wavwin.cpp

wavlet compression on c++ only cods

// Copyright (c) 1999 Stephen T. Welstead. All rights reserved.
// File WAVWIN.CPP  Wavelet image compression window

#define STRICT

#include <malloc.h>
#include <string.h>
#include <time.h>

#include "uwl.h"
#include "utofile.h"
#include "utm.h"
#include "wavrids.h"
#include "wavelet.h"
#include "wave_dlg.h"
#include "wavwin.h"

twavelet_window_manager *the_wavelet_window_manager;

LRESULT CALLBACK _export WaveletWndProc (HWND hwnd, UINT message,
     WPARAM wParam,LPARAM lParam)
     {
     return
       (LRESULT CALLBACK) (the_wavelet_window_manager->
		handle_message (hwnd, message, wParam, lParam)) ;
     }

twavelet_window_manager::twavelet_window_manager (HINSTANCE hInstance,
     tmdi_frame_window *parent, LPCSTR menu_name,
     LPCSTR class_name):
    tmdi_manager (hInstance,parent,(LRESULT CALLBACK)WaveletWndProc,
	0,menu_name,"Wavelet Window",class_name,"WAV_ICON"){ }

void twavelet_window_manager::set_global_ptr (void) {
    the_wavelet_window_manager = this;}

int twavelet_window_manager::respond_wm_create (HWND hwnd) {
    child_window_struct *child;
    char *file_name;
    hwndClient = GetParent (hwindow) ;
    hwndFrame  = GetParent (hwndClient) ;
    file_name = new char [MAX_IMG_FILENAME_LEN+1];
    file_name[0] = '\0';
    if (!get_file_name_dlg (hwndClient,"*.bmp",
      "Bitmap File",file_name,MAX_IMG_FILENAME_LEN,OPEN_DLG)) {
       SendMessage (GetParent (hwnd), WM_MDIDESTROY,(WPARAM) hwnd, 0L) ;
       return 1;
       }
    child = new child_window_struct;
    child->hwnd = hwnd;
    child->window = new twavelet_window(hwnd,this,file_name);
    add_child_window (hwnd,child);
    return 1;
    }

twavelet_window::twavelet_window(HWND hwnd,
     tmdi_manager *the_manager,LPSTR the_image_filename)
     : timg_window(hwnd,the_manager,the_image_filename)
{
   image_obj = new timage();
   wavelet_image = new timage ();
   delete display_image;
   display_image = image_obj;
   p_image_palette = 0;
   gray_image_available = 0;
   compression_percent = 10.0;
   transform_threshold_percent = 50.0;
   wavelet_type = 0;  // 0 = Haar wavelet; 1 = Daub4; 2 = Daub6
   scale_values = 0;
   set_wavelet_name(wavelet_type);
}

void twavelet_window::set_wavelet_name(int type) {
    switch (type) {
    case 1:
       strncpy (wavelet_name,"Daub4 Wavelet",WAV_NAME_LEN);
       break;
    case 2:
       strncpy (wavelet_name,"Daub6 Wavelet",WAV_NAME_LEN);
       break;
    default:
       strncpy (wavelet_name,"Haar Wavelet",WAV_NAME_LEN);
       }  // end switch
    wavelet_name[WAV_NAME_LEN] = '\0';
    return;
    }

int twavelet_window::respond_wm_create (HWND hwnd) {
    timg_window::respond_wm_create(hwnd);
    if (!read_BMP_file (hwindow,image_filename)) return 0;
    return 1;
    }

int twavelet_window::OnRun () {
    int rows = bmHeight,cols = bmWidth;
    if (wavelet_image->s.rows) {
       show_gray_image (wavelet_image);
       return 1;
       }
    if (!image_obj->s.rows) {
       if (!image_obj->allocate_image_struct
		 (rows,cols)) return 1;
       get_gray_image(image_obj);
       }
    show_gray_image(image_obj);
    return 1;
    }

int twavelet_window::get_compression_percent () {
    float value = compression_percent;
    int maxlen = 8,dec_places = 4,max_val = 100.0,min_val = 0.0;
    if (numeric_dialog (hwindow,
	"Compression Percent","Enter new compression percent",maxlen,
	dec_places,REAL_DATA,1,max_val,min_val,&value))
	compression_percent = value;
    return 1;
    }

int twavelet_window::get_transform_threshold () {
    float value = transform_threshold_percent;
    int maxlen = 6,dec_places = 2,max_val = 100.0,min_val = 0.0;
    if (numeric_dialog (hwindow,
	"Transform Threshold Percent","Enter new transform threshold %",maxlen,
	dec_places,REAL_DATA,1,max_val,min_val,&value))
	transform_threshold_percent = value;
    return 1;
    }

