diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d56cb93 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +build/ +.DS_Store \ No newline at end of file diff --git a/C++ Wavelet Libraries.webarchive b/C++ Wavelet Libraries.webarchive new file mode 100644 index 0000000..da7ef83 Binary files /dev/null and b/C++ Wavelet Libraries.webarchive differ diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..a446f9c --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,26 @@ +cmake_minimum_required(VERSION 3.15.2) + +# 设置工程名称和语言 +project(LIBWAVELET) + +# 设置库版本号 +set(VERSION_MAJOR 1) +set(VERSION_MINOR 0) + +# 添加源文件地址 +add_subdirectory(src/) + +# 设置安装地址（通过homebrew安装时需要注释掉） +set(CMAKE_INSTALL_PREFIX /usr/local) + +# 构建一个 CPack 安装包 +include (InstallRequiredSystemLibraries) + set(CPACK_OUTPUT_FILE_PREFIX "${PROJECT_SOURCE_DIR}/package") + #set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE") + set(CPACK_PACKAGE_VERSION_MAJOR "${VERSION_MAJOR}") + set(CPACK_PACKAGE_VERSION_MINOR "${VERSION_MINOR}") + #set(CPACK_PACKAGE_VERSION_PATCH "${VERSION_PATCH}") + set(PROJECT_VERSION_FULL ${VERSION_MAJOR}.${VERSION_MINOR}) + set(CPACK_SOURCE_GENERATOR "TGZ") + set(CPACK_SOURCE_PACKAGE_FILE_NAME liblgd-${PROJECT_VERSION_FULL}) +include (CPack) \ No newline at end of file diff --git a/README.md b/README.md index 9a008e7..ee962bd 100644 --- a/README.md +++ b/README.md @@ -12,3 +12,10 @@ Non FFTW Options - See the folders wavelib-nofftw and wavelib-nofftw-vs for opti Recommended Alternatives - A faster , completely self-contained implementation of 1D DWT,SWT and MODWT with BSD license is available at https://github.com/rafat/wavelib Contact - rafat.hsn@gmail.com + + +## Continued By Yi Zhang + +* Update to FFTW-3.3.8 +* Move file from src to src_deprecated +* Copy files from src_MSVC to src \ No newline at end of file diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt new file mode 100644 index 0000000..53aa78f --- /dev/null +++ b/src/CMakeLists.txt @@ -0,0 +1,58 @@ +# 设定源文件文件夹 +aux_source_directory(lib/ WAVELETLIB_SRC) + +# 添加头文件搜索地址 +include_directories(/usr/local/include) + +# 以下部分为例子程序的编译 +# 设置可执行文件的输出地址 +set(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin) + +# 以下部分为库的编译 +# 注意目标名必须唯一 所以不能直接生成相同名称的动态库与静态库 +# 注意此处不必为目标名称添加lib前缀和相应后缀，cmake会自行添加 +add_library(wlet SHARED ${WAVELETLIB_SRC}) +# 首先添加静态库的生成命令 +add_library(wlet_static STATIC ${WAVELETLIB_SRC}) +# 设置静态库的输出名称从而获得与动态库名称相同的静态库 +set_target_properties(wlet_static PROPERTIES OUTPUT_NAME "wlet") +# 设置输出目标属性以同时输出动态库与静态库 +set_target_properties(wlet PROPERTIES CLEAN_DIRECT_OUTPUT 1) +set_target_properties(wlet_static PROPERTIES CLEAN_DIRECT_OUTPUT 1) +# 设置动态库的版本号 +set_target_properties(wlet PROPERTIES VERSION 1.0 SOVERSION 1.0) +# 设置库文件的输出地址 +set(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib) + +find_library(FFTW_LIB fftw3 HINTS /usr/local/lib) +find_library(FFTW_A_LIB libfftw3.a HINTS /usr/local/lib) +target_link_libraries(wlet PUBLIC ${FFTW_LIB}) +target_link_libraries(wlet_static ${FFTW_A_LIB}) + +# 设置编译选项 +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --std=c++11 -O2") + +# 库的安装命令 +install(TARGETS wlet wlet_static + LIBRARY DESTINATION lib + ARCHIVE DESTINATION lib) +# 头文件安装命令 +install(FILES lib/wlet.h DESTINATION include) + +# 添加示例程序编译宏 +macro(add_sample name) + # 添加头文件搜索地址 + include_directories(/usr/local/include/opencv4) + # 添加可执行文件 命令行 + add_executable(${name} sample/${name}.cpp) + # 为安装文件添加动态库的搜索地址 + set_target_properties(${name} PROPERTIES INSTALL_RPATH "/usr/local/lib") + # 链接动态库 + target_link_libraries(${name} PUBLIC wlet) +endmacro() + +# 添加例子 +add_sample(swtdemo) +#add_sample(swt2Ddemo) +#add_sample(wavedemo) +#add_sample(imagedemo) diff --git a/src/lib/wlet2d.cpp b/src/lib/wlet2d.cpp new file mode 100644 index 0000000..e96ce36 --- /dev/null +++ b/src/lib/wlet2d.cpp @@ -0,0 +1,5665 @@ +//============================================================================ +// Name : 1D/2D Wavelet Transform +// Author : Rafat Hussain +// Version : +// Copyright : GNU GPL License +// Description : Wavelet Library +//============================================================================ +/* + * Copyright (c) 2011 Rafat Hussain + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version.This program also uses FFTW3 library + * for high speed computation and it is being distributed in accordance + * with GNU-GPL license ver 2.0 + * For FFTW3 copyright information, see the FFTW3 folder. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +#define WAVE_EXPORT + +#include +#include +#include +#include +#include +#include +#include + +#include "wlet2d.h" +#include "fftw3.h" + +using namespace std; + +fftw_plan plan_forward_inp,plan_forward_filt, plan_backward; +static unsigned int transient_size_of_fft = 0; + +void* per_ext2d(vector > &signal,vector > &temp2, int a) { + + unsigned int rows = signal.size(); + unsigned int cols = signal[0].size(); + int cols2; + if ((cols % 2) != 0) { + cols2 = cols + 1; + } else { + cols2 = cols; + } + vector > temp_vec(rows ,vector(cols2 + 2* a)); + // vector > temp2(rows + 2 * a ,vector(cols + 2* a)); + + for (unsigned int i=0; i < rows; i++) { + vector sig; + for (unsigned int j=0; j< cols; j++) { + double temp = signal[i][j]; + sig.push_back(temp); + } + per_ext(sig,a); + for (unsigned int j=0; j< sig.size(); j++) { + temp_vec[i][j] = sig[j]; + } + } + for (unsigned int j=0; j < temp_vec[0].size(); j++) { + vector sig; + for (unsigned int i=0; i< rows; i++) { + double temp = temp_vec[i][j]; + sig.push_back(temp); + } + per_ext(sig,a); + for (unsigned int i=0; i< sig.size(); i++) { + temp2[i][j] = sig[i]; + } + } + + + return 0; +} + +void* swt_2d(vector > &sig,int J, string nm, vector &swt_output) { + int m_size = sig.size(); // No. of rows + int n_size = sig[0].size(); //No. of columns + + vector > sig2 =sig; + + int rows_n =m_size; + int cols_n =n_size; + vector lp1,hp1,lp2,hp2; + filtcoef(nm,lp1,hp1,lp2,hp2); + + for (int iter =0; iter < J; iter++) { + int U = (int) pow(2.0,(double)iter); + vector low_pass, high_pass; + if(iter > 0) { + upsamp(lp1,U,low_pass); + upsamp(hp1,U,high_pass); + } else { + low_pass = lp1; + high_pass = hp1; + } + int lf = low_pass.size(); + + if ((sig.size() % 2) == 0 ) { + rows_n = sig.size(); + } else { + rows_n = sig.size() + 1; + } + + if ((sig[0].size() % 2) == 0 ) { + cols_n = sig[0].size(); + } else { + cols_n = sig[0].size() + 1; + } + + vector > signal(rows_n + lf,vector(cols_n+lf)); + // per_ext2d(sig,signal,lf/2); Edit per_ext if you want to use per_ext2d. Remove + // the even indexing. + + per_ext2d(sig,signal,lf/2); + int len_x = signal.size(); + int len_y = signal[0].size(); + vector > sigL(rows_n + lf,vector(cols_n)); + vector > sigH(rows_n + lf,vector(cols_n)); + vector > cA(rows_n,vector(cols_n)); + vector > cH(rows_n,vector(cols_n)); + vector > cV(rows_n,vector(cols_n)); + vector > cD(rows_n,vector(cols_n)); + + for (int i=0; i < len_x; i++) { + vector temp_row; + for (int j=0; j < len_y; j++) { + double temp = signal[i][j]; + temp_row.push_back(temp); + + } + + // ------------------Low Pass Branch-------------------------- + + + vector oup; + convfftm(temp_row,low_pass,oup); + oup.erase(oup.begin(), oup.begin()+lf); + oup.erase(oup.begin()+cols_n,oup.end()); + + // ------------------High Pass Branch-------------------------- + + vector oup2; + convfftm(temp_row,high_pass,oup2); + oup2.erase(oup2.begin(), oup2.begin()+lf); + oup2.erase(oup2.begin()+cols_n,oup2.end()); + + temp_row.clear(); + + for (unsigned int j=0; j < oup.size() ; j++) { + sigL[i][j] = oup[j]; + sigH[i][j] = oup2[j]; + } + + } + + for (int j=0; j < cols_n; j++) { + vector temp_row; + for (int i=0; i < len_x; i++){ + double temp = sigL[i][j]; + temp_row.push_back(temp); + } + + // ------------------Low Pass Branch-------------------------- + + + vector oup; + convfftm(temp_row,low_pass,oup); + oup.erase(oup.begin(), oup.begin()+lf); + oup.erase(oup.begin()+rows_n,oup.end()); + + // ------------------High Pass Branch-------------------------- + + vector oup2; + convfftm(temp_row,high_pass,oup2); + oup2.erase(oup2.begin(), oup2.begin()+lf); + oup2.erase(oup2.begin()+rows_n,oup2.end()); + + temp_row.clear(); + + + for (unsigned int i=0; i < oup.size() ; i++) { + cA[i][j] = oup[i]; + } + + for (unsigned int i=0; i < oup2.size() ; i++) { + cH[i][j] = oup2[i]; + } + + + } + + for (int j=0; j < cols_n; j++) { + vector temp_row; + for (int i=0; i < len_x; i++){ + double temp = sigH[i][j]; + temp_row.push_back(temp); + } + + // ------------------Low Pass Branch-------------------------- + + + vector oup; + convfftm(temp_row,low_pass,oup); + oup.erase(oup.begin(), oup.begin()+lf); + oup.erase(oup.begin()+rows_n,oup.end()); + + // ------------------High Pass Branch-------------------------- + + vector oup2; + convfftm(temp_row,high_pass,oup2); + oup2.erase(oup2.begin(), oup2.begin()+lf); + oup2.erase(oup2.begin()+rows_n,oup2.end()); + + temp_row.clear(); + + + for (unsigned int i=0; i < oup.size() ; i++) { + cV[i][j] = oup[i]; + } + + for (unsigned int i=0; i < oup2.size() ; i++) { + cD[i][j] = oup2[i]; + } + + + } + + sig = cA; + vector temp_sig2; + + if (iter == J-1) { + for(int i =0; i < rows_n; i++){ + for (int j =0; j < cols_n; j++){ + double temp=cA[i][j]; + temp_sig2.push_back(temp); + } + } + } + for(int i =0; i < rows_n; i++){ + for (int j = cols_n; j < cols_n * 2; j++){ + double temp =cH[i][j - cols_n]; + temp_sig2.push_back(temp); + } + } + + for(int i = rows_n; i < rows_n * 2; i++){ + for (int j =0; j < cols_n; j++){ + double temp=cV[i - rows_n][j]; + temp_sig2.push_back(temp); + } + } + + for(int i = rows_n; i < rows_n * 2; i++){ + for (int j = cols_n; j < cols_n * 2; j++){ + double temp =cD[i- rows_n][j - cols_n]; + temp_sig2.push_back(temp); + } + } + + swt_output.insert(swt_output.begin(),temp_sig2.begin(),temp_sig2.end()); + + + + } + + + return 0; +} + + +void* per_ext(vector &sig, int a) { + unsigned int len; + len = sig.size(); + if ((len % 2) != 0 ) { + double temp = sig[len-1]; + sig.push_back(temp); + len = sig.size(); + } + + for (int i=0; i < a; i++) { + double temp1 = sig[2 *i]; + double temp2 = sig[len-1]; + sig.insert(sig.begin(), temp2); + sig.insert(sig.end(), temp1); + + } + + return 0; + +} + + +void* iswt(vector &swtop,int J, string nm, vector &iswt_output) { + int N = swtop.size() / (J + 1); + + vector lpd,hpd,lpr,hpr; + filtcoef(nm,lpd,hpd,lpr,hpr); + + vector appx_sig; + + vector low_pass = lpr; + vector high_pass = hpr; + int lf = low_pass.size(); + + for (int iter = 0; iter < J; iter++) { + vector det_sig; + if (iter ==0) { + for (int i = 0; i < N; i++) { + double temp=swtop[i]; + appx_sig.push_back(temp); + double temp1=swtop[(iter + 1) * N + i]; + det_sig.push_back(temp1); + } + } else { + for (int i = 0; i < N; i++) { + double temp1=swtop[(iter + 1) * N + i]; + det_sig.push_back(temp1); + + } + } + + + int value =(int) pow(2.0,double(J -1 -iter)); + iswt_output.assign(N,0.0); + + for (int count = 0; count < value; count++) { + vector appx1, det1; + for (int index = count; index < N; index+=value){ + double temp = appx_sig[index]; + appx1.push_back(temp); + double temp1 = det_sig[index]; + det1.push_back(temp1); + + } + unsigned int len = appx1.size(); + + // Shift = 0 + + vector appx2, det2; + + for (unsigned int index_shift =0; index_shift < len; index_shift+=2) { + double temp = appx1[index_shift]; + appx2.push_back(temp); + double temp1 = det1[index_shift]; + det2.push_back(temp1); + } + + int U = 2; // Upsampling Factor + + vector cL0,cH0; + upsamp(appx2,U,cL0); + upsamp(det2,U,cH0); + per_ext(cL0,lf/2); + per_ext(cH0,lf/2); + + vector oup00L, oup00H, oup00; + convfft(cL0,low_pass,oup00L); + convfft(cH0,high_pass,oup00H); + + oup00L.erase(oup00L.begin(),oup00L.begin()+lf - 1); + oup00L.erase(oup00L.begin()+len,oup00L.end()); + oup00H.erase(oup00H.begin(),oup00H.begin()+lf - 1); + oup00H.erase(oup00H.begin()+len,oup00H.end()); + + vecsum(oup00L,oup00H,oup00); + + // Shift = 1 + + vector appx3, det3; + + for (unsigned int index_shift =1; index_shift < len; index_shift+=2) { + double temp = appx1[index_shift]; + appx3.push_back(temp); + double temp1 = det1[index_shift]; + det3.push_back(temp1); + } + + + vector cL1,cH1; + upsamp(appx3,U,cL1); + upsamp(det3,U,cH1); + per_ext(cL1,lf/2); + per_ext(cH1,lf/2); + + vector oup01L, oup01H, oup01; + convfft(cL1,low_pass,oup01L); + convfft(cH1,high_pass,oup01H); + + oup01L.erase(oup01L.begin(), oup01L.begin()+lf - 1); + oup01L.erase(oup01L.begin()+len,oup01L.end()); + oup01H.erase(oup01H.begin(), oup01H.begin()+lf - 1); + oup01H.erase(oup01H.begin()+len,oup01H.end()); + + vecsum(oup01L,oup01H,oup01); + circshift(oup01,-1); + + // Continue + int index2 = 0; + for (int index = count; index < N; index+=value){ + double temp = oup00[index2]+oup01[index2]; + iswt_output.at(index) = temp/2; + index2++; + + } + + + } + appx_sig = iswt_output; + + + } + return 0; +} + +void* swt(vector &signal1, int J, string nm, vector &swt_output, int &length) { + vector lpd, hpd, lpr, hpr; + vector sig; + sig = signal1; + int N = sig.size(); + length = N; + + filtcoef(nm,lpd,hpd,lpr,hpr); + + for (int iter = 0; iter < J; iter++) { + vector low_pass; + vector high_pass; + if ( iter > 0){ + + int M = (int) pow(2.0,iter); + upsamp(lpd,M,low_pass); + upsamp(hpd,M,high_pass); + + + } else { + low_pass = lpd; + high_pass = hpd; + } + + unsigned int len_filt = low_pass.size(); + per_ext(sig,len_filt/2); + + vector cA; + convfft(sig,low_pass,cA); + vector cD; + convfft(sig,high_pass,cD); + // Resize cA and cD + cA.erase(cA.begin(), cA.begin()+len_filt); + cA.erase(cA.begin()+N,cA.end()); + cD.erase(cD.begin(), cD.begin()+len_filt); + cD.erase(cD.begin()+N,cD.end()); + // Reset signal value; + + sig = cA; + + if (iter == J - 1 ) { + swt_output.insert(swt_output.begin(),cD.begin(),cD.end()); + swt_output.insert(swt_output.begin(),cA.begin(),cA.end()); + } else { + swt_output.insert(swt_output.begin(),cD.begin(),cD.end()); + } + + } + + return 0; +} + +void* dwt_output_dim_sym(vector &length,vector &length2, int J) { + unsigned int sz=length.size(); + int rows = length[sz-2]; + int cols = length[sz-1]; + for (int i =0; i < J; i++) { + rows =(int) ceil((double) rows/ 2.0); + cols =(int) ceil((double) cols/ 2.0); + } + for (int i =0; i < J + 1; i++) { + length2.push_back(rows); + length2.push_back(cols); + rows = rows * 2; + cols = cols*2; + } + return 0; +} + +void* dwt_output_dim2(vector &length, vector &length2, int J) { + + int row = length[0]; + int col = length[1]; + + for (int i=0; i < J + 1; i++) { + + length2.push_back(row); + length2.push_back(col); + row = row * 2; + col = col * 2; + + + } + + + return 0; +} + +void* dispDWT(vector &output,vector > &dwtdisp, vector &length , vector &length2, int J) { + int sum = 0; + + + for (int iter =0; iter < J; iter++) { + int d_rows=length[2*iter]-length2[2*iter]; + int d_cols=length[2*iter+1]-length2[2*iter + 1]; + + + int rows_n =length[2 * iter]; + int cols_n = length[2 * iter + 1]; + vector > dwt_output(2 * rows_n, vector(2 * cols_n)); + if (iter == 0) { + for(int i =0; i < rows_n; i++){ + for (int j =0; j < cols_n; j++){ + dwt_output[i][j]=output[i*cols_n + j]; + } + } + + for(int i =0; i < rows_n; i++){ + for (int j = cols_n; j < cols_n * 2; j++){ + dwt_output[i][j]= output[rows_n * cols_n + i * cols_n + (j - cols_n)]; + } + } + + for(int i = rows_n; i < rows_n * 2; i++){ + for (int j =0; j < cols_n; j++){ + dwt_output[i][j]=output[2 * rows_n * cols_n+ (i - rows_n) * cols_n + j]; + } + } + + + for(int i = rows_n; i < rows_n * 2; i++){ + for (int j = cols_n; j < cols_n * 2; j++){ + dwt_output[i][j]=output[3 * rows_n * cols_n+ (i -rows_n) * cols_n + (j -cols_n)]; + } + } + } else { + for(int i =0; i < rows_n; i++){ + for (int j = cols_n; j < cols_n * 2; j++){ + dwt_output[i][j]= output[sum + i * cols_n + (j - cols_n)]; + } + } + + for(int i = rows_n; i < rows_n * 2; i++){ + for (int j =0; j < cols_n; j++){ + dwt_output[i][j]=output[sum + rows_n * cols_n+ (i - rows_n) * cols_n + j]; + } + } + + + for(int i = rows_n; i < rows_n * 2; i++){ + for (int j = cols_n; j < cols_n * 2; j++){ + dwt_output[i][j]=output[sum + 2 * rows_n * cols_n+ (i -rows_n) * cols_n + (j -cols_n)]; + } + } + + } + + int rows_x = length2[2*iter]; + int cols_x =length2[2*iter +1]; + + int d_cols2 = (int) ceil( (double) (d_cols - 1) / 2.0); + int d_rows2 = (int) ceil( (double) (d_rows - 1) / 2.0); + if (iter ==0) { + for(int i =0; i < rows_x; i++){ + for (int j =0; j < cols_x; j++){ + if (i + d_rows -1 < 0){ + dwtdisp[i][j]=0; + } + else if (j + d_cols -1 < 0){ + dwtdisp[i][j]=0; + } else { + dwtdisp[i][j]=dwt_output[i+d_rows -1][j+d_cols -1]; + } + } + } + } + for(int i =0; i < rows_x; i++){ + for (int j = cols_x; j < cols_x * 2; j++){ + if (i + d_rows2 < 0){ + dwtdisp[i][j]=0; + } + else if (j + 2* (d_cols -1) +1 > (signed) dwt_output[0].size() - 1){ + dwtdisp[i][j]=0; + } else { + dwtdisp[i][j]= dwt_output[i+d_rows2 ][j + 2* (d_cols -1)+1 ]; + } + } + } + + for(int i = rows_x; i < rows_x * 2; i++){ + for (int j =0; j < cols_x; j++){ + if (i + 2* (d_rows -1) + 1 > (signed) dwt_output.size() - 1){ + dwtdisp[i][j]=0; + } + else if (j + d_cols2 < 0){ + dwtdisp[i][j]=0; + } else { + + dwtdisp[i][j]=dwt_output[i+2 * (d_rows - 1) + 1 ][j+d_cols2 ]; + } + } + } + + for(int i = rows_x; i < rows_x * 2; i++){ + for (int j = cols_x; j < cols_x * 2; j++){ + + if (i + (d_rows -1) + 1 + d_rows2 > (signed) dwt_output.size() - 1){ + dwtdisp[i][j]=0; + } + else if (j + (d_cols -1) + 1 + d_cols2 > (signed) dwt_output[0].size() - 1){ + dwtdisp[i][j]=0; + } else { + dwtdisp[i][j]=dwt_output[i + (d_rows -1) + 1 + d_rows2 ][j + (d_cols -1) + 1 + d_cols2 ]; + } + } + } + if (iter == 0) { + sum+= 4*rows_n*cols_n; + } else { + sum+= 3*rows_n * cols_n; + } + + } + + return 0; + +} + +void symm_ext2d(vector > &signal,vector > &temp2, int a) { + unsigned int rows = signal.size(); + unsigned int cols = signal[0].size(); + vector > temp_vec(rows ,vector(cols + 2* a)); +// vector > temp2(rows + 2 * a ,vector(cols + 2* a)); + + for (unsigned int i=0; i < rows; i++) { + vector sig; + for (unsigned int j=0; j< cols; j++) { + double temp = signal[i][j]; + sig.push_back(temp); + } + symm_ext(sig,a); + for (unsigned int j=0; j< sig.size(); j++) { + temp_vec[i][j] = sig[j]; + } + } + for (unsigned int j=0; j < temp_vec[0].size(); j++) { + vector sig; + for (unsigned int i=0; i< rows; i++) { + double temp = temp_vec[i][j]; + sig.push_back(temp); + } + symm_ext(sig,a); + for (unsigned int i=0; i< sig.size(); i++) { + temp2[i][j] = sig[i]; + } + } + +} + +void* circshift2d(vector > &signal, int x, int y) { + unsigned int rows = signal.size(); + unsigned int cols = signal[0].size(); + vector > temp_vec(rows,vector(cols)); + + for (unsigned int i=0; i < rows; i++) { + vector sig; + for (unsigned int j=0; j< cols; j++) { + double temp = signal[i][j]; + sig.push_back(temp); + } + circshift(sig,x); + for (unsigned int j=0; j< cols; j++) { + temp_vec[i][j] = sig[j]; + } + } + + for (unsigned int j=0; j < cols; j++) { + vector sig; + for (unsigned int i=0; i< rows; i++) { + double temp = temp_vec[i][j]; + sig.push_back(temp); + } + circshift(sig,y); + for (unsigned int i=0; i< rows; i++) { + signal[i][j] = sig[i]; + } + } + return 0; +} + +void* idwt_2d_sym(vector &dwtop,vector &flag, string nm, + vector > &idwt_output, vector &length){ + int J =(int) flag[0]; + int rows =length[0]; + int cols =length[1]; + + int sum_coef =0; + vector lp1,hp1,lp2,hp2; + filtcoef(nm,lp1,hp1,lp2,hp2); + unsigned int lf = lp1.size(); + vector > cLL(rows, vector(cols)); + + + for (int iter=0; iter < J; iter++) { + + int rows_n = length[2*iter]; + int cols_n = length[2*iter + 1]; + + vector > cLH(rows_n, vector(cols_n)); + vector > cHL(rows_n, vector(cols_n)); + vector > cHH(rows_n, vector(cols_n)); + + for (int i = 0 ; i < rows_n; i++ ){ + for (int j = 0; j < cols_n; j++){ + if (iter == 0) { + cLL[i][j] = dwtop[sum_coef+ i * cols_n + j]; + + cLH[i][j] = dwtop[sum_coef+ rows_n * cols_n+ i * cols_n + j]; + + cHL[i][j] = dwtop[sum_coef+ 2 * rows_n * cols_n + i * cols_n + j]; + + cHH[i][j] = dwtop[sum_coef+ 3* rows_n * cols_n + i * cols_n + j]; + } else { + + cLH[i][j] = dwtop[sum_coef+ i * cols_n + j]; + + cHL[i][j] = dwtop[sum_coef+ rows_n * cols_n + i * cols_n + j]; + + cHH[i][j] = dwtop[sum_coef+ 2* rows_n * cols_n + i * cols_n + j]; + + } + } + } + + + // temp_A = cLL; + // idwt2_sym(nm,idwt_output2, cA, cH,cV,cD); + + unsigned int len_x = cLH.size(); + unsigned int len_y = cLH[0].size(); + + // Row Upsampling and Column Filtering at the first LP Stage + vector > cL(2 *len_x - lf + 2,vector(len_y )); + vector > cH(2 * len_x - lf +2,vector(len_y )); + + if (iter ==0) { + for (unsigned int j =0; j < len_y; j++) { + + vector sigLL,sigLH,oup; + + for (unsigned int i=0;i < len_x;i++) { + + double temp1 = cLL[i][j]; + double temp2 = cLH[i][j]; + sigLL.push_back(temp1); + sigLH.push_back(temp2); + } + idwt1_sym_m(nm,oup,sigLL,sigLH); + + for (int i=0;i < (int) oup.size();i++) { + cL[i][j] = oup[i]; + } + + } + } else{ + unsigned int rows1 =cLH.size(); + unsigned int cols1 =cLH[0].size(); + + for (unsigned int j =0; j < cols1;j++){ + vector temp_L1,temp_L2,oup; + for (unsigned int i =0; i < rows1; i++){ + double temp = cLL[i][j]; + temp_L1.push_back(temp); + + double temp2 = cLH[i][j]; + temp_L2.push_back(temp2); + } + idwt1_sym_m(nm,oup,temp_L1,temp_L2); + + for (unsigned int i =0; i < oup.size(); i++){ + cL[i][j]=oup[i]; + } + + } + } + + + for (unsigned int j =0; j < len_y; j++) { + vector sigHL,sigHH,oup2; + for (unsigned int i=0;i < len_x;i++) { + double temp3 = cHL[i][j]; + double temp4 = cHH[i][j]; + sigHL.push_back(temp3); + sigHH.push_back(temp4); + } + idwt1_sym_m(nm,oup2,sigHL,sigHH); + + for (int i=0;i < (int) oup2.size();i++) { + cH[i][j] = oup2[i]; + } + + } + + vector > signal(2*len_x-lf +2,vector(2 *len_y - lf +2 )); + for (unsigned int i =0; i < 2 * len_x - lf +2; i++) { + vector sigL,sigH,oup; + for (unsigned int j=0;j < len_y;j++) { + double temp5 = cL[i][j]; + double temp6 = cH[i][j]; + sigL.push_back(temp5); + sigH.push_back(temp6); + } + idwt1_sym_m(nm,oup,sigL,sigH); + + for (int j=0;j < (int) oup.size();j++) { + signal[i][j] = oup[j]; + } + + } + + + idwt_output = signal; + + + + if (iter ==0) { + sum_coef+= 4 *rows_n * cols_n; + } else { + sum_coef+= 3 *rows_n * cols_n; + } + cLL = signal; + + + } + + + return 0; +} + + +void* dwt2_sym(string name,vector > &signal, vector > &cLL, + vector > &cLH, vector > &cHL, vector > &cHH){ +//Analysis + int rows = signal.size(); + int cols = signal[0].size(); + int cols_lp1 = cLL[0].size(); + int cols_hp1 = cLL[0].size(); + vector lp1,hp1,lp2,hp2; + filtcoef(name, lp1,hp1,lp2,hp2); + vector > lp_dn1(rows, vector( cols_lp1)); + vector > hp_dn1(rows, vector( cols_hp1)); + + // Implementing row filtering and column downsampling in each branch. + for (int i =0; i < rows; i++) { + vector temp_row,oup_lp,oup_hp; + for (int j=0;j < cols;j++) { + double temp = signal[i][j]; + temp_row.push_back(temp); + } + dwt1_sym_m(name,temp_row,oup_lp,oup_hp); + + for (int j=0;j < (int) oup_lp.size();j++) { + lp_dn1[i][j] = oup_lp[j]; + hp_dn1[i][j] = oup_hp[j]; + + } + + } + + + cols =cols_lp1; + // Implementing column filtering and row downsampling in Low Pass branch. + + for (int j =0; j < cols; j++) { + vector temp_row3,oup_lp,oup_hp; + for (int i=0;i < rows;i++) { + double temp = lp_dn1[i][j]; + temp_row3.push_back(temp); + } + dwt1_sym_m(name,temp_row3,oup_lp,oup_hp); + + for (int i=0;i < (int) oup_lp.size();i++) { + cLL[i][j] = oup_lp[i]; + cLH[i][j] = oup_hp[i]; + + } + + + } + + + + // Implementing column filtering and row downsampling in High Pass branch. + + for (int j =0; j < cols; j++) { + vector temp_row5,oup_lp,oup_hp; + for (int i=0;i < rows;i++) { + double temp = hp_dn1[i][j]; + temp_row5.push_back(temp); + } + dwt1_sym_m(name,temp_row5,oup_lp,oup_hp); + + for (int i=0;i < (int) oup_lp.size();i++) { + cHL[i][j] = oup_lp[i]; + cHH[i][j] = oup_hp[i]; + + } + + + } + return 0; +} + + +void* dwt_2d_sym(vector > &origsig, int J, string nm, vector &dwt_output + , vector &flag , vector &length) { + + vector > sig = origsig; + int rows_n = sig.size(); // No. of rows + int cols_n = sig[0].size(); //No. of columns + vector > original_copy(rows_n,vector(cols_n)); + + original_copy = sig; + int Max_Iter; + Max_Iter = min((int) ceil(log( double(sig.size()))/log (2.0)),(int) ceil(log( double(sig[0].size()))/log (2.0))); + if ( Max_Iter < J) { + cout << J << " Iterations are not possible with signals of this dimension " << endl; + exit(1); + } + vector lp1,hp1,lp2,hp2; + + flag.push_back(double(J)); + + + length.insert(length.begin(),cols_n); + length.insert(length.begin(),rows_n); + + + // Flag Values + /* + double temp = (double) (sig2.size() - sig.size()); // Number of zeropad rows + flag.push_back(temp); + double temp2 = (double) (sig2[0].size() - sig[0].size());// Number of zpad cols + flag.push_back(temp2); + flag.push_back((double) J); // Number of Iterations + */ + int sum_coef = 0; + for (int iter = 0; iter < J; iter++) { + filtcoef(nm,lp1,hp1,lp2,hp2); + unsigned int lf = lp1.size(); + + rows_n =(int) floor((double)(rows_n + lf -1)/2); + cols_n =(int) floor((double) (cols_n + lf -1)/2); + length.insert(length.begin(),cols_n); + length.insert(length.begin(),rows_n); + + vector > cA(rows_n, vector(cols_n)); + vector > cH(rows_n, vector(cols_n)); + vector > cV(rows_n, vector(cols_n)); + vector > cD(rows_n, vector(cols_n)); + + + dwt2_sym(nm,original_copy,cA,cH,cV,cD); + vector temp_sig2; + + original_copy = cA; + if (iter == J-1) { + for(int i =0; i < rows_n; i++){ + for (int j =0; j < cols_n; j++){ + double temp=cA[i][j]; + temp_sig2.push_back(temp); + } + } + } + for(int i =0; i < rows_n; i++){ + for (int j = cols_n; j < cols_n * 2; j++){ + double temp =cH[i][j - cols_n]; + temp_sig2.push_back(temp); + } + } + + for(int i = rows_n; i < rows_n * 2; i++){ + for (int j =0; j < cols_n; j++){ + double temp=cV[i - rows_n][j]; + temp_sig2.push_back(temp); + } + } + + for(int i = rows_n; i < rows_n * 2; i++){ + for (int j = cols_n; j < cols_n * 2; j++){ + double temp =cD[i- rows_n][j - cols_n]; + temp_sig2.push_back(temp); + } + } + + dwt_output.insert(dwt_output.begin(),temp_sig2.begin(),temp_sig2.end()); + sum_coef += 4 * rows_n * cols_n; + + + + } +/* + ofstream dwt2out("dwt2out.dat"); + for (unsigned int i= 0; i < dwt_output.size(); i++){ + dwt2out << dwt_output[i] < &X, vector &app, vector &detail) { + + // Not Tested. Use dwt_sym and idwt_sym for any and all computations + vector dwtop; + vector flag; + vector idwt_output; + vector length; + length[0] = app.size(); + length[1] = detail.size(); + dwtop = app; + dwtop.insert(dwtop.end(),detail.begin(),detail.end()); + flag.push_back(1); + flag.push_back(0); + idwt_sym(dwtop,flag,wname,idwt_output,length); + X = idwt_output; + + return 0; +} + +void* idwt1_sym_m(string wname, vector &idwt_output, vector &app, vector &detail) { + + int U = 2; // Upsampling Factor + vector lpd1,hpd1, lpr1, hpr1; + + filtcoef(wname,lpd1,hpd1,lpr1,hpr1); + int lf = lpr1.size(); + + + // Operations in the Low Frequency branch of the Synthesis Filter Bank + vector X_lp; + vector cA_up; + upsamp(app, U,cA_up ); + cA_up.pop_back(); + convfftm(cA_up, lpr1, X_lp); + + + + // Operations in the High Frequency branch of the Synthesis Filter Bank + + vector X_hp; + vector cD_up; + upsamp(detail, U, cD_up); + cD_up.pop_back(); + convfftm(cD_up, hpr1, X_hp); + + + vecsum(X_lp,X_hp,idwt_output); + + idwt_output.erase(idwt_output.begin(),idwt_output.begin()+lf-2); + idwt_output.erase(idwt_output.end()-(lf - 2),idwt_output.end()); + + return 0; +} + + +void* symm_ext(vector &sig, int a) { + unsigned int len = sig.size(); + for (int i =0; i < a; i++) { + double temp1= sig[i * 2]; + double temp2= sig[len - 1]; + sig.insert(sig.begin(),temp1); + sig.insert(sig.end(),temp2); + } + + return 0; + +} + +void* idwt_sym(vector &dwtop,vector &flag, string nm, + vector &idwt_output, vector &length) { + + int J =(int) flag[1]; + unsigned int lf; + + vector app; + vector detail; + unsigned int app_len = length[0]; + unsigned int det_len = length[1]; + + vector::iterator dwt; + dwt = dwtop.begin(); + app.assign(dwt,dwtop.begin()+app_len); + detail.assign(dwtop.begin()+app_len, dwtop.begin()+ 2* app_len); + + for (int i = 0; i < J; i++) { + + int U = 2; // Upsampling Factor + vector lpd1,hpd1, lpr1, hpr1; + + filtcoef(nm,lpd1,hpd1,lpr1,hpr1); + lf = lpr1.size(); + + + // Operations in the Low Frequency branch of the Synthesis Filter Bank + vector X_lp; + vector cA_up; + upsamp(app, U,cA_up ); + cA_up.pop_back(); + convfft(cA_up, lpr1, X_lp); + + + + // Operations in the High Frequency branch of the Synthesis Filter Bank + + vector X_hp; + vector cD_up; + upsamp(detail, U, cD_up); + cD_up.pop_back(); + convfft(cD_up, hpr1, X_hp); + + + app_len += det_len; + vecsum(X_lp,X_hp,idwt_output); + + idwt_output.erase(idwt_output.begin(),idwt_output.begin()+lf-2); + idwt_output.erase(idwt_output.end()-(lf - 2),idwt_output.end()); + + app.clear(); + detail.clear(); + if ( i < J - 1 ) { + det_len = length[i+2]; + // detail.assign(dwtop.begin()+app_len, dwtop.begin()+ det_len); + + for (unsigned int l = 0; l < det_len;l++) { + double temp = dwtop[app_len + l]; + detail.push_back(temp); + } + + } + app = idwt_output; + + for (int iter1 = 0; iter1 < (int) (app.size() - det_len);iter1++) { + app.pop_back(); + } + + } + + + // Remove ZeroPadding + + int zerop =(int) flag[0]; + idwt_output.erase(idwt_output.end()- zerop,idwt_output.end()); + return 0; +} + +void* dwt1_sym(string wname, vector &signal, vector &cA, vector &cD) { + + vector lp1, hp1, lp2, hp2; + + filtcoef(wname,lp1,hp1,lp2,hp2); + int D = 2; // Downsampling Factor is 2 + int lf = lp1.size(); + symm_ext(signal,lf-1); + + vector cA_undec; + //sig value + convfft(signal,lp1,cA_undec); + cA_undec.erase(cA_undec.begin(),cA_undec.begin()+lf); + cA_undec.erase(cA_undec.end()-lf+1,cA_undec.end()); + downsamp(cA_undec, D, cA); + // cA.erase(cA.begin(),cA.begin()+(int) ceil(((double)lf-1.0)/2.0)); + // cA.erase(cA.end()-(int) ceil(((double)lf-1.0)/2.0),cA.end()); + + + //High Pass Branch Computation + + vector cD_undec; + convfft(signal,hp1,cD_undec); + cD_undec.erase(cD_undec.begin(),cD_undec.begin()+lf); + cD_undec.erase(cD_undec.end()-lf+1,cD_undec.end()); + downsamp(cD_undec,D,cD); + // cD.erase(cD.begin(),cD.begin()+(int) ceil(((double)lf-1.0)/2.0)); + // cD.erase(cD.end()-(int) ceil(((double)lf-1.0)/2.0),cD.end()); + + filtcoef(wname,lp1,hp1,lp2,hp2); + + return 0; +} + +void* dwt1_sym_m(string wname, vector &signal, vector &cA, vector &cD) { + + vector lp1, hp1, lp2, hp2; + + filtcoef(wname,lp1,hp1,lp2,hp2); + int D = 2; // Downsampling Factor is 2 + int lf = lp1.size(); + symm_ext(signal,lf-1); + + vector cA_undec; + //sig value + convfftm(signal,lp1,cA_undec); + cA_undec.erase(cA_undec.begin(),cA_undec.begin()+lf); + cA_undec.erase(cA_undec.end()-lf+1,cA_undec.end()); + downsamp(cA_undec, D, cA); + // cA.erase(cA.begin(),cA.begin()+(int) ceil(((double)lf-1.0)/2.0)); + // cA.erase(cA.end()-(int) ceil(((double)lf-1.0)/2.0),cA.end()); + + + //High Pass Branch Computation + + vector cD_undec; + convfftm(signal,hp1,cD_undec); + cD_undec.erase(cD_undec.begin(),cD_undec.begin()+lf); + cD_undec.erase(cD_undec.end()-lf+1,cD_undec.end()); + downsamp(cD_undec,D,cD); + // cD.erase(cD.begin(),cD.begin()+(int) ceil(((double)lf-1.0)/2.0)); + // cD.erase(cD.end()-(int) ceil(((double)lf-1.0)/2.0),cD.end()); + + filtcoef(wname,lp1,hp1,lp2,hp2); + + return 0; +} + +void* dwt_sym(vector &signal, int J,string nm, vector &dwt_output, + vector &flag, vector &length){ + + unsigned int temp_len = signal.size(); + if ( (temp_len % 2) != 0) { + double temp =signal[temp_len - 1]; + signal.push_back(temp); + flag.push_back(1); + temp_len++; + } else { + flag.push_back(0); + } + length.push_back(temp_len); + flag.push_back(double(J)); + // flag[2] contains symmetric extension length + + + vector original_copy, appx_sig, det_sig; + original_copy = signal; + + // Storing Filter Values for GnuPlot + vector lp1,hp1,lp2,hp2; + filtcoef(nm,lp1,hp1,lp2,hp2); + for (int iter = 0; iter < J; iter++) { + dwt1_sym(nm,signal, appx_sig, det_sig); + dwt_output.insert(dwt_output.begin(),det_sig.begin(),det_sig.end()); + int l_temp = det_sig.size(); + length.insert(length.begin(),l_temp); + + if (iter == J-1 ) { + dwt_output.insert(dwt_output.begin(),appx_sig.begin(),appx_sig.end()); + int l_temp = appx_sig.size(); + length.insert(length.begin(),l_temp); + + } + + signal.clear(); + signal = appx_sig; + appx_sig.clear(); + det_sig.clear(); + + } + signal = original_copy; + +return 0; +} + + +void* freq(vector &sig, vector &freq_resp) { + unsigned int K = sig.size(); + unsigned int N = (unsigned int) pow(2.0,ceil(log10 (static_cast(K))/log10(2.0))); + vector > fft_oup; + for (unsigned int i =0; i < sig.size(); i++) { + double temp = sig[i]; + fft_oup.push_back(complex(temp,0)); + } + fft(fft_oup,1,N); + + for (unsigned int i = 0; i < N; i++){ + double temp = abs(fft_oup[i]); + freq_resp.push_back(temp); + } + circshift(freq_resp, N/2); + return 0; +} + +double convfft(vector &a, vector &b, vector &c) { + fftw_complex *inp_data, *filt_data, *inp_fft, *filt_fft, *temp_data, *temp_ifft; + fftw_plan plan_forward_inp,plan_forward_filt, plan_backward; + + unsigned int sz = a.size() + b.size() - 1; + inp_data = ( fftw_complex* ) fftw_malloc( sizeof( fftw_complex ) * sz ); + filt_data = ( fftw_complex* ) fftw_malloc( sizeof( fftw_complex ) * sz ); + + inp_fft = ( fftw_complex* ) fftw_malloc( sizeof( fftw_complex ) * sz ); + filt_fft = ( fftw_complex* ) fftw_malloc( sizeof( fftw_complex ) * sz ); + + temp_data = ( fftw_complex* ) fftw_malloc( sizeof( fftw_complex ) * sz ); + temp_ifft = ( fftw_complex* ) fftw_malloc( sizeof( fftw_complex ) * sz ); + + plan_forward_inp = fftw_plan_dft_1d( sz, inp_data, inp_fft, FFTW_FORWARD, FFTW_ESTIMATE ); + plan_forward_filt = fftw_plan_dft_1d( sz, filt_data, filt_fft, FFTW_FORWARD, FFTW_ESTIMATE ); + plan_backward = fftw_plan_dft_1d( sz, temp_data, temp_ifft, FFTW_BACKWARD, FFTW_ESTIMATE ); + + + for (unsigned int i =0; i < sz; i++) { + if (i < a.size()) { + inp_data[i][0] = a[i]; + } else { + inp_data[i][0] = 0.0; + + } + inp_data[i][1] = 0.0; + if (i < b.size()) { + filt_data[i][0] = b[i]; + } else { + filt_data[i][0] = 0.0; + + } + filt_data[i][1] = 0.0; + + } + + + + fftw_execute(plan_forward_inp); + + fftw_execute(plan_forward_filt); + + for (unsigned int i =0; i < sz; i++){ + temp_data[i][0] = inp_fft[i][0]*filt_fft[i][0] - inp_fft[i][1]*filt_fft[i][1]; + + temp_data[i][1] = inp_fft[i][0]*filt_fft[i][1] + inp_fft[i][1]*filt_fft[i][0]; + + + + } + + + fftw_execute(plan_backward); + + for (unsigned int i = 0; i < sz; i++) { + double temp1; + temp1 = temp_ifft[i][0] / (double) sz; + c.push_back(temp1); + + } + fftw_free(inp_data); + fftw_free(filt_data); + fftw_free(inp_fft); + fftw_free(filt_fft); + fftw_free(temp_data); + fftw_free(temp_ifft); + fftw_destroy_plan(plan_forward_inp); + fftw_destroy_plan(plan_forward_filt); + fftw_destroy_plan(plan_backward); + + return 0; +} + +double convfftm(vector &a, vector &b, vector &c) { + fftw_complex *inp_data, *filt_data, *inp_fft, *filt_fft, *temp_data, *temp_ifft; + + unsigned int sz = a.size() + b.size() - 1; + inp_data = ( fftw_complex* ) fftw_malloc( sizeof( fftw_complex ) * sz ); + filt_data = ( fftw_complex* ) fftw_malloc( sizeof( fftw_complex ) * sz ); + + inp_fft = ( fftw_complex* ) fftw_malloc( sizeof( fftw_complex ) * sz ); + filt_fft = ( fftw_complex* ) fftw_malloc( sizeof( fftw_complex ) * sz ); + + temp_data = ( fftw_complex* ) fftw_malloc( sizeof( fftw_complex ) * sz ); + temp_ifft = ( fftw_complex* ) fftw_malloc( sizeof( fftw_complex ) * sz ); + + if (sz != transient_size_of_fft) { + + if (transient_size_of_fft != 0) { + fftw_destroy_plan(plan_forward_inp); + fftw_destroy_plan(plan_forward_filt); + fftw_destroy_plan(plan_backward); + } + + plan_forward_inp = fftw_plan_dft_1d( sz, inp_data, inp_fft, FFTW_FORWARD, FFTW_MEASURE ); + plan_forward_filt = fftw_plan_dft_1d( sz, filt_data, filt_fft, FFTW_FORWARD, FFTW_MEASURE ); + plan_backward = fftw_plan_dft_1d( sz, temp_data, temp_ifft, FFTW_BACKWARD, FFTW_MEASURE ); + transient_size_of_fft = sz; + +} + + for (unsigned int i =0; i < sz; i++) { + if (i < a.size()) { + inp_data[i][0] = a[i]; + } else { + inp_data[i][0] = 0.0; + + } + inp_data[i][1] = 0.0; + if (i < b.size()) { + filt_data[i][0] = b[i]; + } else { + filt_data[i][0] = 0.0; + + } + filt_data[i][1] = 0.0; + + } + + + fftw_execute_dft( plan_forward_inp,inp_data, inp_fft); + fftw_execute_dft( plan_forward_filt,filt_data, filt_fft); + + + + for (unsigned int i =0; i < sz; i++){ + temp_data[i][0] = inp_fft[i][0]*filt_fft[i][0] - inp_fft[i][1]*filt_fft[i][1]; + + temp_data[i][1] = inp_fft[i][0]*filt_fft[i][1] + inp_fft[i][1]*filt_fft[i][0]; + + + + } + + fftw_execute_dft( plan_backward, temp_data, temp_ifft); + + + for (unsigned int i = 0; i < sz; i++) { + double temp1; + temp1 = temp_ifft[i][0] / (double) sz; + c.push_back(temp1); + + } + fftw_free(inp_data); + fftw_free(filt_data); + fftw_free(inp_fft); + fftw_free(filt_fft); + fftw_free(temp_data); + fftw_free(temp_ifft); + + return 0; +} + +void* fft(vector > &data, int sign,unsigned int N){ + double pi = - 3.14159265358979; + if ( sign == 1 || sign == -1) { + pi = sign * pi; + } else { + cout << "Format fft(data, num), num = +1(fft) and num = -1 (Ifft)" << endl; + exit(1); + } + unsigned int len = data.size(); + vector >::iterator it; + it = data.end(); + if ( len != N) { + unsigned int al = N - len; + data.insert(it,al,complex(0,0)); + } + + unsigned int K = (unsigned int) pow(2.0,ceil(log10(static_cast(N))/log10(2.0))); + vector >::iterator it1; + it1 = data.end(); + if ( N < K) { + unsigned int al = K - N; + data.insert(it1,al,complex(0,0)); + N = K; + } + + bitreverse(data); + +// radix2(data); + for (unsigned int iter = 1; iter < N; iter <<=1) + { + const unsigned int step = iter << 1; + + const double theta = pi / double(iter); + + double wtemp = sin(theta * .5); + // Multipliers + double wreal = -2 * wtemp * wtemp; + double wimag = sin(theta); + + // Factors + double wr = 1.0; + double wi = 0.0; + // Iteration through two loops + + for (unsigned int m = 0; m < iter; m++) + { + // Iteration within m + for (unsigned int i = m; i < N; i += step) + { + // jth position + const unsigned int j = i + iter; + + double tempr= wr * real(data[j]) - wi * imag(data[j]); + double tempi= wr * imag(data[j]) + wi * real(data[j]); + + complex temp(tempr,tempi); + data[j]= data[i]- temp; + data[i] += temp; + + } + // Twiddle Factors updated + wtemp = wr; + wr += wr * wreal - wi * wimag; + wi += wi * wreal + wtemp * wimag ; + } + + } + + if ( sign == -1) { + double scale = 1.0/double(N); + for (unsigned int i = 0; i < N; i++){ + data[i]*=scale; + } + } + + + + // Place holder + return 0; +} + + +void* bitreverse(vector > &sig) { + unsigned int len = sig.size(); + unsigned int N = (unsigned int) pow(2.0,ceil(log10(static_cast(len))/log10(2.0))); + unsigned int rev = 0; + // Processing Input Data + for (unsigned int iter = 0; iter < N; ++iter) + { + if (rev > iter) + { + // Replacing current values with reversed values + + double tempr = real(sig[rev]); + double tempi = imag(sig[rev]); + complex temp(tempr,tempi); + sig[rev] = sig[iter]; + sig[iter] = temp; + + } + // Using filter "filt" such that the value of reverse changes with each iteration + unsigned int filt = N; + while (rev & (filt >>= 1)) { + rev &= ~filt; + } + rev |= filt; + } + return 0; + +} + + +void* dwt(vector &sig, int J, string nm, vector &dwt_output + , vector &flag, vector &length ) { + + int Max_Iter; + Max_Iter = (int) ceil(log( double(sig.size()))/log (2.0)) - 2; + + if ( Max_Iter < J) { + J = Max_Iter; + + } + + vector original_copy,orig, appx_sig, det_sig; + original_copy = sig; + + // Zero Pad the Signal to nearest 2^ M value ,where M is an integer. + unsigned int temp_len = sig.size(); + if ( (temp_len % 2) != 0) { + double temp =sig[temp_len - 1]; + sig.push_back(temp); + flag.push_back(1); + temp_len++; + } else { + flag.push_back(0); + } + length.push_back(temp_len); + flag.push_back(double(J)); + + orig = sig; + + + // Storing Filter Values for GnuPlot + vector lp1,hp1,lp2,hp2; + filtcoef(nm,lp1,hp1,lp2,hp2); + + + for (int iter = 0; iter < J; iter++) { + dwt1(nm,orig, appx_sig, det_sig); + dwt_output.insert(dwt_output.begin(),det_sig.begin(),det_sig.end()); + + int l_temp = det_sig.size(); + length.insert(length.begin(),l_temp); + + if (iter == J-1 ) { + dwt_output.insert(dwt_output.begin(),appx_sig.begin(),appx_sig.end()); + int l_temp2 = appx_sig.size(); + length.insert(length.begin(),l_temp2); + + } + + orig = appx_sig; + appx_sig.clear(); + det_sig.clear(); + + } + + sig = original_copy; + return 0; +} + + +void circshift(vector &sig_cir, int L){ + if ( abs(L) >(signed int) sig_cir.size()) { + L = sign(L) * (abs(L) % sig_cir.size()); + } + + if ( L < 0 ){ + L = (sig_cir.size() + L) % sig_cir.size(); + // cout << "L" << L << endl; + } + for (int i = 0; i < L; i++){ + sig_cir.push_back(sig_cir[0]); + sig_cir.erase(sig_cir.begin()); + } + +} + +double convol(vector &a1, vector &b1, vector &c) { + unsigned int len_c = a1.size() + b1.size() - 1; + vector a = a1; + vector b = b1; + double* oup= NULL; + + oup = new double[len_c]; + vector::iterator a_it; + a_it = a.end(); + signed int al = len_c - a.size(); + a.insert(a_it,al,0); + + + vector::iterator b_it; + b_it = b.end(); + signed int bl = len_c - b.size(); + b.insert(b_it,bl, 0); + + + for (unsigned int ini = 0; ini < len_c ; ini++){ + double ou1 = 0; + oup[ini] = 0; + double temp = 0; + for (unsigned int jni = 0; jni <= ini; jni++) { + ou1 = a[jni] * b[ini - jni]; + oup[ini]+= ou1; + } + temp = oup[ini]; + c.push_back(temp); + } + delete [] oup; + oup = NULL; + return 0; +} + +void downsamp(vector &sig, int M, vector &sig_d){ + int len = sig.size(); + double len_n = ceil( (double) len / (double) M); + for (int i = 0; i < (int) len_n; i++) { + double temp = sig[i*M]; + sig_d.push_back(temp); + } +} + + + + + +void* dwt1(string wname, vector &signal, vector &cA, vector &cD) { + + vector lpd, hpd, lpr, hpr; + + filtcoef(wname,lpd,hpd,lpr,hpr); + + int len_lpfilt = lpd.size(); + int len_hpfilt = hpd.size(); + int len_avg = (len_lpfilt + len_hpfilt) / 2; + int len_sig = 2 * (int) ceil((double) signal.size() / 2.0); + + per_ext(signal,len_avg / 2); // Periodic Extension + + vector cA_undec; + // convolving signal with lpd, Low Pass Filter, and O/P is stored in cA_undec + convfft(signal,lpd,cA_undec); + int D = 2; // Downsampling Factor is 2 + cA_undec.erase(cA_undec.begin(),cA_undec.begin()+len_avg-1); + cA_undec.erase(cA_undec.end()-len_avg+1,cA_undec.end()); + cA_undec.erase(cA_undec.begin()+len_sig,cA_undec.end()); + cA_undec.erase(cA_undec.begin()); + + + // Downsampling by 2 gives cA + downsamp(cA_undec, D, cA); + + vector cD_undec; + // convolving signal with lpd, Low Pass Filter, and O/P is stored in cA_undec + convfft(signal,hpd,cD_undec); + cD_undec.erase(cD_undec.begin(),cD_undec.begin()+len_avg-1); + cD_undec.erase(cD_undec.end()-len_avg+1,cD_undec.end()); + cD_undec.erase(cD_undec.begin()+len_sig,cD_undec.end()); + cD_undec.erase(cD_undec.begin()); + + // Downsampling Factor is 2 + + // Downsampling by 2 gives cA + downsamp(cD_undec, D, cD); + + filtcoef(wname,lpd,hpd,lpr,hpr); + + return 0; +} + +void* dwt1_m(string wname, vector &signal, vector &cA, vector &cD) { + + vector lpd, hpd, lpr, hpr; + + filtcoef(wname,lpd,hpd,lpr,hpr); + + int len_lpfilt = lpd.size(); + int len_hpfilt = hpd.size(); + int len_avg = (len_lpfilt + len_hpfilt) / 2; + int len_sig = 2 * (int) ceil((double) signal.size() / 2.0); + + // cout << len_lpfilt << "Filter" << endl; + per_ext(signal,len_avg / 2); // Periodic Extension + // computations designed to deal with boundary distortions + + // Low Pass Filtering Operations in the Analysis Filter Bank Section +// int len_cA =(int) floor(double (len_sig + len_lpfilt -1) / double (2)); + vector cA_undec; + // convolving signal with lpd, Low Pass Filter, and O/P is stored in cA_undec + convfftm(signal,lpd,cA_undec); + int D = 2; // Downsampling Factor is 2 + cA_undec.erase(cA_undec.begin(),cA_undec.begin()+len_avg-1); + cA_undec.erase(cA_undec.end()-len_avg+1,cA_undec.end()); + cA_undec.erase(cA_undec.begin()+len_sig,cA_undec.end()); + cA_undec.erase(cA_undec.begin()); + + + // Downsampling by 2 gives cA + downsamp(cA_undec, D, cA); + + // cA.erase(cA.begin(),cA.begin()+len_avg/2); + // cA.erase(cA.end()-len_avg/2,cA.end()); + + // High Pass Filtering Operations in the Analysis Filter Bank Section +// int len_cA =(int) floor(double (len_sig + len_lpfilt -1) / double (2)); + + vector cD_undec; + // convolving signal with lpd, Low Pass Filter, and O/P is stored in cA_undec + convfftm(signal,hpd,cD_undec); + cD_undec.erase(cD_undec.begin(),cD_undec.begin()+len_avg-1); + cD_undec.erase(cD_undec.end()-len_avg+1,cD_undec.end()); + cD_undec.erase(cD_undec.begin()+len_sig,cD_undec.end()); + cD_undec.erase(cD_undec.begin()); + + // Downsampling Factor is 2 + + // Downsampling by 2 gives cA + downsamp(cD_undec, D, cD); + + // cD.erase(cD.begin(),cD.begin()+len_avg/2); + // cD.erase(cD.end()-len_avg/2,cD.end()); + + filtcoef(wname,lpd,hpd,lpr,hpr); + + return 0; +} + + +void* dyadic_zpad_1d(vector &signal) { + unsigned int N = signal.size(); + double M = log10 (static_cast (N)) / log10(2.0); + int D = (int) ceil(M); + double int_val = pow(2.0, double(D)) - pow(2.0, M); + + int z = (int) int_val; + vector::iterator a_it; + a_it = signal.end(); + double val = signal[N-1]; + // double val = 0; + signal.insert(a_it,z,val); + return 0; + +} + + +void* idwt(vector &dwtop,vector &flag, string nm, + vector &idwt_output,vector &length) { + + int J =(int) flag[1]; + // int zpad =(int) flag[0]; + + + vector app; + vector detail; + unsigned int app_len = length[0]; + unsigned int det_len = length[1]; + + vector::iterator dwt; + dwt = dwtop.begin(); + app.assign(dwt,dwtop.begin()+app_len); + detail.assign(dwtop.begin()+app_len, dwtop.begin()+ 2* app_len); + + for (int i = 0; i < J; i++) { + + idwt1(nm,idwt_output, app,detail); + app_len +=det_len; + app.clear(); + detail.clear(); + if ( i < J - 1 ) { + det_len = length[i+2]; + for (unsigned int l = 0; l < det_len;l++) { + double temp = dwtop[app_len + l]; + detail.push_back(temp); + } + app = idwt_output; + + if (app.size() >= detail.size()){ + int t = app.size() - detail.size(); + int lent = (int) floor((double)t/2.0); + app.erase(app.begin()+detail.size()+lent,app.end()); + app.erase(app.begin(),app.begin()+lent); + } + } + + + } + + + // Remove ZeroPadding + + int zerop =(int) flag[0]; + idwt_output.erase(idwt_output.end()- zerop,idwt_output.end()); + + return 0; +} + +void* idwt1_m(string wname, vector &X, vector &cA, vector &cD) { + vector lpd1,hpd1, lpr1, hpr1; + + filtcoef(wname,lpd1,hpd1,lpr1,hpr1); + int len_lpfilt = lpr1.size(); + int len_hpfilt = hpr1.size(); + int len_avg = (len_lpfilt + len_hpfilt) / 2; + unsigned int N = 2 * cD.size(); + int U = 2; // Upsampling Factor + + // Operations in the Low Frequency branch of the Synthesis Filter Bank + + vector cA_up; + vector X_lp; + // int len1 = cA_up.size(); + upsamp(cA, U, cA_up); + + per_ext(cA_up,len_avg/2); + + + convfftm(cA_up, lpr1, X_lp); + + + // Operations in the High Frequency branch of the Synthesis Filter Bank + + vector cD_up; + vector X_hp; + upsamp(cD, U, cD_up); + per_ext(cD_up,len_avg/2); + + + convfftm(cD_up, hpr1, X_hp); + + + X_lp.erase(X_lp.begin()+N+len_avg-1,X_lp.end()); + X_lp.erase(X_lp.begin(),X_lp.begin()+len_avg-1); + + X_hp.erase(X_hp.begin()+N+len_avg-1,X_hp.end()); + X_hp.erase(X_hp.begin(),X_hp.begin()+len_avg-1); + + + vecsum(X_lp,X_hp,X); + + + return 0; +} + +void* idwt1(string wname, vector &X, vector &cA, vector &cD) { + vector lpd1,hpd1, lpr1, hpr1; + + filtcoef(wname,lpd1,hpd1,lpr1,hpr1); + int len_lpfilt = lpr1.size(); + int len_hpfilt = hpr1.size(); + int len_avg = (len_lpfilt + len_hpfilt) / 2; + unsigned int N = 2 * cD.size(); + int U = 2; // Upsampling Factor + + // Operations in the Low Frequency branch of the Synthesis Filter Bank + + vector cA_up; + vector X_lp; + // int len1 = cA_up.size(); + upsamp(cA, U, cA_up); + + per_ext(cA_up,len_avg/2); + + + convfft(cA_up, lpr1, X_lp); + + + // Operations in the High Frequency branch of the Synthesis Filter Bank + + vector cD_up; + vector X_hp; + upsamp(cD, U, cD_up); + per_ext(cD_up,len_avg/2); + + + convfft(cD_up, hpr1, X_hp); + + // Remove periodic extension + + // X.erase(X.begin(),X.begin()+len_avg+len_avg/2-1); + // X.erase(X.end()-len_avg-len_avg/2,X.end()); + + + X_lp.erase(X_lp.begin()+N+len_avg-1,X_lp.end()); + X_lp.erase(X_lp.begin(),X_lp.begin()+len_avg-1); + + X_hp.erase(X_hp.begin()+N+len_avg-1,X_hp.end()); + X_hp.erase(X_hp.begin(),X_hp.begin()+len_avg-1); + + + vecsum(X_lp,X_hp,X); + + + return 0; +} + +int sign(int X) { + if (X >= 0) + return 1; + else + return -1; +} + +void upsamp(vector &sig, int M, vector &sig_u) { + int len = sig.size(); + double len_n = ceil( (double) len * (double) M); + + for (int i = 0; i < (int) len_n; i++) { + if ( i % M == 0) { + double temp = sig[i / M]; + sig_u.push_back(temp); + + } + else + { + sig_u.push_back(0); + } + + } + + + +} + +double op_sum(double i, double j) { + return (i+j); +} + +int vecsum(vector &a, vector &b, vector &c){ + + + c.resize(a.size()); + transform (a.begin(), a.end(), b.begin(), b.begin(), op_sum); + c = b; + return 0; +} + +void* getcoeff2d(vector > &dwtoutput, vector > &cH, + vector > &cV,vector > &cD,vector &flag, int &N) { + if (N > flag[2]) { + cout << "Signal is decimated only up to " << flag[2] << " levels" << endl; + exit(1); + } + int rows = dwtoutput.size(); + int cols = dwtoutput[0].size(); + // Getting Horizontal Coefficients + int r = (int) ceil((double) rows /pow(2.0,N)) ; + int c = (int) ceil((double) cols /pow(2.0,N)) ; + + for (int i =0; i < (int) ceil ((double) rows /pow(2.0,N)); i++){ + for (int j =0; j < (int) ceil ((double) cols /pow(2.0,N)); j++) { + cH[i][j]=dwtoutput[i][c+ j]; + } + } + + + for (int i =0; i < (int) ceil ((double) rows /pow(2.0,N)); i++){ + for (int j =0; j < (int) ceil ((double) cols /pow(2.0,N)); j++) { + cV[i][j]=dwtoutput[i + r][j]; + } + } + + for (int i =0; i < (int) ceil ((double) rows /pow(2.0,N)); i++){ + for (int j =0; j < (int) ceil ((double) cols /pow(2.0,N)); j++) { + cD[i][j]=dwtoutput[i + r][c+ j]; + } + } + + return 0; +} + +void* zero_remove(vector > &input,vector > &output) { + int zero_rows = output.size()-input.size(); + int zero_cols = output[0].size()-input[0].size(); + + vector >::iterator row = output.end()-zero_rows; + + + unsigned int ousize = output.size(); + for (unsigned int i = input.size(); i < ousize; i++){ + output.erase(row); + row++; + + } + +// unsigned int ousize2 = output[0].size(); + + + for (unsigned int i = 0; i < ousize; i++){ + vector ::iterator col = output[i].end()-zero_cols; + + output[i].erase(col, output[i].end()); + + } + return 0; +} + +void* dwt_output_dim(vector >&signal, int &r, int &c ){ + int rows =signal.size(); + int cols = signal[0].size(); + + double Mr = log10 (static_cast (rows)) / log10(2.0); + int Dr = (int) ceil(Mr); + double int_val_row = pow(2.0, double(Dr)); + int r1 = (int) int_val_row; + + double Mc = log10 (static_cast (cols)) / log10(2.0); + int Dc = (int) ceil(Mc); + double int_val_cols = pow(2.0, double(Dc)); + int c1 = (int) int_val_cols; + r=max(r1,c1); + c=max(r1,c1); + + return 0; + +} + +void* dyadic_zpad_2d(vector > &signal,vector > &mod){ + int rows =signal.size(); + int cols = signal[0].size(); + + for (int i=0; i < rows; i++) { + for (int j = 0; j < cols; j++){ + mod[i][j] = signal[i][j]; + } + + } + // Zeropadding the columns + + double Mr = log10 (static_cast (rows)) / log10(2.0); + int Dr = (int) ceil(Mr); + double int_val_row = pow(2.0, double(Dr)) - pow(2.0, Mr); + + int zeros_row = (int) int_val_row; + + double Mc = log10 (static_cast (cols)) / log10(2.0); + int Dc = (int) ceil(Mc); + double int_val_cols = pow(2.0, double(Dc)) - pow(2.0, Mc); + + int zeros_cols = (int) int_val_cols; + + for (int i=0; i < rows + zeros_row; i++) { + for (int j = cols; j < cols+zeros_cols; j++){ + + mod[i][j] = 0; + } + + } + + for (int i= rows; i < rows + zeros_row; i++) { + for (int j = 0; j < cols+zeros_cols; j++){ + mod[i][j] = 0; + } + + } + + return 0; + +} + +void* idwt_2d(vector &dwtop,vector &flag, string nm, + vector > &idwt_output, vector &length){ + int J =(int) flag[0]; + int rows =length[0]; + int cols =length[1]; + + int sum_coef =0; + vector lp1,hp1,lp2,hp2; + filtcoef(nm,lp1,hp1,lp2,hp2); + vector > cLL(rows, vector(cols)); + + + for (int iter=0; iter < J; iter++) { + + int rows_n = length[2*iter]; + int cols_n = length[2*iter + 1]; + + vector > cLH(rows_n, vector(cols_n)); + vector > cHL(rows_n, vector(cols_n)); + vector > cHH(rows_n, vector(cols_n)); + + for (int i = 0 ; i < rows_n; i++ ){ + for (int j = 0; j < cols_n; j++){ + if (iter == 0) { + cLL[i][j] = dwtop[sum_coef+ i * cols_n + j]; + + cLH[i][j] = dwtop[sum_coef+ rows_n * cols_n+ i * cols_n + j]; + + cHL[i][j] = dwtop[sum_coef+ 2 * rows_n * cols_n + i * cols_n + j]; + + cHH[i][j] = dwtop[sum_coef+ 3* rows_n * cols_n + i * cols_n + j]; + } else { + + cLH[i][j] = dwtop[sum_coef+ i * cols_n + j]; + + cHL[i][j] = dwtop[sum_coef+ rows_n * cols_n + i * cols_n + j]; + + cHH[i][j] = dwtop[sum_coef+ 2* rows_n * cols_n + i * cols_n + j]; + + } + } + } + + + // temp_A = cLL; + // idwt2_sym(nm,idwt_output2, cA, cH,cV,cD); + + unsigned int len_x = cLH.size(); + unsigned int len_y = cLH[0].size(); + + // Row Upsampling and Column Filtering at the first LP Stage + vector > cL(2 *len_x,vector(len_y )); + vector > cH(2 * len_x ,vector(len_y )); + + if (iter ==0) { + for (unsigned int j =0; j < len_y; j++) { + + vector sigLL,sigLH,oup; + + for (unsigned int i=0;i < len_x;i++) { + + double temp1 = cLL[i][j]; + double temp2 = cLH[i][j]; + sigLL.push_back(temp1); + sigLH.push_back(temp2); + } + idwt1_m(nm,oup,sigLL,sigLH); + + for (int i=0;i < (int) oup.size();i++) { + cL[i][j] = oup[i]; + } + + } + } else{ + unsigned int rows1 =cLH.size(); + unsigned int cols1 =cLH[0].size(); + + for (unsigned int j =0; j < cols1;j++){ + vector temp_L1,temp_L2,oup; + for (unsigned int i =0; i < rows1; i++){ + double temp = cLL[i][j]; + temp_L1.push_back(temp); + + double temp2 = cLH[i][j]; + temp_L2.push_back(temp2); + } + idwt1_m(nm,oup,temp_L1,temp_L2); + + for (unsigned int i =0; i < oup.size(); i++){ + cL[i][j]=oup[i]; + } + + } + } + + + for (unsigned int j =0; j < len_y; j++) { + vector sigHL,sigHH,oup2; + for (unsigned int i=0;i < len_x;i++) { + double temp3 = cHL[i][j]; + double temp4 = cHH[i][j]; + sigHL.push_back(temp3); + sigHH.push_back(temp4); + } + idwt1_m(nm,oup2,sigHL,sigHH); + + for (int i=0;i < (int) oup2.size();i++) { + cH[i][j] = oup2[i]; + } + + } + + vector > signal(2*len_x,vector(2 *len_y )); + for (unsigned int i =0; i < 2 * len_x ; i++) { + vector sigL,sigH,oup; + for (unsigned int j=0;j < len_y;j++) { + double temp5 = cL[i][j]; + double temp6 = cH[i][j]; + sigL.push_back(temp5); + sigH.push_back(temp6); + } + idwt1_m(nm,oup,sigL,sigH); + + for (int j=0;j < (int) oup.size();j++) { + signal[i][j] = oup[j]; + } + + } + + idwt_output = signal; + + + + if (iter ==0) { + sum_coef+= 4 *rows_n * cols_n; + } else { + sum_coef+= 3 *rows_n * cols_n; + } + cLL = signal; + + + } + + + return 0; +} + + + +void* dwt_2d(vector > &origsig, int J, string nm, vector &dwt_output + , vector &flag , vector &length) { +// flag will contain + + vector > sig = origsig; + int rows_n = sig.size(); // No. of rows + int cols_n = sig[0].size(); //No. of columns + vector > original_copy(rows_n,vector(cols_n)); + + original_copy = sig; + int Max_Iter; + Max_Iter = min((int) ceil(log( double(sig.size()))/log (2.0)),(int) ceil(log( double(sig[0].size()))/log (2.0))); + if ( Max_Iter < J) { + cout << J << " Iterations are not possible with signals of this dimension " << endl; + exit(1); + } + vector lp1,hp1,lp2,hp2; + + flag.push_back(double(J)); + flag.push_back(0); + + + length.insert(length.begin(),cols_n); + length.insert(length.begin(),rows_n); + + + int sum_coef = 0; + for (int iter = 0; iter < J; iter++) { + filtcoef(nm,lp1,hp1,lp2,hp2); + + rows_n =(int) ceil((double)rows_n /2.0); + cols_n =(int) ceil((double) cols_n/2.0); + length.insert(length.begin(),cols_n); + length.insert(length.begin(),rows_n); + + vector > cA(rows_n, vector(cols_n)); + vector > cH(rows_n, vector(cols_n)); + vector > cV(rows_n, vector(cols_n)); + vector > cD(rows_n, vector(cols_n)); + + if (iter == 0) { + dwt2(nm,original_copy,cA,cH,cV,cD); + } else { + dwt2(nm,original_copy,cA,cH,cV,cD); + + } + vector temp_sig2; + + original_copy = cA; + if (iter == J-1) { + for(int i =0; i < rows_n; i++){ + for (int j =0; j < cols_n; j++){ + double temp=cA[i][j]; + temp_sig2.push_back(temp); + } + } + } + for(int i =0; i < rows_n; i++){ + for (int j = cols_n; j < cols_n * 2; j++){ + double temp =cH[i][j - cols_n]; + temp_sig2.push_back(temp); + } + } + + for(int i = rows_n; i < rows_n * 2; i++){ + for (int j =0; j < cols_n; j++){ + double temp=cV[i - rows_n][j]; + temp_sig2.push_back(temp); + } + } + + for(int i = rows_n; i < rows_n * 2; i++){ + for (int j = cols_n; j < cols_n * 2; j++){ + double temp =cD[i- rows_n][j - cols_n]; + temp_sig2.push_back(temp); + } + } + + dwt_output.insert(dwt_output.begin(),temp_sig2.begin(),temp_sig2.end()); + sum_coef += 4 * rows_n * cols_n; + + + + } + + return 0; + +} + + + +void* branch_lp_hp_up(string wname,vector &cA, vector &cD, vector &X) { + vector lpd1,hpd1, lpr1, hpr1; + + filtcoef(wname,lpd1,hpd1,lpr1,hpr1); + int len_lpfilt = lpr1.size(); + int len_hpfilt = hpr1.size(); + int len_avg = (len_lpfilt + len_hpfilt) / 2; + //unsigned int N = 2 * cA.size(); + int U = 2; // Upsampling Factor + + // Operations in the Low Frequency branch of the Synthesis Filter Bank + + vector cA_up; + vector X_lp; + per_ext(cA,len_avg/2); + + upsamp(cA, U, cA_up); + convfftm(cA_up, lpr1, X_lp); + + + // Operations in the High Frequency branch of the Synthesis Filter Bank + + vector cD_up; + vector X_hp; + per_ext(cD,len_avg/2); + upsamp(cD, U, cD_up); + convfftm(cD_up, hpr1, X_hp); + + + + + vecsum(X_lp,X_hp,X); + // Remove periodic extension + + X.erase(X.begin(),X.begin()+len_avg+len_avg/2-1); + X.erase(X.end()-len_avg-len_avg/2,X.end()); + + return 0; +} + +void* branch_hp_dn(string wname, vector &signal, vector &sigop) { + + vector lpd, hpd, lpr, hpr; + + filtcoef(wname,lpd,hpd,lpr,hpr); + // for (unsigned int i = 0; i < signal.size(); i++) { + // cout << signal[i] << endl; + // out2 << signal[i] < cA_undec; + // convolving signal with lpd, Low Pass Filter, and O/P is stored in cA_undec + convfftm(signal,hpd,cA_undec); + int D = 2; // Downsampling Factor is 2 + + // Downsampling by 2 gives cA + downsamp(cA_undec, D, sigop); + + sigop.erase(sigop.begin(),sigop.begin()+len_avg/2); + sigop.erase(sigop.end()-len_avg/2,sigop.end()); +return 0; + + + +} +void* branch_lp_dn(string wname, vector &signal, vector &sigop){ + + vector lpd, hpd, lpr, hpr; + + filtcoef(wname,lpd,hpd,lpr,hpr); + // for (unsigned int i = 0; i < signal.size(); i++) { + // cout << signal[i] << endl; + // out2 << signal[i] < cA_undec; + // convolving signal with lpd, Low Pass Filter, and O/P is stored in cA_undec + convfftm(signal,lpd,cA_undec); + int D = 2; // Downsampling Factor is 2 + + // Downsampling by 2 gives cA + downsamp(cA_undec, D, sigop); + + sigop.erase(sigop.begin(),sigop.begin()+len_avg/2); + sigop.erase(sigop.end()-len_avg/2,sigop.end()); + + +return 0; + +} + +void* idwt2(string name,vector > &signal, vector > &cLL, + vector > &cLH, vector > &cHL, vector > &cHH) { +// Synthesis + int rows= cLL.size(); + int cols= cLL[0].size(); + int rows_n = 2 * rows; + // Row Upsampling and Column Filtering at the first LP Stage + vector > cL(rows_n,vector(cols)); + vector > cH(rows_n,vector(cols)); + + for (int j =0; j < cols; j++) { + + vector sigLL; + vector sigLH; + for (int i=0;i < rows;i++) { + + double temp1 = cLL[i][j]; + double temp2 = cLH[i][j]; + sigLL.push_back(temp1); + sigLH.push_back(temp2); + } + vector oup; + + branch_lp_hp_up(name,sigLL,sigLH,oup); + sigLL.clear(); + sigLH.clear(); + for (int i=0;i < (int) oup.size();i++) { + cL[i][j] = oup[i]; + } + + } + + for (int j =0; j < cols; j++) { + vector sigHL; + vector sigHH; + for (int i=0;i < rows;i++) { + double temp3 = cHL[i][j]; + double temp4 = cHH[i][j]; + sigHL.push_back(temp3); + sigHH.push_back(temp4); + } + vector oup2; + branch_lp_hp_up(name,sigHL,sigHH,oup2); + sigHL.clear(); + sigHH.clear(); + + for (int i=0;i < (int) oup2.size();i++) { + cH[i][j] = oup2[i]; + } + + } + + for (int i =0; i < rows_n; i++) { + vector sigL; + vector sigH; + for (int j=0;j < cols;j++) { + double temp5 = cL[i][j];\ + double temp6 = cH[i][j]; + sigL.push_back(temp5); + sigH.push_back(temp6); + } + vector oup3; + branch_lp_hp_up(name,sigL,sigH,oup3); + sigL.clear(); + sigH.clear(); + + for (int j=0;j < (int) oup3.size();j++) { + signal[i][j] = oup3[j]; + } + + } + return 0; +} + +void* dwt2(string name,vector > &signal, vector > &cLL, + vector > &cLH, vector > &cHL, vector > &cHH){ +//Analysis + int rows = signal.size(); + int cols = signal[0].size(); + int cols_lp1 = cLL[0].size(); + int cols_hp1 = cLL[0].size(); + vector lp1,hp1,lp2,hp2; + filtcoef(name, lp1,hp1,lp2,hp2); + vector > lp_dn1(rows, vector( cols_lp1)); + vector > hp_dn1(rows, vector( cols_hp1)); + + // Implementing row filtering and column downsampling in each branch. + for (int i =0; i < rows; i++) { + vector temp_row,oup_lp,oup_hp; + for (int j=0;j < cols;j++) { + double temp = signal[i][j]; + temp_row.push_back(temp); + } + dwt1_m(name,temp_row,oup_lp,oup_hp); + + for (int j=0;j < (int) oup_lp.size();j++) { + lp_dn1[i][j] = oup_lp[j]; + hp_dn1[i][j] = oup_hp[j]; + + } + + } + + + cols =cols_lp1; + // Implementing column filtering and row downsampling in Low Pass branch. + + for (int j =0; j < cols; j++) { + vector temp_row3,oup_lp,oup_hp; + for (int i=0;i < rows;i++) { + double temp = lp_dn1[i][j]; + temp_row3.push_back(temp); + } + dwt1_m(name,temp_row3,oup_lp,oup_hp); + + for (int i=0;i < (int) oup_lp.size();i++) { + cLL[i][j] = oup_lp[i]; + cLH[i][j] = oup_hp[i]; + + } + + + } + + + + // Implementing column filtering and row downsampling in High Pass branch. + + for (int j =0; j < cols; j++) { + vector temp_row5,oup_lp,oup_hp; + for (int i=0;i < rows;i++) { + double temp = hp_dn1[i][j]; + temp_row5.push_back(temp); + } + dwt1_m(name,temp_row5,oup_lp,oup_hp); + + for (int i=0;i < (int) oup_lp.size();i++) { + cHL[i][j] = oup_lp[i]; + cHH[i][j] = oup_hp[i]; + + } + + + } + return 0; +} + + +void* downsamp2(vector > & vec1,vector > & vec2, int rows_dn, int cols_dn) { + + int rows = vec1.size(); + int cols = vec1[0].size(); + double rows_n = ceil( (double) rows / (double) rows_dn); + double cols_n = ceil( (double) cols / (double) cols_dn); + for (int i =0; i < (int)rows_n; i++){ + for (int j = 0; j< (int) cols_n; j++){ + + vec2[i][j] = vec1[i * rows_dn][j*cols_dn]; + } + } + + return 0; +} + +void* upsamp2(vector > & vec1,vector > & vec2, int rows_up, int cols_up){ + + int rows = vec1.size(); + int cols = vec1[0].size(); + int rows_n = rows * rows_up; + int cols_n = cols * cols_up; + for (int i = 0; i < rows_n; i++){ + for (int j = 0; j < cols_n; j++){ + if ( i % rows_up == 0 && j % cols_up == 0){ + vec2[i][j]=vec1[(int) (i/rows_up)][(int) (j/cols_up)]; + } else { + vec2[i][j] = 0; + } +} +} + return 0; +} + + +int filtcoef(string name, vector &lp1, vector &hp1, vector &lp2, + vector &hp2){ + if (name == "haar" || name == "db1" ) { + lp1.push_back(0.7071);lp1.push_back(0.7071); + hp1.push_back(-0.7071);hp1.push_back(0.7071); + lp2.push_back(0.7071);lp2.push_back(0.7071); + hp2.push_back(0.7071);hp2.push_back(-0.7071); + // cout << lp2[1] << endl; +// hpd = {-0.7071, 0.7071}; +// lpr = {0.7071, 0.7071}; +// hpr = {0.7071, -0.7071}; + return 0; + } + else if ( name == "db2"){ + double lp1_a[] = {-0.12940952255092145, 0.22414386804185735, 0.83651630373746899, + 0.48296291314469025}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.48296291314469025, 0.83651630373746899, -0.22414386804185735, + -0.12940952255092145}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.48296291314469025, 0.83651630373746899, 0.22414386804185735, + -0.12940952255092145}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-0.12940952255092145, -0.22414386804185735, 0.83651630373746899, + -0.48296291314469025}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "db3"){ + double lp1_a[] = {0.035226291882100656, -0.085441273882241486, -0.13501102001039084, + 0.45987750211933132, 0.80689150931333875, 0.33267055295095688}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.33267055295095688, 0.80689150931333875, -0.45987750211933132, + -0.13501102001039084, 0.085441273882241486, 0.035226291882100656 }; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.33267055295095688, 0.80689150931333875, 0.45987750211933132, + -0.13501102001039084, -0.085441273882241486, 0.035226291882100656 }; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.035226291882100656, 0.085441273882241486, -0.13501102001039084, + -0.45987750211933132, 0.80689150931333875, -0.33267055295095688 }; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "db4"){ + double lp1_a[] = {-0.010597401784997278, 0.032883011666982945, 0.030841381835986965, + -0.18703481171888114, -0.027983769416983849, 0.63088076792959036, + 0.71484657055254153, 0.23037781330885523 }; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.23037781330885523, 0.71484657055254153, -0.63088076792959036, + -0.027983769416983849, 0.18703481171888114, 0.030841381835986965, + -0.032883011666982945, -0.010597401784997278 }; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.23037781330885523, 0.71484657055254153, 0.63088076792959036, + -0.027983769416983849, -0.18703481171888114, 0.030841381835986965, + 0.032883011666982945, -0.010597401784997278 }; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-0.010597401784997278, -0.032883011666982945, 0.030841381835986965, + 0.18703481171888114, -0.027983769416983849, -0.63088076792959036, + 0.71484657055254153, -0.23037781330885523 }; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "db5"){ + double lp1_a[] = {0.0033357252850015492, -0.012580751999015526, -0.0062414902130117052, + 0.077571493840065148, -0.03224486958502952, -0.24229488706619015, + 0.13842814590110342, 0.72430852843857441, 0.60382926979747287, + 0.16010239797412501 }; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.16010239797412501, 0.60382926979747287, -0.72430852843857441, + 0.13842814590110342, 0.24229488706619015, -0.03224486958502952, + -0.077571493840065148, -0.0062414902130117052, 0.012580751999015526, + 0.0033357252850015492 }; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.16010239797412501, 0.60382926979747287, 0.72430852843857441, + 0.13842814590110342, -0.24229488706619015, -0.03224486958502952, + 0.077571493840065148, -0.0062414902130117052, -0.012580751999015526, + 0.0033357252850015492 }; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.0033357252850015492, 0.012580751999015526, -0.0062414902130117052, + -0.077571493840065148, -0.03224486958502952, 0.24229488706619015, + 0.13842814590110342, -0.72430852843857441, 0.60382926979747287, + -0.16010239797412501 }; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "db6"){ + double lp1_a[] = {-0.0010773010849955799, + 0.0047772575110106514, + 0.0005538422009938016, + -0.031582039318031156, + 0.027522865530016288, + 0.097501605587079362, + -0.12976686756709563, + -0.22626469396516913, + 0.3152503517092432, + 0.75113390802157753, + 0.49462389039838539, + 0.11154074335008017 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.11154074335008017, + 0.49462389039838539, + -0.75113390802157753, + 0.3152503517092432, + 0.22626469396516913, + -0.12976686756709563, + -0.097501605587079362, + 0.027522865530016288, + 0.031582039318031156, + 0.0005538422009938016, + -0.0047772575110106514, + -0.0010773010849955799 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.11154074335008017, + 0.49462389039838539, + 0.75113390802157753, + 0.3152503517092432, + -0.22626469396516913, + -0.12976686756709563, + 0.097501605587079362, + 0.027522865530016288, + -0.031582039318031156, + 0.0005538422009938016, + 0.0047772575110106514, + -0.0010773010849955799 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-0.0010773010849955799, + -0.0047772575110106514, + 0.0005538422009938016, + 0.031582039318031156, + 0.027522865530016288, + -0.097501605587079362, + -0.12976686756709563, + 0.22626469396516913, + 0.3152503517092432, + -0.75113390802157753, + 0.49462389039838539, + -0.11154074335008017 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "db7"){ + double lp1_a[] = {0.00035371380000103988, + -0.0018016407039998328, + 0.00042957797300470274, + 0.012550998556013784, + -0.01657454163101562, + -0.038029936935034633, + 0.080612609151065898, + 0.071309219267050042, + -0.22403618499416572, + -0.14390600392910627, + 0.4697822874053586, + 0.72913209084655506, + 0.39653931948230575, + 0.077852054085062364 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.077852054085062364, + 0.39653931948230575, + -0.72913209084655506, + 0.4697822874053586, + 0.14390600392910627, + -0.22403618499416572, + -0.071309219267050042, + 0.080612609151065898, + 0.038029936935034633, + -0.01657454163101562, + -0.012550998556013784, + 0.0004295779730047027, + 0.0018016407039998328, + 0.00035371380000103988 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.077852054085062364, + 0.39653931948230575, + 0.72913209084655506, + 0.4697822874053586, + -0.14390600392910627, + -0.22403618499416572, + 0.071309219267050042, + 0.080612609151065898, + -0.038029936935034633, + -0.01657454163101562, + 0.012550998556013784, + 0.00042957797300470274, + -0.0018016407039998328, + 0.00035371380000103988 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.00035371380000103988, + 0.0018016407039998328, + 0.00042957797300470274, + -0.01255099855601378, + -0.01657454163101562, + 0.038029936935034633, + 0.080612609151065898, + -0.071309219267050042, + -0.22403618499416572, + 0.14390600392910627, + 0.4697822874053586, + -0.72913209084655506, + 0.39653931948230575, + -0.077852054085062364 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "db8"){ + double lp1_a[] = {-0.00011747678400228192, + 0.00067544940599855677, + -0.00039174037299597711, + -0.0048703529930106603, + 0.0087460940470156547, + 0.013981027917015516, + -0.044088253931064719, + -0.017369301002022108, + 0.12874742662018601, + 0.00047248457399797254, + -0.28401554296242809, + -0.015829105256023893, + 0.58535468365486909, + 0.67563073629801285, + 0.31287159091446592, + 0.054415842243081609 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.054415842243081609, + 0.31287159091446592, + -0.67563073629801285, + 0.58535468365486909, + 0.015829105256023893, + -0.28401554296242809, + -0.00047248457399797254, + 0.12874742662018601, + 0.017369301002022108, + -0.044088253931064719, + -0.013981027917015516, + 0.0087460940470156547, + 0.0048703529930106603, + -0.00039174037299597711, + -0.00067544940599855677, + -0.00011747678400228192 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.054415842243081609, + 0.31287159091446592, + 0.67563073629801285, + 0.58535468365486909, + -0.015829105256023893, + -0.28401554296242809, + 0.00047248457399797254, + 0.12874742662018601, + -0.017369301002022108, + -0.044088253931064719, + 0.013981027917015516, + 0.0087460940470156547, + -0.0048703529930106603, + -0.00039174037299597711, + 0.00067544940599855677, + -0.00011747678400228192 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-0.00011747678400228192, + -0.00067544940599855677, + -0.00039174037299597711, + 0.0048703529930106603, + 0.0087460940470156547, + -0.013981027917015516, + -0.044088253931064719, + 0.017369301002022108, + 0.12874742662018601, + -0.00047248457399797254, + -0.28401554296242809, + 0.015829105256023893, + 0.58535468365486909, + -0.67563073629801285, + 0.31287159091446592, + -0.054415842243081609 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "db9"){ + double lp1_a[] = {3.9347319995026124e-05, + -0.00025196318899817888, + 0.00023038576399541288, + 0.0018476468829611268, + -0.0042815036819047227, + -0.004723204757894831, + 0.022361662123515244, + 0.00025094711499193845, + -0.067632829059523988, + 0.030725681478322865, + 0.14854074933476008, + -0.096840783220879037, + -0.29327378327258685, + 0.13319738582208895, + 0.65728807803663891, + 0.6048231236767786, + 0.24383467463766728, + 0.038077947363167282 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.038077947363167282, + 0.24383467463766728, + -0.6048231236767786, + 0.65728807803663891, + -0.13319738582208895, + -0.29327378327258685, + 0.096840783220879037, + 0.14854074933476008, + -0.030725681478322865, + -0.067632829059523988, + -0.00025094711499193845, + 0.022361662123515244, + 0.004723204757894831, + -0.0042815036819047227, + -0.0018476468829611268, + 0.00023038576399541288, + 0.00025196318899817888, + 3.9347319995026124e-05 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.038077947363167282, + 0.24383467463766728, + 0.6048231236767786, + 0.65728807803663891, + 0.13319738582208895, + -0.29327378327258685, + -0.096840783220879037, + 0.14854074933476008, + 0.030725681478322865, + -0.067632829059523988, + 0.00025094711499193845, + 0.022361662123515244, + -0.004723204757894831, + -0.0042815036819047227, + 0.0018476468829611268, + 0.00023038576399541288, + -0.00025196318899817888, + 3.9347319995026124e-05 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {3.9347319995026124e-05, + 0.00025196318899817888, + 0.00023038576399541288, + -0.0018476468829611268, + -0.0042815036819047227, + 0.004723204757894831, + 0.022361662123515244, + -0.00025094711499193845, + -0.067632829059523988, + -0.030725681478322865, + 0.14854074933476008, + 0.096840783220879037, + -0.29327378327258685, + -0.13319738582208895, + 0.65728807803663891, + -0.6048231236767786, + 0.24383467463766728, + -0.038077947363167282 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "db10"){ + double lp1_a[] = {-1.3264203002354869e-05, + 9.3588670001089845e-05, + -0.0001164668549943862, + -0.00068585669500468248, + 0.0019924052949908499, + 0.0013953517469940798, + -0.010733175482979604, + 0.0036065535669883944, + 0.033212674058933238, + -0.029457536821945671, + -0.071394147165860775, + 0.093057364603806592, + 0.12736934033574265, + -0.19594627437659665, + -0.24984642432648865, + 0.28117234366042648, + 0.68845903945259213, + 0.52720118893091983, + 0.18817680007762133, + 0.026670057900950818 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.026670057900950818, + 0.18817680007762133, + -0.52720118893091983, + 0.68845903945259213, + -0.28117234366042648, + -0.24984642432648865, + 0.19594627437659665, + 0.12736934033574265, + -0.093057364603806592, + -0.071394147165860775, + 0.029457536821945671, + 0.033212674058933238, + -0.0036065535669883944, + -0.010733175482979604, + -0.0013953517469940798, + 0.0019924052949908499, + 0.00068585669500468248, + -0.0001164668549943862, + -9.3588670001089845e-05, + -1.3264203002354869e-05 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.026670057900950818, + 0.18817680007762133, + 0.52720118893091983, + 0.68845903945259213, + 0.28117234366042648, + -0.24984642432648865, + -0.19594627437659665, + 0.12736934033574265, + 0.093057364603806592, + -0.071394147165860775, + -0.029457536821945671, + 0.033212674058933238, + 0.0036065535669883944, + -0.010733175482979604, + 0.0013953517469940798, + 0.0019924052949908499, + -0.00068585669500468248, + -0.0001164668549943862, + 9.3588670001089845e-05, + -1.3264203002354869e-05 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-1.3264203002354869e-05, + -9.3588670001089845e-05, + -0.0001164668549943862, + 0.00068585669500468248, + 0.0019924052949908499, + -0.0013953517469940798, + -0.010733175482979604, + -0.0036065535669883944, + 0.033212674058933238, + 0.029457536821945671, + -0.071394147165860775, + -0.093057364603806592, + 0.12736934033574265, + 0.19594627437659665, + -0.24984642432648865, + -0.28117234366042648, + 0.68845903945259213, + -0.52720118893091983, + 0.18817680007762133, + -0.026670057900950818 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "db12"){ + double lp1_a[] = {-1.5290717580684923e-06, + 1.2776952219379579e-05, + -2.4241545757030318e-05, + -8.8504109208203182e-05, + 0.00038865306282092672, + 6.5451282125215034e-06, + -0.0021795036186277044, + 0.0022486072409952287, + 0.0067114990087955486, + -0.012840825198299882, + -0.01221864906974642, + 0.041546277495087637, + 0.010849130255828966, + -0.09643212009649671, + 0.0053595696743599965, + 0.18247860592758275, + -0.023779257256064865, + -0.31617845375277914, + -0.044763885653777619, + 0.51588647842780067, + 0.65719872257929113, + 0.37735513521420411, + 0.10956627282118277, + 0.013112257957229239 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.013112257957229239, + 0.10956627282118277, + -0.37735513521420411, + 0.65719872257929113, + -0.51588647842780067, + -0.044763885653777619, + 0.31617845375277914, + -0.023779257256064865, + -0.18247860592758275, + 0.0053595696743599965, + 0.09643212009649671, + 0.010849130255828966, + -0.041546277495087637, + -0.01221864906974642, + 0.012840825198299882, + 0.0067114990087955486, + -0.0022486072409952287, + -0.0021795036186277044, + -6.5451282125215034e-06, + 0.00038865306282092672, + 8.8504109208203182e-05, + -2.4241545757030318e-05, + -1.2776952219379579e-05, + -1.5290717580684923e-06 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.013112257957229239, + 0.10956627282118277, + 0.37735513521420411, + 0.65719872257929113, + 0.51588647842780067, + -0.044763885653777619, + -0.31617845375277914, + -0.023779257256064865, + 0.18247860592758275, + 0.0053595696743599965, + -0.09643212009649671, + 0.010849130255828966, + 0.041546277495087637, + -0.01221864906974642, + -0.012840825198299882, + 0.0067114990087955486, + 0.0022486072409952287, + -0.0021795036186277044, + 6.5451282125215034e-06, + 0.00038865306282092672, + -8.8504109208203182e-05, + -2.4241545757030318e-05, + 1.2776952219379579e-05, + -1.5290717580684923e-06 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-1.5290717580684923e-06, + -1.2776952219379579e-05, + -2.4241545757030318e-05, + 8.8504109208203182e-05, + 0.00038865306282092672, + -6.5451282125215034e-06, + -0.0021795036186277044, + -0.0022486072409952287, + 0.0067114990087955486, + 0.012840825198299882, + -0.01221864906974642, + -0.041546277495087637, + 0.010849130255828966, + 0.09643212009649671, + 0.0053595696743599965, + -0.18247860592758275, + -0.023779257256064865, + 0.31617845375277914, + -0.044763885653777619, + -0.51588647842780067, + 0.65719872257929113, + -0.37735513521420411, + 0.10956627282118277, + -0.013112257957229239 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + else if ( name == "db13"){ + double lp1_a[] = {5.2200350984547998e-07, + -4.7004164793608082e-06, + 1.0441930571407941e-05, + 3.0678537579324358e-05, + -0.00016512898855650571, + 4.9251525126285676e-05, + 0.00093232613086724904, + -0.0013156739118922766, + -0.002761911234656831, + 0.0072555894016171187, + 0.0039239414487955773, + -0.023831420710327809, + 0.0023799722540522269, + 0.056139477100276156, + -0.026488406475345658, + -0.10580761818792761, + 0.072948933656788742, + 0.17947607942935084, + -0.12457673075080665, + -0.31497290771138414, + 0.086985726179645007, + 0.58888957043121193, + 0.61105585115878114, + 0.31199632216043488, + 0.082861243872901946, + 0.0092021335389622788 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.0092021335389622788, + 0.082861243872901946, + -0.31199632216043488, + 0.61105585115878114, + -0.58888957043121193, + 0.086985726179645007, + 0.31497290771138414, + -0.12457673075080665, + -0.17947607942935084, + 0.072948933656788742, + 0.10580761818792761, + -0.026488406475345658, + -0.056139477100276156, + 0.0023799722540522269, + 0.023831420710327809, + 0.0039239414487955773, + -0.0072555894016171187, + -0.002761911234656831, + 0.0013156739118922766, + 0.00093232613086724904, + -4.9251525126285676e-05, + -0.00016512898855650571, + -3.0678537579324358e-05, + 1.0441930571407941e-05, + 4.7004164793608082e-06, + 5.2200350984547998e-07 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.0092021335389622788, + 0.082861243872901946, + 0.31199632216043488, + 0.61105585115878114, + 0.58888957043121193, + 0.086985726179645007, + -0.31497290771138414, + -0.12457673075080665, + 0.17947607942935084, + 0.072948933656788742, + -0.10580761818792761, + -0.026488406475345658, + 0.056139477100276156, + 0.0023799722540522269, + -0.023831420710327809, + 0.0039239414487955773, + 0.0072555894016171187, + -0.002761911234656831, + -0.0013156739118922766, + 0.00093232613086724904, + 4.9251525126285676e-05, + -0.00016512898855650571, + 3.0678537579324358e-05, + 1.0441930571407941e-05, + -4.7004164793608082e-06, + 5.2200350984547998e-07 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {5.2200350984547998e-07, + 4.7004164793608082e-06, + 1.0441930571407941e-05, + -3.0678537579324358e-05, + -0.00016512898855650571, + -4.9251525126285676e-05, + 0.00093232613086724904, + 0.0013156739118922766, + -0.002761911234656831, + -0.0072555894016171187, + 0.0039239414487955773, + 0.023831420710327809, + 0.0023799722540522269, + -0.056139477100276156, + -0.026488406475345658, + 0.10580761818792761, + 0.072948933656788742, + -0.17947607942935084, + -0.12457673075080665, + 0.31497290771138414, + 0.086985726179645007, + -0.58888957043121193, + 0.61105585115878114, + -0.31199632216043488, + 0.082861243872901946, + -0.0092021335389622788 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "db11"){ + double lp1_a[] = {4.4942742772363519e-06, + -3.4634984186983789e-05, + 5.4439074699366381e-05, + 0.00024915252355281426, + -0.00089302325066623663, + -0.00030859285881515924, + 0.0049284176560587777, + -0.0033408588730145018, + -0.015364820906201324, + 0.020840904360180039, + 0.031335090219045313, + -0.066438785695020222, + -0.04647995511667613, + 0.14981201246638268, + 0.066043588196690886, + -0.27423084681792875, + -0.16227524502747828, + 0.41196436894789695, + 0.68568677491617847, + 0.44989976435603013, + 0.14406702115061959, + 0.018694297761470441 + }; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.018694297761470441, + 0.14406702115061959, + -0.44989976435603013, + 0.68568677491617847, + -0.41196436894789695, + -0.16227524502747828, + 0.27423084681792875, + 0.066043588196690886, + -0.14981201246638268, + -0.04647995511667613, + 0.066438785695020222, + 0.031335090219045313, + -0.020840904360180039, + -0.015364820906201324, + 0.0033408588730145018, + 0.0049284176560587777, + 0.00030859285881515924, + -0.00089302325066623663, + -0.00024915252355281426, + 5.4439074699366381e-05, + 3.4634984186983789e-05, + 4.4942742772363519e-06 + }; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.018694297761470441, + 0.14406702115061959, + 0.44989976435603013, + 0.68568677491617847, + 0.41196436894789695, + -0.16227524502747828, + -0.27423084681792875, + 0.066043588196690886, + 0.14981201246638268, + -0.04647995511667613, + -0.066438785695020222, + 0.031335090219045313, + 0.020840904360180039, + -0.015364820906201324, + -0.0033408588730145018, + 0.0049284176560587777, + -0.00030859285881515924, + -0.00089302325066623663, + 0.00024915252355281426, + 5.4439074699366381e-05, + -3.4634984186983789e-05, + 4.4942742772363519e-06 + }; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {4.4942742772363519e-06, + 3.4634984186983789e-05, + 5.4439074699366381e-05, + -0.00024915252355281426, + -0.00089302325066623663, + 0.00030859285881515924, + 0.0049284176560587777, + 0.0033408588730145018, + -0.015364820906201324, + -0.020840904360180039, + 0.031335090219045313, + 0.066438785695020222, + -0.04647995511667613, + -0.14981201246638268, + 0.066043588196690886, + 0.27423084681792875, + -0.16227524502747828, + -0.41196436894789695, + 0.68568677491617847, + -0.44989976435603013, + 0.14406702115061959, + -0.018694297761470441 + }; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "db14"){ + double lp1_a[] = {-1.7871399683109222e-07, + 1.7249946753674012e-06, + -4.3897049017804176e-06, + -1.0337209184568496e-05, + 6.875504252695734e-05, + -4.1777245770370672e-05, + -0.00038683194731287514, + 0.00070802115423540481, + 0.001061691085606874, + -0.003849638868019787, + -0.00074621898926387534, + 0.012789493266340071, + -0.0056150495303375755, + -0.030185351540353976, + 0.026981408307947971, + 0.05523712625925082, + -0.071548955503983505, + -0.086748411568110598, + 0.13998901658445695, + 0.13839521386479153, + -0.21803352999321651, + -0.27168855227867705, + 0.21867068775886594, + 0.63118784910471981, + 0.55430561794077093, + 0.25485026779256437, + 0.062364758849384874, + 0.0064611534600864905 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.0064611534600864905, + 0.062364758849384874, + -0.25485026779256437, + 0.55430561794077093, + -0.63118784910471981, + 0.21867068775886594, + 0.27168855227867705, + -0.21803352999321651, + -0.13839521386479153, + 0.13998901658445695, + 0.086748411568110598, + -0.071548955503983505, + -0.05523712625925082, + 0.026981408307947971, + 0.030185351540353976, + -0.0056150495303375755, + -0.012789493266340071, + -0.00074621898926387534, + 0.003849638868019787, + 0.001061691085606874, + -0.00070802115423540481, + -0.00038683194731287514, + 4.1777245770370672e-05, + 6.875504252695734e-05, + 1.0337209184568496e-05, + -4.3897049017804176e-06, + -1.7249946753674012e-06, + -1.7871399683109222e-07 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.0064611534600864905, + 0.062364758849384874, + 0.25485026779256437, + 0.55430561794077093, + 0.63118784910471981, + 0.21867068775886594, + -0.27168855227867705, + -0.21803352999321651, + 0.13839521386479153, + 0.13998901658445695, + -0.086748411568110598, + -0.071548955503983505, + 0.05523712625925082, + 0.026981408307947971, + -0.030185351540353976, + -0.0056150495303375755, + 0.012789493266340071, + -0.00074621898926387534, + -0.003849638868019787, + 0.001061691085606874, + 0.00070802115423540481, + -0.00038683194731287514, + -4.1777245770370672e-05, + 6.875504252695734e-05, + -1.0337209184568496e-05, + -4.3897049017804176e-06, + 1.7249946753674012e-06, + -1.7871399683109222e-07 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-1.7871399683109222e-07, + -1.7249946753674012e-06, + -4.3897049017804176e-06, + 1.0337209184568496e-05, + 6.875504252695734e-05, + 4.1777245770370672e-05, + -0.00038683194731287514, + -0.00070802115423540481, + 0.001061691085606874, + 0.003849638868019787, + -0.00074621898926387534, + -0.012789493266340071, + -0.0056150495303375755, + 0.030185351540353976, + 0.026981408307947971, + -0.05523712625925082, + -0.071548955503983505, + 0.086748411568110598, + 0.13998901658445695, + -0.13839521386479153, + -0.21803352999321651, + 0.27168855227867705, + 0.21867068775886594, + -0.63118784910471981, + 0.55430561794077093, + -0.25485026779256437, + 0.062364758849384874, + -0.0064611534600864905 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + else if ( name == "db15"){ + double lp1_a[] = {6.1333599133037138e-08, + -6.3168823258794506e-07, + 1.8112704079399406e-06, + 3.3629871817363823e-06, + -2.8133296266037558e-05, + 2.579269915531323e-05, + 0.00015589648992055726, + -0.00035956524436229364, + -0.00037348235413726472, + 0.0019433239803823459, + -0.00024175649075894543, + -0.0064877345603061454, + 0.0051010003604228726, + 0.015083918027862582, + -0.020810050169636805, + -0.025767007328366939, + 0.054780550584559995, + 0.033877143923563204, + -0.11112093603713753, + -0.039666176555733602, + 0.19014671400708816, + 0.065282952848765688, + -0.28888259656686216, + -0.19320413960907623, + 0.33900253545462167, + 0.64581314035721027, + 0.49263177170797529, + 0.20602386398692688, + 0.046743394892750617, + 0.0045385373615773762 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.0045385373615773762, + 0.046743394892750617, + -0.20602386398692688, + 0.49263177170797529, + -0.64581314035721027, + 0.33900253545462167, + 0.19320413960907623, + -0.28888259656686216, + -0.065282952848765688, + 0.19014671400708816, + 0.039666176555733602, + -0.11112093603713753, + -0.033877143923563204, + 0.054780550584559995, + 0.025767007328366939, + -0.020810050169636805, + -0.015083918027862582, + 0.0051010003604228726, + 0.0064877345603061454, + -0.00024175649075894543, + -0.0019433239803823459, + -0.00037348235413726472, + 0.00035956524436229364, + 0.00015589648992055726, + -2.579269915531323e-05, + -2.8133296266037558e-05, + -3.3629871817363823e-06, + 1.8112704079399406e-06, + 6.3168823258794506e-07, + 6.1333599133037138e-08 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.0045385373615773762, + 0.046743394892750617, + 0.20602386398692688, + 0.49263177170797529, + 0.64581314035721027, + 0.33900253545462167, + -0.19320413960907623, + -0.28888259656686216, + 0.065282952848765688, + 0.19014671400708816, + -0.039666176555733602, + -0.11112093603713753, + 0.033877143923563204, + 0.054780550584559995, + -0.025767007328366939, + -0.020810050169636805, + 0.015083918027862582, + 0.0051010003604228726, + -0.0064877345603061454, + -0.00024175649075894543, + 0.0019433239803823459, + -0.00037348235413726472, + -0.00035956524436229364, + 0.00015589648992055726, + 2.579269915531323e-05, + -2.8133296266037558e-05, + 3.3629871817363823e-06, + 1.8112704079399406e-06, + -6.3168823258794506e-07, + 6.1333599133037138e-08 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {6.1333599133037138e-08, + 6.3168823258794506e-07, + 1.8112704079399406e-06, + -3.3629871817363823e-06, + -2.8133296266037558e-05, + -2.579269915531323e-05, + 0.00015589648992055726, + 0.00035956524436229364, + -0.00037348235413726472, + -0.0019433239803823459, + -0.00024175649075894543, + 0.0064877345603061454, + 0.0051010003604228726, + -0.015083918027862582, + -0.020810050169636805, + 0.025767007328366939, + 0.054780550584559995, + -0.033877143923563204, + -0.11112093603713753, + 0.039666176555733602, + 0.19014671400708816, + -0.065282952848765688, + -0.28888259656686216, + 0.19320413960907623, + 0.33900253545462167, + -0.64581314035721027, + 0.49263177170797529, + -0.20602386398692688, + 0.046743394892750617, + -0.0045385373615773762 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + else if ( name == "bior1.1"){ + double lp1_a[] = {0.70710678118654757, + 0.70710678118654757 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.70710678118654757, + 0.70710678118654757 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.70710678118654757, + 0.70710678118654757 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.70710678118654757, + -0.70710678118654757 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "bior1.3"){ + double lp1_a[] = {-0.088388347648318447, + 0.088388347648318447, + 0.70710678118654757, + 0.70710678118654757, + 0.088388347648318447, + -0.088388347648318447, + }; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {0.0, + 0.0, + -0.70710678118654757, + 0.70710678118654757, + 0.0, + 0.0 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.0, + 0.0, + 0.70710678118654757, + 0.70710678118654757, + 0.0, + 0.0 + }; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-0.088388347648318447, + -0.088388347648318447, + 0.70710678118654757, + -0.70710678118654757, + 0.088388347648318447, + 0.088388347648318447 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "bior1.5"){ + double lp1_a[] = {0.01657281518405971, + -0.01657281518405971, + -0.12153397801643787, + 0.12153397801643787, + 0.70710678118654757, + 0.70710678118654757, + 0.12153397801643787, + -0.12153397801643787, + -0.01657281518405971, + 0.01657281518405971 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {0.0, + 0.0, + 0.0, + 0.0, + -0.70710678118654757, + 0.70710678118654757, + 0.0, + 0.0, + 0.0, + 0.0 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.0, + 0.0, + 0.0, + 0.0, + 0.70710678118654757, + 0.70710678118654757, + 0.0, + 0.0, + 0.0, + 0.0 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.01657281518405971, + 0.01657281518405971, + -0.12153397801643787, + -0.12153397801643787, + 0.70710678118654757, + -0.70710678118654757, + 0.12153397801643787, + 0.12153397801643787, + -0.01657281518405971, + -0.01657281518405971 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "bior2.2"){ + double lp1_a[] = {0.0, + -0.17677669529663689, + 0.35355339059327379, + 1.0606601717798214, + 0.35355339059327379, + -0.17677669529663689 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {0.0, + 0.35355339059327379, + -0.70710678118654757, + 0.35355339059327379, + 0.0, + 0.0 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.0, + 0.35355339059327379, + 0.70710678118654757, + 0.35355339059327379, + 0.0, + 0.0 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.0, + 0.17677669529663689, + 0.35355339059327379, + -1.0606601717798214, + 0.35355339059327379, + 0.17677669529663689 + +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "bior2.4"){ + double lp1_a[] = {0.0, + 0.033145630368119419, + -0.066291260736238838, + -0.17677669529663689, + 0.4198446513295126, + 0.99436891104358249, + 0.4198446513295126, + -0.17677669529663689, + -0.066291260736238838, + 0.033145630368119419 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {0.0, + 0.0, + 0.0, + 0.35355339059327379, + -0.70710678118654757, + 0.35355339059327379, + 0.0, + 0.0, + 0.0, + 0.0 + +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.0, + 0.0, + 0.0, + 0.35355339059327379, + 0.70710678118654757, + 0.35355339059327379, + 0.0, + 0.0, + 0.0, + 0.0 + +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.0, + -0.033145630368119419, + -0.066291260736238838, + 0.17677669529663689, + 0.4198446513295126, + -0.99436891104358249, + 0.4198446513295126, + 0.17677669529663689, + -0.066291260736238838, + -0.033145630368119419 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "bior2.6"){ + double lp1_a[] = {0.0, + -0.0069053396600248784, + 0.013810679320049757, + 0.046956309688169176, + -0.10772329869638811, + -0.16987135563661201, + 0.44746600996961211, + 0.96674755240348298, + 0.44746600996961211, + -0.16987135563661201, + -0.10772329869638811, + 0.046956309688169176, + 0.013810679320049757, + -0.0069053396600248784 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.35355339059327379, + -0.70710678118654757, + 0.35355339059327379, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.35355339059327379, + 0.70710678118654757, + 0.35355339059327379, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.0, + 0.0069053396600248784, + 0.013810679320049757, + -0.046956309688169176, + -0.10772329869638811, + 0.16987135563661201, + 0.44746600996961211, + -0.96674755240348298, + 0.44746600996961211, + 0.16987135563661201, + -0.10772329869638811, + -0.046956309688169176, + 0.013810679320049757, + 0.0069053396600248784 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + else if ( name == "bior2.8"){ + double lp1_a[] = {0.0, + 0.0015105430506304422, + -0.0030210861012608843, + -0.012947511862546647, + 0.028916109826354178, + 0.052998481890690945, + -0.13491307360773608, + -0.16382918343409025, + 0.46257144047591658, + 0.95164212189717856, + 0.46257144047591658, + -0.16382918343409025, + -0.13491307360773608, + 0.052998481890690945, + 0.028916109826354178, + -0.012947511862546647, + -0.0030210861012608843, + 0.0015105430506304422 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.35355339059327379, + -0.70710678118654757, + 0.35355339059327379, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.35355339059327379, + 0.70710678118654757, + 0.35355339059327379, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.0, + -0.0015105430506304422, + -0.0030210861012608843, + 0.012947511862546647, + 0.028916109826354178, + -0.052998481890690945, + -0.13491307360773608, + 0.16382918343409025, + 0.46257144047591658, + -0.95164212189717856, + 0.46257144047591658, + 0.16382918343409025, + -0.13491307360773608, + -0.052998481890690945, + 0.028916109826354178, + 0.012947511862546647, + -0.0030210861012608843, + -0.0015105430506304422 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "bior3.1"){ + double lp1_a[] = {-0.35355339059327379, + 1.0606601717798214, + 1.0606601717798214, + -0.35355339059327379 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.17677669529663689, + 0.53033008588991071, + -0.53033008588991071, + 0.17677669529663689 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.17677669529663689, + 0.53033008588991071, + 0.53033008588991071, + 0.17677669529663689 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-0.35355339059327379, + -1.0606601717798214, + 1.0606601717798214, + 0.35355339059327379 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + else if ( name == "bior3.3"){ + double lp1_a[] = {0.066291260736238838, + -0.19887378220871652, + -0.15467960838455727, + 0.99436891104358249, + 0.99436891104358249, + -0.15467960838455727, + -0.19887378220871652, + 0.066291260736238838 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {0.0, + 0.0, + -0.17677669529663689, + 0.53033008588991071, + -0.53033008588991071, + 0.17677669529663689, + 0.0, + 0.0 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.0, + 0.0, + 0.17677669529663689, + 0.53033008588991071, + 0.53033008588991071, + 0.17677669529663689, + 0.0, + 0.0 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.066291260736238838, + 0.19887378220871652, + -0.15467960838455727, + -0.99436891104358249, + 0.99436891104358249, + 0.15467960838455727, + -0.19887378220871652, + -0.066291260736238838 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + else if ( name == "bior3.5"){ + double lp1_a[] = {-0.013810679320049757, + 0.041432037960149271, + 0.052480581416189075, + -0.26792717880896527, + -0.071815532464258744, + 0.96674755240348298, + 0.96674755240348298, + -0.071815532464258744, + -0.26792717880896527, + 0.052480581416189075, + 0.041432037960149271, + -0.013810679320049757 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {0.0, + 0.0, + 0.0, + 0.0, + -0.17677669529663689, + 0.53033008588991071, + -0.53033008588991071, + 0.17677669529663689, + 0.0, + 0.0, + 0.0, + 0.0 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.0, + 0.0, + 0.0, + 0.0, + 0.17677669529663689, + 0.53033008588991071, + 0.53033008588991071, + 0.17677669529663689, + 0.0, + 0.0, + 0.0, + 0.0 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-0.013810679320049757, + -0.041432037960149271, + 0.052480581416189075, + 0.26792717880896527, + -0.071815532464258744, + -0.96674755240348298, + 0.96674755240348298, + 0.071815532464258744, + -0.26792717880896527, + -0.052480581416189075, + 0.041432037960149271, + 0.013810679320049757 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "bior3.7"){ + double lp1_a[] = {0.0030210861012608843, + -0.0090632583037826529, + -0.016831765421310641, + 0.074663985074019001, + 0.031332978707362888, + -0.301159125922835, + -0.026499240945345472, + 0.95164212189717856, + 0.95164212189717856, + -0.026499240945345472, + -0.301159125922835, + 0.031332978707362888, + 0.074663985074019001, + -0.016831765421310641, + -0.0090632583037826529, + 0.0030210861012608843 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + -0.17677669529663689, + 0.53033008588991071, + -0.53033008588991071, + 0.17677669529663689, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.17677669529663689, + 0.53033008588991071, + 0.53033008588991071, + 0.17677669529663689, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.0030210861012608843, + 0.0090632583037826529, + -0.016831765421310641, + -0.074663985074019001, + 0.031332978707362888, + 0.301159125922835, + -0.026499240945345472, + -0.95164212189717856, + 0.95164212189717856, + 0.026499240945345472, + -0.301159125922835, + -0.031332978707362888, + 0.074663985074019001, + 0.016831765421310641, + -0.0090632583037826529, + -0.0030210861012608843 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + else if ( name == "bior3.9"){ + double lp1_a[] = {-0.00067974437278369901, + 0.0020392331183510968, + 0.0050603192196119811, + -0.020618912641105536, + -0.014112787930175846, + 0.09913478249423216, + 0.012300136269419315, + -0.32019196836077857, + 0.0020500227115698858, + 0.94212570067820678, + 0.94212570067820678, + 0.0020500227115698858, + -0.32019196836077857, + 0.012300136269419315, + 0.09913478249423216, + -0.014112787930175846, + -0.020618912641105536, + 0.0050603192196119811, + 0.0020392331183510968, + -0.00067974437278369901 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + -0.17677669529663689, + 0.53033008588991071, + -0.53033008588991071, + 0.17677669529663689, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.17677669529663689, + 0.53033008588991071, + 0.53033008588991071, + 0.17677669529663689, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-0.00067974437278369901, + -0.0020392331183510968, + 0.0050603192196119811, + 0.020618912641105536, + -0.014112787930175846, + -0.09913478249423216, + 0.012300136269419315, + 0.32019196836077857, + 0.0020500227115698858, + -0.94212570067820678, + 0.94212570067820678, + -0.0020500227115698858, + -0.32019196836077857, + -0.012300136269419315, + 0.09913478249423216, + 0.014112787930175846, + -0.020618912641105536, + -0.0050603192196119811, + 0.0020392331183510968, + 0.00067974437278369901 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + else if ( name == "bior4.4"){ + double lp1_a[] = {0.0, + 0.03782845550726404, + -0.023849465019556843, + -0.11062440441843718, + 0.37740285561283066, + 0.85269867900889385, + 0.37740285561283066, + -0.11062440441843718, + -0.023849465019556843, + 0.03782845550726404 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {0.0, + -0.064538882628697058, + 0.040689417609164058, + 0.41809227322161724, + -0.7884856164055829, + 0.41809227322161724, + 0.040689417609164058, + -0.064538882628697058, + 0.0, + 0.0 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.0, + -0.064538882628697058, + -0.040689417609164058, + 0.41809227322161724, + 0.7884856164055829, + 0.41809227322161724, + -0.040689417609164058, + -0.064538882628697058, + 0.0, + 0.0 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.0, + -0.03782845550726404, + -0.023849465019556843, + 0.11062440441843718, + 0.37740285561283066, + -0.85269867900889385, + 0.37740285561283066, + 0.11062440441843718, + -0.023849465019556843, + -0.03782845550726404 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + else if ( name == "bior5.5"){ + double lp1_a[] = {0.0, + 0.0, + 0.03968708834740544, + 0.0079481086372403219, + -0.054463788468236907, + 0.34560528195603346, + 0.73666018142821055, + 0.34560528195603346, + -0.054463788468236907, + 0.0079481086372403219, + 0.03968708834740544, + 0.0 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.013456709459118716, + -0.0026949668801115071, + 0.13670658466432914, + -0.093504697400938863, + -0.47680326579848425, + 0.89950610974864842, + -0.47680326579848425, + -0.093504697400938863, + 0.13670658466432914, + -0.0026949668801115071, + -0.013456709459118716, + 0.0 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.013456709459118716, + -0.0026949668801115071, + -0.13670658466432914, + -0.093504697400938863, + 0.47680326579848425, + 0.89950610974864842, + 0.47680326579848425, + -0.093504697400938863, + -0.13670658466432914, + -0.0026949668801115071, + 0.013456709459118716, + 0.0 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.0, + 0.0, + 0.03968708834740544, + -0.0079481086372403219, + -0.054463788468236907, + -0.34560528195603346, + 0.73666018142821055, + -0.34560528195603346, + -0.054463788468236907, + -0.0079481086372403219, + 0.03968708834740544, + 0.0 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + else if ( name == "bior6.8"){ + double lp1_a[] = {0.0, + 0.0019088317364812906, + -0.0019142861290887667, + -0.016990639867602342, + 0.01193456527972926, + 0.04973290349094079, + -0.077263173167204144, + -0.09405920349573646, + 0.42079628460982682, + 0.82592299745840225, + 0.42079628460982682, + -0.09405920349573646, + -0.077263173167204144, + 0.04973290349094079, + 0.01193456527972926, + -0.016990639867602342, + -0.0019142861290887667, + 0.0019088317364812906 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {0.0, + 0.0, + 0.0, + 0.014426282505624435, + -0.014467504896790148, + -0.078722001062628819, + 0.040367979030339923, + 0.41784910915027457, + -0.75890772945365415, + 0.41784910915027457, + 0.040367979030339923, + -0.078722001062628819, + -0.014467504896790148, + 0.014426282505624435, + 0.0, + 0.0, + 0.0, + 0.0 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.0, + 0.0, + 0.0, + 0.014426282505624435, + 0.014467504896790148, + -0.078722001062628819, + -0.040367979030339923, + 0.41784910915027457, + 0.75890772945365415, + 0.41784910915027457, + -0.040367979030339923, + -0.078722001062628819, + 0.014467504896790148, + 0.014426282505624435, + 0.0, + 0.0, + 0.0, + 0.0 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.0, + -0.0019088317364812906, + -0.0019142861290887667, + 0.016990639867602342, + 0.01193456527972926, + -0.04973290349094079, + -0.077263173167204144, + 0.09405920349573646, + 0.42079628460982682, + -0.82592299745840225, + 0.42079628460982682, + 0.09405920349573646, + -0.077263173167204144, + -0.04973290349094079, + 0.01193456527972926, + 0.016990639867602342, + -0.0019142861290887667, + -0.0019088317364812906 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "coif1"){ + double lp1_a[] = {-0.01565572813546454, + -0.072732619512853897, + 0.38486484686420286, + 0.85257202021225542, + 0.33789766245780922, + -0.072732619512853897 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {0.072732619512853897, + 0.33789766245780922, + -0.85257202021225542, + 0.38486484686420286, + 0.072732619512853897, + -0.01565572813546454 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {-0.072732619512853897, + 0.33789766245780922, + 0.85257202021225542, + 0.38486484686420286, + -0.072732619512853897, + -0.01565572813546454 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-0.01565572813546454, + 0.072732619512853897, + 0.38486484686420286, + -0.85257202021225542, + 0.33789766245780922, + 0.072732619512853897 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + else if ( name == "coif2"){ + double lp1_a[] = {-0.00072054944536451221, + -0.0018232088707029932, + 0.0056114348193944995, + 0.023680171946334084, + -0.059434418646456898, + -0.076488599078306393, + 0.41700518442169254, + 0.81272363544554227, + 0.38611006682116222, + -0.067372554721963018, + -0.041464936781759151, + 0.016387336463522112 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.016387336463522112, + -0.041464936781759151, + 0.067372554721963018, + 0.38611006682116222, + -0.81272363544554227, + 0.41700518442169254, + 0.076488599078306393, + -0.059434418646456898, + -0.023680171946334084, + 0.0056114348193944995, + 0.0018232088707029932, + -0.00072054944536451221 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.016387336463522112, + -0.041464936781759151, + -0.067372554721963018, + 0.38611006682116222, + 0.81272363544554227, + 0.41700518442169254, + -0.076488599078306393, + -0.059434418646456898, + 0.023680171946334084, + 0.0056114348193944995, + -0.0018232088707029932, + -0.00072054944536451221 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-0.00072054944536451221, + 0.0018232088707029932, + 0.0056114348193944995, + -0.023680171946334084, + -0.059434418646456898, + 0.076488599078306393, + 0.41700518442169254, + -0.81272363544554227, + 0.38611006682116222, + 0.067372554721963018, + -0.041464936781759151, + -0.016387336463522112 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + else if ( name == "coif3"){ + double lp1_a[] = {-3.4599772836212559e-05, + -7.0983303138141252e-05, + 0.00046621696011288631, + 0.0011175187708906016, + -0.0025745176887502236, + -0.0090079761366615805, + 0.015880544863615904, + 0.034555027573061628, + -0.082301927106885983, + -0.071799821619312018, + 0.42848347637761874, + 0.79377722262562056, + 0.4051769024096169, + -0.061123390002672869, + -0.0657719112818555, + 0.023452696141836267, + 0.0077825964273254182, + -0.0037935128644910141 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {0.0037935128644910141, + 0.0077825964273254182, + -0.023452696141836267, + -0.0657719112818555, + 0.061123390002672869, + 0.4051769024096169, + -0.79377722262562056, + 0.42848347637761874, + 0.071799821619312018, + -0.082301927106885983, + -0.034555027573061628, + 0.015880544863615904, + 0.0090079761366615805, + -0.0025745176887502236, + -0.0011175187708906016, + 0.00046621696011288631, + 7.0983303138141252e-05, + -3.4599772836212559e-05 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {-0.0037935128644910141, + 0.0077825964273254182, + 0.023452696141836267, + -0.0657719112818555, + -0.061123390002672869, + 0.4051769024096169, + 0.79377722262562056, + 0.42848347637761874, + -0.071799821619312018, + -0.082301927106885983, + 0.034555027573061628, + 0.015880544863615904, + -0.0090079761366615805, + -0.0025745176887502236, + 0.0011175187708906016, + 0.00046621696011288631, + -7.0983303138141252e-05, + -3.4599772836212559e-05 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-3.4599772836212559e-05, + 7.0983303138141252e-05, + 0.00046621696011288631, + -0.0011175187708906016, + -0.0025745176887502236, + 0.0090079761366615805, + 0.015880544863615904, + -0.034555027573061628, + -0.082301927106885983, + 0.071799821619312018, + 0.42848347637761874, + -0.79377722262562056, + 0.4051769024096169, + 0.061123390002672869, + -0.0657719112818555, + -0.023452696141836267, + 0.0077825964273254182, + 0.0037935128644910141 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + else if ( name == "coif4"){ + double lp1_a[] = {-1.7849850030882614e-06, + -3.2596802368833675e-06, + 3.1229875865345646e-05, + 6.2339034461007128e-05, + -0.00025997455248771324, + -0.00058902075624433831, + 0.0012665619292989445, + 0.0037514361572784571, + -0.0056582866866107199, + -0.015211731527946259, + 0.025082261844864097, + 0.039334427123337491, + -0.096220442033987982, + -0.066627474263425038, + 0.4343860564914685, + 0.78223893092049901, + 0.41530840703043026, + -0.056077313316754807, + -0.081266699680878754, + 0.026682300156053072, + 0.016068943964776348, + -0.0073461663276420935, + -0.0016294920126017326, + 0.00089231366858231456 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.00089231366858231456, + -0.0016294920126017326, + 0.0073461663276420935, + 0.016068943964776348, + -0.026682300156053072, + -0.081266699680878754, + 0.056077313316754807, + 0.41530840703043026, + -0.78223893092049901, + 0.4343860564914685, + 0.066627474263425038, + -0.096220442033987982, + -0.039334427123337491, + 0.025082261844864097, + 0.015211731527946259, + -0.0056582866866107199, + -0.0037514361572784571, + 0.0012665619292989445, + 0.00058902075624433831, + -0.00025997455248771324, + -6.2339034461007128e-05, + 3.1229875865345646e-05, + 3.2596802368833675e-06, + -1.7849850030882614e-06 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.00089231366858231456, + -0.0016294920126017326, + -0.0073461663276420935, + 0.016068943964776348, + 0.026682300156053072, + -0.081266699680878754, + -0.056077313316754807, + 0.41530840703043026, + 0.78223893092049901, + 0.4343860564914685, + -0.066627474263425038, + -0.096220442033987982, + 0.039334427123337491, + 0.025082261844864097, + -0.015211731527946259, + -0.0056582866866107199, + 0.0037514361572784571, + 0.0012665619292989445, + -0.00058902075624433831, + -0.00025997455248771324, + 6.2339034461007128e-05, + 3.1229875865345646e-05, + -3.2596802368833675e-06, + -1.7849850030882614e-06 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-1.7849850030882614e-06, + 3.2596802368833675e-06, + 3.1229875865345646e-05, + -6.2339034461007128e-05, + -0.00025997455248771324, + 0.00058902075624433831, + 0.0012665619292989445, + -0.0037514361572784571, + -0.0056582866866107199, + 0.015211731527946259, + 0.025082261844864097, + -0.039334427123337491, + -0.096220442033987982, + 0.066627474263425038, + 0.4343860564914685, + -0.78223893092049901, + 0.41530840703043026, + 0.056077313316754807, + -0.081266699680878754, + -0.026682300156053072, + 0.016068943964776348, + 0.0073461663276420935, + -0.0016294920126017326, + -0.00089231366858231456 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + else if ( name == "coif5"){ + double lp1_a[] = {-9.517657273819165e-08, + -1.6744288576823017e-07, + 2.0637618513646814e-06, + 3.7346551751414047e-06, + -2.1315026809955787e-05, + -4.1340432272512511e-05, + 0.00014054114970203437, + 0.00030225958181306315, + -0.00063813134304511142, + -0.0016628637020130838, + 0.0024333732126576722, + 0.0067641854480530832, + -0.0091642311624818458, + -0.019761778942572639, + 0.032683574267111833, + 0.041289208750181702, + -0.10557420870333893, + -0.062035963962903569, + 0.43799162617183712, + 0.77428960365295618, + 0.42156620669085149, + -0.052043163176243773, + -0.091920010559696244, + 0.02816802897093635, + 0.023408156785839195, + -0.010131117519849788, + -0.004159358781386048, + 0.0021782363581090178, + 0.00035858968789573785, + -0.00021208083980379827 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {0.00021208083980379827, + 0.00035858968789573785, + -0.0021782363581090178, + -0.004159358781386048, + 0.010131117519849788, + 0.023408156785839195, + -0.02816802897093635, + -0.091920010559696244, + 0.052043163176243773, + 0.42156620669085149, + -0.77428960365295618, + 0.43799162617183712, + 0.062035963962903569, + -0.10557420870333893, + -0.041289208750181702, + 0.032683574267111833, + 0.019761778942572639, + -0.0091642311624818458, + -0.0067641854480530832, + 0.0024333732126576722, + 0.0016628637020130838, + -0.00063813134304511142, + -0.00030225958181306315, + 0.00014054114970203437, + 4.1340432272512511e-05, + -2.1315026809955787e-05, + -3.7346551751414047e-06, + 2.0637618513646814e-06, + 1.6744288576823017e-07, + -9.517657273819165e-08 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {-0.00021208083980379827, + 0.00035858968789573785, + 0.0021782363581090178, + -0.004159358781386048, + -0.010131117519849788, + 0.023408156785839195, + 0.02816802897093635, + -0.091920010559696244, + -0.052043163176243773, + 0.42156620669085149, + 0.77428960365295618, + 0.43799162617183712, + -0.062035963962903569, + -0.10557420870333893, + 0.041289208750181702, + 0.032683574267111833, + -0.019761778942572639, + -0.0091642311624818458, + 0.0067641854480530832, + 0.0024333732126576722, + -0.0016628637020130838, + -0.00063813134304511142, + 0.00030225958181306315, + 0.00014054114970203437, + -4.1340432272512511e-05, + -2.1315026809955787e-05, + 3.7346551751414047e-06, + 2.0637618513646814e-06, + -1.6744288576823017e-07, + -9.517657273819165e-08 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-9.517657273819165e-08, + 1.6744288576823017e-07, + 2.0637618513646814e-06, + -3.7346551751414047e-06, + -2.1315026809955787e-05, + 4.1340432272512511e-05, + 0.00014054114970203437, + -0.00030225958181306315, + -0.00063813134304511142, + 0.0016628637020130838, + 0.0024333732126576722, + -0.0067641854480530832, + -0.0091642311624818458, + 0.019761778942572639, + 0.032683574267111833, + -0.041289208750181702, + -0.10557420870333893, + 0.062035963962903569, + 0.43799162617183712, + -0.77428960365295618, + 0.42156620669085149, + 0.052043163176243773, + -0.091920010559696244, + -0.02816802897093635, + 0.023408156785839195, + 0.010131117519849788, + -0.004159358781386048, + -0.0021782363581090178, + 0.00035858968789573785, + 0.00021208083980379827 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "sym2"){ + double lp1_a[] = {-0.12940952255092145, + 0.22414386804185735, + 0.83651630373746899, + 0.48296291314469025 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.48296291314469025, + 0.83651630373746899, + -0.22414386804185735, + -0.12940952255092145 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.48296291314469025, + 0.83651630373746899, + 0.22414386804185735, + -0.12940952255092145 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-0.12940952255092145, + -0.22414386804185735, + 0.83651630373746899, + -0.48296291314469025 + +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "sym3"){ + double lp1_a[] = {0.035226291882100656, + -0.085441273882241486, + -0.13501102001039084, + 0.45987750211933132, + 0.80689150931333875, + 0.33267055295095688 + +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.33267055295095688, + 0.80689150931333875, + -0.45987750211933132, + -0.13501102001039084, + 0.085441273882241486, + 0.035226291882100656 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.33267055295095688, + 0.80689150931333875, + 0.45987750211933132, + -0.13501102001039084, + -0.085441273882241486, + 0.035226291882100656 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.035226291882100656, + 0.085441273882241486, + -0.13501102001039084, + -0.45987750211933132, + 0.80689150931333875, + -0.33267055295095688 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "sym4"){ + double lp1_a[] = {-0.075765714789273325, + -0.02963552764599851, + 0.49761866763201545, + 0.80373875180591614, + 0.29785779560527736, + -0.099219543576847216, + -0.012603967262037833, + 0.032223100604042702 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.032223100604042702, + -0.012603967262037833, + 0.099219543576847216, + 0.29785779560527736, + -0.80373875180591614, + 0.49761866763201545, + 0.02963552764599851, + -0.075765714789273325 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.032223100604042702, + -0.012603967262037833, + -0.099219543576847216, + 0.29785779560527736, + 0.80373875180591614, + 0.49761866763201545, + -0.02963552764599851, + -0.075765714789273325 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-0.075765714789273325, + 0.02963552764599851, + 0.49761866763201545, + -0.80373875180591614, + 0.29785779560527736, + 0.099219543576847216, + -0.012603967262037833, + -0.032223100604042702 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "sym5"){ + double lp1_a[] = {0.027333068345077982, + 0.029519490925774643, + -0.039134249302383094, + 0.1993975339773936, + 0.72340769040242059, + 0.63397896345821192, + 0.016602105764522319, + -0.17532808990845047, + -0.021101834024758855, + 0.019538882735286728 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.019538882735286728, + -0.021101834024758855, + 0.17532808990845047, + 0.016602105764522319, + -0.63397896345821192, + 0.72340769040242059, + -0.1993975339773936, + -0.039134249302383094, + -0.029519490925774643, + 0.027333068345077982 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.019538882735286728, + -0.021101834024758855, + -0.17532808990845047, + 0.016602105764522319, + 0.63397896345821192, + 0.72340769040242059, + 0.1993975339773936, + -0.039134249302383094, + 0.029519490925774643, + 0.027333068345077982 + +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.027333068345077982, + -0.029519490925774643, + -0.039134249302383094, + -0.1993975339773936, + 0.72340769040242059, + -0.63397896345821192, + 0.016602105764522319, + 0.17532808990845047, + -0.021101834024758855, + -0.019538882735286728 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "sym6"){ + double lp1_a[] = {0.015404109327027373, + 0.0034907120842174702, + -0.11799011114819057, + -0.048311742585632998, + 0.49105594192674662, + 0.787641141030194, + 0.3379294217276218, + -0.072637522786462516, + -0.021060292512300564, + 0.044724901770665779, + 0.0017677118642428036, + -0.007800708325034148 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {0.007800708325034148, + 0.0017677118642428036, + -0.044724901770665779, + -0.021060292512300564, + 0.072637522786462516, + 0.3379294217276218, + -0.787641141030194, + 0.49105594192674662, + 0.048311742585632998, + -0.11799011114819057, + -0.0034907120842174702, + 0.015404109327027373 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {-0.007800708325034148, + 0.0017677118642428036, + 0.044724901770665779, + -0.021060292512300564, + -0.072637522786462516, + 0.3379294217276218, + 0.787641141030194, + 0.49105594192674662, + -0.048311742585632998, + -0.11799011114819057, + 0.0034907120842174702, + 0.015404109327027373 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.015404109327027373, + -0.0034907120842174702, + -0.11799011114819057, + 0.048311742585632998, + 0.49105594192674662, + -0.787641141030194, + 0.3379294217276218, + 0.072637522786462516, + -0.021060292512300564, + -0.044724901770665779, + 0.0017677118642428036, + 0.007800708325034148 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "sym7"){ + double lp1_a[] = {0.0026818145682578781, + -0.0010473848886829163, + -0.01263630340325193, + 0.03051551316596357, + 0.067892693501372697, + -0.049552834937127255, + 0.017441255086855827, + 0.5361019170917628, + 0.76776431700316405, + 0.28862963175151463, + -0.14004724044296152, + -0.10780823770381774, + 0.0040102448715336634, + 0.010268176708511255 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.010268176708511255, + 0.0040102448715336634, + 0.10780823770381774, + -0.14004724044296152, + -0.28862963175151463, + 0.76776431700316405, + -0.5361019170917628, + 0.017441255086855827, + 0.049552834937127255, + 0.067892693501372697, + -0.03051551316596357, + -0.01263630340325193, + 0.0010473848886829163, + 0.0026818145682578781 + +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.010268176708511255, + 0.0040102448715336634, + -0.10780823770381774, + -0.14004724044296152, + 0.28862963175151463, + 0.76776431700316405, + 0.5361019170917628, + 0.017441255086855827, + -0.049552834937127255, + 0.067892693501372697, + 0.03051551316596357, + -0.01263630340325193, + -0.0010473848886829163, + 0.0026818145682578781 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.0026818145682578781, + 0.0010473848886829163, + -0.01263630340325193, + -0.03051551316596357, + 0.067892693501372697, + 0.049552834937127255, + 0.017441255086855827, + -0.5361019170917628, + 0.76776431700316405, + -0.28862963175151463, + -0.14004724044296152, + 0.10780823770381774, + 0.0040102448715336634, + -0.010268176708511255 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "sym8"){ + double lp1_a[] = {-0.0033824159510061256, + -0.00054213233179114812, + 0.031695087811492981, + 0.0076074873249176054, + -0.14329423835080971, + -0.061273359067658524, + 0.48135965125837221, + 0.77718575170052351, + 0.3644418948353314, + -0.051945838107709037, + -0.027219029917056003, + 0.049137179673607506, + 0.0038087520138906151, + -0.014952258337048231, + -0.0003029205147213668, + 0.0018899503327594609 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.0018899503327594609, + -0.0003029205147213668, + 0.014952258337048231, + 0.0038087520138906151, + -0.049137179673607506, + -0.027219029917056003, + 0.051945838107709037, + 0.3644418948353314, + -0.77718575170052351, + 0.48135965125837221, + 0.061273359067658524, + -0.14329423835080971, + -0.0076074873249176054, + 0.031695087811492981, + 0.00054213233179114812, + -0.0033824159510061256 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.0018899503327594609, + -0.0003029205147213668, + -0.014952258337048231, + 0.0038087520138906151, + 0.049137179673607506, + -0.027219029917056003, + -0.051945838107709037, + 0.3644418948353314, + 0.77718575170052351, + 0.48135965125837221, + -0.061273359067658524, + -0.14329423835080971, + 0.0076074873249176054, + 0.031695087811492981, + -0.00054213233179114812, + -0.0033824159510061256 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {-0.0033824159510061256, + 0.00054213233179114812, + 0.031695087811492981, + -0.0076074873249176054, + -0.14329423835080971, + 0.061273359067658524, + 0.48135965125837221, + -0.77718575170052351, + 0.3644418948353314, + 0.051945838107709037, + -0.027219029917056003, + -0.049137179673607506, + 0.0038087520138906151, + 0.014952258337048231, + -0.0003029205147213668, + -0.0018899503327594609 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "sym9"){ + double lp1_a[] = {0.0014009155259146807, + 0.00061978088898558676, + -0.013271967781817119, + -0.01152821020767923, + 0.03022487885827568, + 0.00058346274612580684, + -0.054568958430834071, + 0.238760914607303, + 0.717897082764412, + 0.61733844914093583, + 0.035272488035271894, + -0.19155083129728512, + -0.018233770779395985, + 0.06207778930288603, + 0.0088592674934004842, + -0.010264064027633142, + -0.00047315449868008311, + 0.0010694900329086053 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {-0.0010694900329086053, + -0.00047315449868008311, + 0.010264064027633142, + 0.0088592674934004842, + -0.06207778930288603, + -0.018233770779395985, + 0.19155083129728512, + 0.035272488035271894, + -0.61733844914093583, + 0.717897082764412, + -0.238760914607303, + -0.054568958430834071, + -0.00058346274612580684, + 0.03022487885827568, + 0.01152821020767923, + -0.013271967781817119, + -0.00061978088898558676, + 0.0014009155259146807 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {0.0010694900329086053, + -0.00047315449868008311, + -0.010264064027633142, + 0.0088592674934004842, + 0.06207778930288603, + -0.018233770779395985, + -0.19155083129728512, + 0.035272488035271894, + 0.61733844914093583, + 0.717897082764412, + 0.238760914607303, + -0.054568958430834071, + 0.00058346274612580684, + 0.03022487885827568, + -0.01152821020767923, + -0.013271967781817119, + 0.00061978088898558676, + 0.0014009155259146807 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.0014009155259146807, + -0.00061978088898558676, + -0.013271967781817119, + 0.01152821020767923, + 0.03022487885827568, + -0.00058346274612580684, + -0.054568958430834071, + -0.238760914607303, + 0.717897082764412, + -0.61733844914093583, + 0.035272488035271894, + 0.19155083129728512, + -0.018233770779395985, + -0.06207778930288603, + 0.0088592674934004842, + 0.010264064027633142, + -0.00047315449868008311, + -0.0010694900329086053 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + else if ( name == "sym10"){ + double lp1_a[] = {0.00077015980911449011, + 9.5632670722894754e-05, + -0.0086412992770224222, + -0.0014653825813050513, + 0.045927239231092203, + 0.011609893903711381, + -0.15949427888491757, + -0.070880535783243853, + 0.47169066693843925, + 0.7695100370211071, + 0.38382676106708546, + -0.035536740473817552, + -0.0319900568824278, + 0.049994972077376687, + 0.0057649120335819086, + -0.02035493981231129, + -0.00080435893201654491, + 0.0045931735853118284, + 5.7036083618494284e-05, + -0.00045932942100465878 +}; + lp1.assign (lp1_a,lp1_a + sizeof(lp1_a)/sizeof(double)); + + double hp1_a[] = {0.00045932942100465878, + 5.7036083618494284e-05, + -0.0045931735853118284, + -0.00080435893201654491, + 0.02035493981231129, + 0.0057649120335819086, + -0.049994972077376687, + -0.0319900568824278, + 0.035536740473817552, + 0.38382676106708546, + -0.7695100370211071, + 0.47169066693843925, + 0.070880535783243853, + -0.15949427888491757, + -0.011609893903711381, + 0.045927239231092203, + 0.0014653825813050513, + -0.0086412992770224222, + -9.5632670722894754e-05, + 0.00077015980911449011 +}; + hp1.assign (hp1_a,hp1_a + sizeof(hp1_a)/sizeof(double)); + + double lp2_a[] = {-0.00045932942100465878, + 5.7036083618494284e-05, + 0.0045931735853118284, + -0.00080435893201654491, + -0.02035493981231129, + 0.0057649120335819086, + 0.049994972077376687, + -0.0319900568824278, + -0.035536740473817552, + 0.38382676106708546, + 0.7695100370211071, + 0.47169066693843925, + -0.070880535783243853, + -0.15949427888491757, + 0.011609893903711381, + 0.045927239231092203, + -0.0014653825813050513, + -0.0086412992770224222, + 9.5632670722894754e-05, + 0.00077015980911449011 +}; + lp2.assign (lp2_a,lp2_a + sizeof(lp2_a)/sizeof(double)); + + double hp2_a[] = {0.00077015980911449011, + -9.5632670722894754e-05, + -0.0086412992770224222, + 0.0014653825813050513, + 0.045927239231092203, + -0.011609893903711381, + -0.15949427888491757, + 0.070880535783243853, + 0.47169066693843925, + -0.7695100370211071, + 0.38382676106708546, + 0.035536740473817552, + -0.0319900568824278, + -0.049994972077376687, + 0.0057649120335819086, + 0.02035493981231129, + -0.00080435893201654491, + -0.0045931735853118284, + 5.7036083618494284e-05, + 0.00045932942100465878 +}; + hp2.assign (hp2_a,hp2_a + sizeof(hp2_a)/sizeof(double)); + return 0; + } + + + else { + cout << "Filter Not in Database" << endl; + return -1; + } + +} + + + + diff --git a/src/lib/wlet2d.h b/src/lib/wlet2d.h new file mode 100644 index 0000000..a0ff4c9 --- /dev/null +++ b/src/lib/wlet2d.h @@ -0,0 +1,155 @@ +#ifndef WAVELET2D_H +#define WAVELET2D_H + +#include +#include + +using namespace std; + + +// 1D Functions + +void* dwt1(string, vector &, vector &, vector &); + +void* dyadic_zpad_1d(vector &); + +double convol(vector &, vector &, vector &); + +int filtcoef(string , vector &, vector &, vector &, + vector &); + +void downsamp(vector &, int , vector &); + +void upsamp(vector &, int, vector &); + +void circshift(vector &, int ); + +int sign(int); + +void* idwt1(string wname, vector &, vector &, vector &); + +int vecsum(vector &, vector &, vector &); + + + +// 1D Symmetric Extension DWT Functions + + + +void* dwt_sym(vector &, int ,string , vector &,vector &, + vector &); + +void* dwt1_sym(string , vector &, vector &, vector &); + +void* idwt_sym(vector &,vector &, string,vector &, vector &); + +void* symm_ext(vector &, int ); + +void* idwt1_sym(string, vector &, vector &, vector &); // Not Tested + +// 1D Stationary Wavelet Transform + +void* swt(vector &, int , string , vector &, int &) ; + +void* iswt(vector &,int , string, vector &); + +void* per_ext(vector &, int ); + + + + +// 2D Functions + +void* branch_lp_dn(string , vector &, vector &); + +void* branch_hp_dn(string , vector &, vector &); + +void* branch_lp_hp_up(string ,vector &, vector &, vector &); + +//void* dwt_2d(vector > &, int , string , vector > & + // , vector &) ; + +//void* idwt_2d(vector > &,vector &, string ,vector > &); + +void* dyadic_zpad_2d(vector > &,vector > &); + +void* dwt_output_dim(vector >&, int &, int & ); + +void* zero_remove(vector > &,vector > &) ; + +void* getcoeff2d(vector > &, vector > &, + vector > &,vector > &,vector &, int &); + +void* idwt2(string ,vector > &, vector > &, + vector > &, vector > &, vector > &); + +void* dwt2(string ,vector > &, vector > &, + vector > &, vector > &, vector > &); + +void* downsamp2(vector > &,vector > &, int, int); + +void* upsamp2(vector > &,vector > &, int, int); + +// 2D DWT (Symmetric Extension) Functions + +void* dwt_2d_sym(vector > &, int , string , vector &, vector & , + vector &); + +void* dwt2_sym(string ,vector > &, vector > &, + vector > &, vector > &, vector > &); + +void* idwt_2d_sym(vector &,vector &, string ,vector > &, + vector &); + +void* circshift2d(vector > &, int , int ); + +void symm_ext2d(vector > &,vector > &, int ); + +void* dispDWT(vector &,vector > &, vector &, vector &, int ) ; + +void* dwt_output_dim_sym(vector &,vector &, int ); + +//2D Stationary Wavelet Transform + +void* swt_2d(vector > &,int , string , vector &); + +void* per_ext2d(vector > &,vector > &, int ); + +// FFT functions + + +double convfft(vector &, vector &, vector &); + +double convfftm(vector &, vector &, vector &); + +void* fft(vector > &,int ,unsigned int); + +void* bitreverse(vector > &); + +void* freq(vector &, vector &); + +//New + + +void* dwt1_sym_m(string wname, vector &signal, vector &cA, vector &cD);//FFTW3 for 2D + +void* idwt1_sym_m(string wname, vector &X, vector &app, vector &detail); + +void* dwt(vector &sig, int J, string nm, vector &dwt_output + , vector &flag, vector &length ); + +void* idwt(vector &,vector &, string,vector &, vector &); + +void* dwt_2d(vector > &, int , string , vector &, vector & , + vector &); +void* dwt1_m(string wname, vector &signal, vector &cA, vector &cD) ; + +void* idwt_2d(vector &dwtop,vector &flag, string nm, + vector > &idwt_output, vector &length); + +void* idwt1_m(string wname, vector &X, vector &cA, vector &cD); + +void* dwt_output_dim2(vector &length, vector &length2, int J); + + +#endif/* WAVELET2D_H */ diff --git a/src/sample/imagedemo.cpp b/src/sample/imagedemo.cpp new file mode 100644 index 0000000..77da7d5 --- /dev/null +++ b/src/sample/imagedemo.cpp @@ -0,0 +1,197 @@ +//============================================================================ +// Name : imagedemo1.cpp +// Author : Rafat Hussain +// Version : +// Copyright : +// Description : DWT of arbitrary size image using symmetric or periodic extension +//============================================================================ + +#include +#include +#include +#include +#include +#include +#include +#include "../lib/wlet2d.h" +#include "cv.h" +#include "highgui.h" +#include "cxcore.h" + +using namespace std; +using namespace cv; + +void* maxval(vector > &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 &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 > vec1(rows, vector(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 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 length; + vector output,flag; + int J =3; + dwt_2d_sym(vec1,J,nm,output,flag,length); + + double max; + vector 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 > dwtdisp(rows_n, vector(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 > 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 > dwt_hold(rows_n, vector( 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 > idwt_output(rows, vector(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; +} \ No newline at end of file diff --git a/src/sample/swt2Ddemo.cpp b/src/sample/swt2Ddemo.cpp new file mode 100644 index 0000000..2879a8e --- /dev/null +++ b/src/sample/swt2Ddemo.cpp @@ -0,0 +1,178 @@ +//============================================================================ +// Name : swt2Ddemo.cpp +// Author : Rafat Hussain +// Version : +// Copyright : +// Description : 2D SWT Demo using OPENCV +//============================================================================ + +#include +#include +#include +#include +#include +#include +#include +#include "../lib/wlet2d.h" +#include +#include +#include +#include +//#include "cv.h" +//#include "highgui.h" +//#include "cxcore.h" + +using namespace std; +using namespace cv; + +void* maxval(vector > &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; +} + +int main() { + Mat img = imread("lena512.bmp"); + 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); + imshow("Original Image", img); + cvWaitKey(); + cvDestroyWindow("Original Image"); + imwrite("orig.bmp",img); + + + int rows =(int) height; + int cols =(int) width; + Mat matimg(img); + + vector > vec1(rows, vector(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 = "db2"; +// vector l1,h1,l2,h2; +// filtcoef(nm,l1,h1,l2,h2); + + + vector output; + int J =3; + swt_2d(vec1,J,nm,output); + cout << "OUTPUT size" << output.size() << endl; + cout << "LOOP OK" << endl; + + int row,col; + row=vec1.size(); + col=vec1[0].size(); + + // Extract and Display Low Pass Image at the Jth stage + + vector > blur(row,vector(col)); + + for (int i=0;i < row; i++){ + for (int j=0; j < col;j++){ + double temp = output[i*col + j]; + blur[i][j]= temp; + } + } + + double max; + maxval(blur,max); + + // Creating Image in OPENCV + IplImage *cvImg; // image used for output + CvSize imgSize; // size of output image + + imgSize.width = col; + imgSize.height = row; + + cvImg = cvCreateImage( imgSize, 8, 1 ); + + for (int i = 0; i < imgSize.height; i++ ) { + for (int j = 0; j < imgSize.width; j++ ){ + if ( blur[i][j] <= 0.0){ + blur[i][j] = 0.0; + } + + ((uchar*)(cvImg->imageData + cvImg->widthStep*i))[j] = + (char) ( (blur[i][j] / max) * 255.0); + + } + } + + cvNamedWindow( "Low Pass Image", 1 ); // creation of a visualisation window + imshow( "Low Pass Image", cvImg ); // image visualisation + cvWaitKey(); + cvDestroyWindow("Low Pass Image"); + imwrite("blur.bmp",cvImg); + + // Displaying BandPass Images + + vector > detail(3*row,vector(J * col)); + + for (int k=0; k < J; k++) { + for (int i=0; i < 3*row; i++) { + for(int j=0+ k*col; j < (k+1)*col; j++) { + double temp = output[(3*k+1)*row*col+ i * col +j - k*col]; + detail[i][j]= temp; + } + } + } + Mat dvImg; // image used for output + CvSize imgSz; // size of output image + + imgSz.width = J*col; + imgSz.height = 3*row; + + dvImg = cvCreateImage( imgSz, 8, 1 ); + + for (int i = 0; i < imgSz.height; i++ ) { + for (int j = 0; j < imgSz.width; j++ ){ + if ( detail[i][j] <= 0.0){ + detail[i][j] = 0.0; + } + + ((uchar*)(dvImg->imageData + dvImg->widthStep*i))[j] = + (char) detail[i][j]; + + } + } + + cvNamedWindow( "Band Pass Image", 1 ); // creation of a visualisation window + imshow( "Band Pass Image", dvImg ); // image visualisation + cvWaitKey(); + cvDestroyWindow("Band Pass Image"); + imwrite("detail.bmp",dvImg); + + + return 0; +} \ No newline at end of file diff --git a/src/sample/swtdemo.cpp b/src/sample/swtdemo.cpp new file mode 100644 index 0000000..e6cd511 --- /dev/null +++ b/src/sample/swtdemo.cpp @@ -0,0 +1,93 @@ +//============================================================================ +// Name : swtdemo.cpp +// Author : Rafat Hussain +// Version : +// Copyright : +// Description : 1D Stationary Wavelet Transform Demo +//============================================================================ + +#include +#include +#include "../lib/wlet2d.h" +#include +#include +#include +using namespace std; + +int main() { + cout << "********J- LEVEL DISCRETE WAVELET TRANSFORM IMPLEMENTATION*********" << endl; // prints + 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 sig; + ifstream sig_inp(inp); + if ( !sig_inp.good()){ + cout << "The File doesn't exist"<< endl; + } + while (sig_inp) { + double temp; + sig_inp >> temp; + sig.push_back(temp); + } + sig.pop_back(); + vector original; + original = sig; // Make a copy of the signal if you want to use original signal + // later on. The other option is to use IDWT output as the SWt/ISWT system is + // Perefect Reconstruction system. + cout << "Please Enter the Number of DWT Stages J :" << endl; + + int J; + cin >> J ; + + vector swt_output; + + // perform J-Level DWT + int length;// All coefficients are of same length. Variable "length" returns length + // of coefficients. It is not required for ISWT computations. + + + + swt(sig, J, nm, swt_output, length); + cout << "coeff-len = " << length << endl; + + ofstream swtcoeff("swtcoeff.txt"); + for (unsigned int i=0; i < swt_output.size(); i++) { + swtcoeff << swt_output[i] << endl; + } + + // remove high level details + for (int i = 0; i < 200; i++) + { + swt_output[200+i] = 0.0; + } + + vector iswt_output; + iswt(swt_output,J, nm,iswt_output); + ofstream sig1("recon.txt"); + ofstream diff("diff.txt"); + + cout <<" Recon signal size" << iswt_output.size() << endl; + for (unsigned int i = 0; i < iswt_output.size(); i++){ + sig1 << iswt_output[i] << " " << original[i] << endl; + diff << iswt_output[i] - original[i] << endl; + + } + + + return 0; +} diff --git a/src/sample/wavedemo.cpp b/src/sample/wavedemo.cpp new file mode 100644 index 0000000..037ff47 --- /dev/null +++ b/src/sample/wavedemo.cpp @@ -0,0 +1,83 @@ +//============================================================================ +// Name : wavedemo1.cpp +// Author : Rafat Hussain +// Version : +// Copyright : +// Description : 1D DWT Demo +//============================================================================ + +#include +#include +#include "../lib/wlet2d.h" +#include +#include +#include +using namespace std; + +int main() { + cout << "********J- LEVEL DISCRETE WAVELET TRANSFORM IMPLEMENTATION*********" << endl; // prints + 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 sig; + ifstream sig_inp(inp); + if ( !sig_inp.good()){ + cout << "The File doesn't exist"<< endl; + } + while (sig_inp) { + double temp; + sig_inp >> temp; + sig.push_back(temp); + } + sig.pop_back(); + vector original; + original = sig; + cout << "Please Enter the Number of DWT Stages J :" << endl; + + int J; + cin >> J ; + + vector dwt_output, flag; + + // perform J-Level DWT + vector length; + + dwt_sym(sig, J, nm, dwt_output,flag,length); + ofstream dwtout("dwtout.txt"); + for (unsigned int i = 0; i < dwt_output.size(); i++){ + dwtout << dwt_output[i] << endl; + + } + + + //Perform J-Level IDWT + vector output; + idwt_sym(dwt_output, flag,nm,output,length); + + ofstream sig1("recon.txt"); + ofstream diff("diff.txt"); + + cout <<" Recon signal size" << output.size() << endl; + for (unsigned int i = 0; i < output.size(); i++){ + sig1 << output[i] << endl; + diff << output[i] - original[i] << endl; + + } + //gnudwtplot(J); + return 0; +} \ No newline at end of file diff --git a/src/README b/src_deprecated/README similarity index 100% rename from src/README rename to src_deprecated/README diff --git a/src/changelog-05-27.txt b/src_deprecated/changelog-05-27.txt similarity index 100% rename from src/changelog-05-27.txt rename to src_deprecated/changelog-05-27.txt diff --git a/src/license.txt b/src_deprecated/license.txt similarity index 100% rename from src/license.txt rename to src_deprecated/license.txt diff --git a/src/signal.txt b/src_deprecated/signal.txt similarity index 100% rename from src/signal.txt rename to src_deprecated/signal.txt diff --git a/src/wave1d.cpp b/src_deprecated/wave1d.cpp similarity index 100% rename from src/wave1d.cpp rename to src_deprecated/wave1d.cpp diff --git a/src/wave1d.h b/src_deprecated/wave1d.h similarity index 100% rename from src/wave1d.h rename to src_deprecated/wave1d.h diff --git a/src/wavelet.cpp b/src_deprecated/wavelet.cpp similarity index 100% rename from src/wavelet.cpp rename to src_deprecated/wavelet.cpp diff --git a/src/wavelet.h b/src_deprecated/wavelet.h similarity index 100% rename from src/wavelet.h rename to src_deprecated/wavelet.h