Wavelet1d

dwt_output_dim_sym(length, length2, J);
// ...
int siz = length2.size();
int rows_n = length2[siz - 2];
int cols_n = length2[siz - 1];
Vector2d dwtdisp(rows_n, Vector1d(cols_n));

void* dwt_output_dim_sym(vector<int> &length, vector<int> &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;
}

// 3.5 Image Approximation Demo
// http://wavelet2d.sourceforge.net/
IplImage * createDWTImage(IplImage * original)
{
    using namespace std;
    using namespace cv;

    int height = original->height;
    int width = original->width;
    // int channels = original->nChannels;
    // int depth = original->depth;

    Mat matrix_original(original);
    Vector2d vector_original(height, Vector1d(width));

    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            const int k = 1; // what is k ?
            uchar * image_cursor = (uchar*) matrix_original.data + y * matrix_original.step;
            uchar pixel = image_cursor[x * matrix_original.elemSize() + k];
            vector_original[y][x] = (double) pixel;
        }
    }

    std::string nm = "db2"; // Daubechies : db1,db2,.., ,db15

    Vector1d 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 0 (eg., int e = 0)
    Vector1i length;
    Vector1d output, flag;

    int J = 1; // depth of dwt.
    dwt_2d(vector_original, J, nm, output, flag, length);

    double max;
    Vector1i 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];
    Vector2d dwtdisp(rows_n, Vector1d(cols_n));

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

    // dispDWT returns the 2D object dwtdisp which will be displayed using OPENCV’s image
    // handling functions
    Vector2d dwt_output = dwtdisp;

    // Storing the DWT coefficients in two different vectors that will be used to approximate
    // Image with two different sets of chosen coefficients.
    Vector1d dwt_coef1;
    Vector1d dwt_coef2;
    dwt_coef1 = output;
    dwt_coef2 = output;

    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.
    Vector2d dwt_hold(rows_n, Vector1d(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();

    return cvImg;
}