int twavelet_window::get_wavelet_type () {
    twave_dialog *wavelet_dlg = new twave_dialog (hwindow,wavelet_type);
    if (wavelet_dlg->exec_dialog())
       wavelet_type = wavelet_dlg->wavelet_choice;
    delete wavelet_dlg;
    set_wavelet_name(wavelet_type);
    return 1;
    }

int twavelet_window::get_wavelet_compressed_image ()
    {
    switch (wavelet_type) {
    case 1:
	 Daub4_wavelet = new tDaub4_wavelet();
	 wavelet_compression (Daub4_wavelet);
	 delete Daub4_wavelet;
	 break;
    case 2:
	 Daub6_wavelet = new tDaub6_wavelet();
	 wavelet_compression (Daub6_wavelet);
	 delete Daub6_wavelet;
	 break;
    default:
	 Haar_wavelet = new tHaar_wavelet();
	 wavelet_compression (Haar_wavelet);
	 delete Haar_wavelet;
	 }  //
    return 1;
    }

int twavelet_window::wavelet_compression (twavelet *wavelet) {
    float **values = 0;
    HCURSOR save_cursor,hour_glass_cursor;
    int rows = bmHeight,cols = bmWidth,i,j;
    time_t start_time,end_time,wavelet_transform_time,
	decimation_time,compression_time,inverse_transform_time,elapsed_time;
    float max,min,range;
    int int_value;

    if (!image_obj->s.rows) {
       if (!image_obj->allocate_image_struct
	       (rows,cols)) return 1;
       get_gray_image(image_obj);
       }
    if (wavelet_image->s.rows)
       wavelet_image->delete_image_struct ();
    if (!wavelet_image->allocate_image_struct
	   (rows,cols)) return 1;
    if (!(values = matrix2d (1,rows,1,cols))) return 1;
    hour_glass_cursor = LoadCursor(NULL,IDC_WAIT);
    save_cursor = SetCursor (hour_glass_cursor);
    int image_min = image_obj->s.pixel[1][1],
	image_max = image_obj->s.pixel[1][1],
	image_range;
    for (i=1;i<=rows;i++)
	for (j=1;j<=cols;j++) {
	     values[i][j] = image_obj->s.pixel[i][j];
	     if (image_min > image_obj->s.pixel[i][j])
		image_min = image_obj->s.pixel[i][j];
	     if (image_max < image_obj->s.pixel[i][j])
		image_max = image_obj->s.pixel[i][j];
		}
    image_range = image_max - image_min;
    message_printf (MB_INFO,"Compress",
      "Image Min: %d\r\nImage Max: %d\r\nImage Range: %d",
      image_min,image_max,image_range);
    twavelet_2d_array *wavelet_array = new twavelet_2d_array (values,
	wavelet,rows,cols);
    start_time = time(NULL);
    wavelet_array->transform();
    end_time = time(NULL);
    wavelet_transform_time = end_time - start_time;
    start_time = time(NULL);
    wavelet_array->decimate (compression_percent);
    end_time = time(NULL);
    decimation_time = end_time - start_time;
    compression_time = wavelet_transform_time + decimation_time;
    start_time = time(NULL);
    wavelet_array->inverse_transform();
    end_time = time(NULL);
    inverse_transform_time = end_time - start_time;
    elapsed_time = compression_time + inverse_transform_time;
    message_printf (MB_INFO,"Elapsed Time",
      "Wavelet Transform Time:   %ld\r\n"
      "Decimation Time:   %ld\r\n"
      "Total Compression Time:   %ld\r\n"
      "Inverse Transform Time:   %ld\r\n"
      "Total Elapsed Time: %ld\r\n",
      wavelet_transform_time,
      decimation_time,
      compression_time,
      inverse_transform_time,
      elapsed_time);

    min = wavelet_array->inverse_min;
    max = wavelet_array->inverse_max;
    range = max - min;
    if (range < 1) range = 1;
    message_printf (MB_INFO,"Compress",
      "Transform min: %7.4f\r\n"
      "Transform max: %7.4f\r\n"
      "Inverse min: %7.4f\r\n"
      "Inverse max: %7.4f",wavelet_array->transform_min,
         wavelet_array->transform_max,min,max);
    for (i=1;i<=rows;i++)
	for (j=1;j<=cols;j++) {
	    if (scale_values)
	    int_value =
		  (int) (((wavelet_array->values[i][j] - min)/range)
			     *image_range + image_min);
	    else
	    int_value =
		  (int) wavelet_array->values[i][j];  
	    if (int_value < 0) int_value = 0;
	    if (int_value > WAV_GRAY_LEVELS-1) int_value = WAV_GRAY_LEVELS-1;
	    wavelet_image->s.pixel[i][j] = (unsigned char)int_value;
	    }

    SetCursor (save_cursor);
    delete wavelet_array;
    free_matrix2d (values,1,rows,1);
    display_image = wavelet_image;
    show_gray_image(wavelet_image);

    sprintf ((char *)the_title,"%s (%5.2f%%): %s",wavelet_name,
	  compression_percent,(char *)image_filename);
    SetWindowText (hwindow,the_title);
    return 1;
    }

