eddy

#include "wavedec.h"
#include "events.h"
#include "macros.h"
#include "alloc.h"
#include "wav_filters.h"
#include "wav_trf.h"
#include "wav_gen.h"

float **imageR = NULL, **imageG = NULL, **imageB = NULL;
float min_, max_, QMax[2][2], QMin[2][2], Widths[2][2], Areas[2][2];
int wImageSize;
GLubyte *WaveletBits = NULL;
int more_info = 0;

void alloc_mem(){
    int size, i, j;
    if(imageR) free_2d_float(imageR, wImageSize);
    if(imageG) free_2d_float(imageG, wImageSize);
    if(imageB) free_2d_float(imageB, wImageSize);
//  if(WaveletBits) free(WaveletBits);
    wImageSize = (GRAB_WIDTH > GRAB_HEIGHT) ? GRAB_WIDTH : GRAB_HEIGHT;
    i = 0; j = wImageSize;
    while(j>>=1) i++; // получаем ближайшую к wImageSize степень 2 снизу
    if(wImageSize != 1<<i) wImageSize = 1<<(i+1);
    size = wImageSize * wImageSize;
    imageR = allocate_2d_float(wImageSize, wImageSize, 1);
    imageG = allocate_2d_float(wImageSize, wImageSize, 1);
    imageB = allocate_2d_float(wImageSize, wImageSize, 1);
    if(!WaveletBits) WaveletBits = (GLubyte *)calloc(3*size, sizeof(GLubyte));
//  WARN("init memory for wavelets, ext size=%d\n", wImageSize);
}
/*
void emptyMem(){
    int i,j;
    for(i=0; i<wImageSize; i++)
        for(j=0; j<wImageSize; j++)
            imageR[j][i]=imageG[j][i]=imageB[j][i] = 0.;
}*/

void initWavelet(){ // инициализация вейвлет-пространства и изображения для в.анализа
    int i, j, k;
    float *ptr[3];
//  if(!(WaveletBits && imageR && imageG && imageB))
        alloc_mem();
//  emptyMem();
    GLubyte *bytes = BitmapBits;
    for(j = wImageSize - GRAB_HEIGHT; j < wImageSize; j++){
        ptr[0] = imageR[j]; ptr[1] = imageG[j]; ptr[2] = imageB[j];
        for(i = 0; i < GRAB_WIDTH; i++){
            for(k = 0; k < 3; k++)
                *(ptr[k]++) = (float)(*bytes++);
        }
    }
/*  fprintf(stderr, "Массив для вейвлетов инициализирован. размеры: %dx%d (увелич.: %d)\n",
        GRAB_WIDTH, GRAB_HEIGHT, wImageSize);*/
}

void mkWavedec(){
    float *ptr[3],  wdth;
    int j, i, k;
    const int levs=1;
    int Nl,Nh;
    float *lp,*hp;
    int shift_arr_r[MAX_ARR_SIZE],shift_arr_c[MAX_ARR_SIZE];
    GLubyte *bytes;
    inline void findminmax(float **image, char flag){
        int w2 = GRAB_WIDTH/2-1, h2 = GRAB_HEIGHT/2-1, s2 = wImageSize/2;
        int XLb = w2, XHb = s2+w2, YLb = h2, YHb = s2+h2;
        int i, j, px, py;
        float *ptr, pixval;
        if(flag){
            min_ = 1e30; max_ = -1e30;
            for(i=0; i<2; i++) for(j=0; j<2; j++){
                QMax[i][j] = -1e30; QMin[i][j] = 1e30;
                Areas[i][j] = 0.;
            }
        }
        for(j=0; j<YHb; j++){
            if(j < YLb) py = 1;
            else if(j > s2) py = 0;
            else continue;
            ptr = &image[j][1];
            for(i=1; i<XHb; i++, ptr++){
                if(i < XLb) px = 0;
                else if(i > s2) px = 1;
                else continue;
                pixval = *ptr;
                if(min_ > pixval) min_ = pixval;
                else if(max_ < pixval) max_ = pixval;
                if(QMin[py][px] > pixval) QMin[py][px] = pixval;
                else if(QMax[py][px] < pixval) QMax[py][px] = pixval;
                Areas[py][px] += fabs(pixval);
            }
        }
    }
    inline GLubyte testpix(int pix){
        int res = pix; if(res < 0) res = 0; else if(res > 255) res = 255;
        return (GLubyte)res;
    }
    initWavelet();
    for(i=levs-1; i>=0; i--)
        shift_arr_r[i]=shift_arr_c[i]=0;
    choose_filter('H', 9);
    lp=MFLP;Nl=Nflp;
    hp=MFHP;Nh=Nfhp;
    wav2d_inpl(imageR,wImageSize,wImageSize,levs,lp,Nl,hp,Nh,1,shift_arr_r,shift_arr_c);
    wav2d_inpl(imageG,wImageSize,wImageSize,levs,lp,Nl,hp,Nh,1,shift_arr_r,shift_arr_c);
    wav2d_inpl(imageB,wImageSize,wImageSize,levs,lp,Nl,hp,Nh,1,shift_arr_r,shift_arr_c);
    findminmax(imageR, 1);
    findminmax(imageG, 0);
    findminmax(imageB, 0);
    wdth = 255. / (max_ - min_);
    bytes = WaveletBits;
    for(j = 0; j < wImageSize; j++){
        ptr[0] = imageR[j]; ptr[1] = imageG[j]; ptr[2] = imageB[j];
        for(i = 0; i < wImageSize; i++){
            for(k = 0; k < 3; k++)
                *bytes++ = (GLubyte) ((*(ptr[k]++) - min_) * wdth);
        }
    }
    for(j=0; j<2; j++) for(i=0; i<2; i++)
        Widths[j][i] = QMax[j][i] - QMin[j][i];
    if(!more_info) return;
    fprintf(stderr, "max=%.3g, min=%.3g\n", max_, min_);
    fprintf(stderr, "Экстремумы по квадрантам (min, max):\n");
    fprintf(stderr, "(%.3g, %.3g)\t\t\t(%.3g, %.3g)\n", QMin[0][0], QMax[0][0],
        QMin[0][1], QMax[0][1]);
    fprintf(stderr, "(%.3g, %.3g)\t\t\t(%.3g, %.3g)\n", QMin[1][0], QMax[1][0],
        QMin[1][1], QMax[1][1]);
}