int twavelet_window::show_wavelet_transform ()
    {
    switch (wavelet_type) {
    case 1:
	 Daub4_wavelet = new tDaub4_wavelet();
	 wavelet_transform (Daub4_wavelet);
	 delete Daub4_wavelet;
	 break;
    case 2:
	 Daub6_wavelet = new tDaub6_wavelet();
	 wavelet_transform (Daub6_wavelet);
	 delete Daub6_wavelet;
	 break;
    default:
	 Haar_wavelet = new tHaar_wavelet();
	 wavelet_transform (Haar_wavelet);
	 delete Haar_wavelet;
	 }  //
    return 1;
    }

int twavelet_window::wavelet_transform (twavelet *wavelet) {
    float **values = 0,max,min,range;
    HCURSOR save_cursor,hour_glass_cursor;
    int rows = bmHeight,cols = bmWidth,i,j;

    if (!image_obj->s.rows) {
       if (!image_obj->allocate_image_struct
	       (rows,cols)) return 1;
       get_gray_image(image_obj);
       }
    if (wavelet_image->s.rows)
       wavelet_image->delete_image_struct ();
    if (!wavelet_image->allocate_image_struct
	   (rows,cols)) return 1;
    if (!(values = matrix2d (1,rows,1,cols))) return 1;
    hour_glass_cursor = LoadCursor(NULL,IDC_WAIT);
    save_cursor = SetCursor (hour_glass_cursor);
    for (i=1;i<=rows;i++)
	for (j=1;j<=cols;j++)
	     values[i][j] = image_obj->s.pixel[i][j];
    twavelet_2d_array *wavelet_array = new twavelet_2d_array (values,
	wavelet,rows,cols);
    wavelet_array->transform();
    wavelet_array->decimate(transform_threshold_percent);

    min = wavelet_array->transform_min;
    max = wavelet_array->transform_max;
    range = max - min;
    for (i=1;i<=rows;i++)
	for (j=1;j<=cols;j++)  {
	    if (wavelet_array->values[i][j] > 0.0)
		wavelet_image->s.pixel[i][j] = 0;  // BLACK
	    else
	    wavelet_image->s.pixel[i][j] = WAV_GRAY_LEVELS - 1;  // WHITE
	    }

    SetCursor (save_cursor);
    delete wavelet_array;
    free_matrix2d (values,1,rows,1);
    display_image = wavelet_image;
    show_gray_image(wavelet_image);

    sprintf ((char *)the_title,"%s Transform (%5.2f%%): %s",
	 (char *)wavelet_name,transform_threshold_percent,
	 (char *)image_filename);
    SetWindowText (hwindow,the_title);
    return 1;
    }

int twavelet_window::respond_wm_paint () {
   // Calls to Beginpaint and EndPaint required when handling
   // WM_PAINT message.
    if (!wavelet_image->s.rows)
       return timg_window::respond_wm_paint();
    PAINTSTRUCT     ps;
    HDC hdc = BeginPaint (hwindow,&ps);
    if (!hbitmap)
       message_puts (MB_EXCLAIM,"Wavelet","hbitmap is 0!");
    show_bitmap_image(hdc,hbitmap,p_image_palette);
    EndPaint (hwindow, &ps);
    return 1;
   }

int twavelet_window::respond_wm_command (WPARAM wParam,
    LPARAM) {
    switch (wParam)
       {
       case WAV_GRAY_IMAGE:
	    return OnRun();
       case WAV_WAVELET:
	    return get_wavelet_compressed_image();
       case WAV_SETUP:
	    return get_compression_percent();
       case WAV_THRESHOLD:
	    return get_transform_threshold();
       case WAV_TYPE:
	    return get_wavelet_type();
       case WAV_TRANSFORM:
	    return show_wavelet_transform();
       }  // end switch

    return timg_window::respond_wm_command (wParam,0L);
    }

int twavelet_window::respond_wm_destroy (HWND hwnd) {
    if (p_image_palette) free ((char *)p_image_palette);
    if (himage_bitmap) DeleteObject (himage_bitmap);
    delete [] image_filename;
    if (image_obj)
       delete image_obj;
    if (wavelet_image)
       delete wavelet_image;
    display_image = 0;
    timg_window::respond_wm_destroy (hwnd);
    return 1;
    }