wavzwin.cpp

wavlet compression on c++ only cods

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

#define STRICT

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

#include "uwl.h"
#include "utofile.h"
#include "utm.h"
#include "imgproc.h"
#include "wavrids.h"
#include "wavelet.h"
#include "wavzwin.h"

twavelet_zerotree_window_manager *the_wavelet_zerotree_window_manager;

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

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

void twavelet_zerotree_window_manager::set_global_ptr (void) {
    the_wavelet_zerotree_window_manager = this;}

int twavelet_zerotree_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_zerotree_window(hwnd,this,file_name);
    add_child_window (hwnd,child);
    return 1;
    }

twavelet_zerotree_window::twavelet_zerotree_window(HWND hwnd,
     tmdi_manager *the_manager,LPSTR the_image_filename)
     : twavelet_window(hwnd,the_manager,the_image_filename)
{
   symbol_array = 0;
   // Used for decimation of wavelet coefficients prior to zerotree coding:
   compression_percent = 0.0;
   bit_count = 0;
   bit_plane_count = 0;
   bit_plane_total = 0;
   selected_max_bit_plane = 0;
   show_symbols = 1;
   show_bit_planes = 0;
   // Used for displaying bit-planes during encoding:
   z_incr = WAV_GRAY_LEVELS/(NO_OF_SYMBOLS-1);
}

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

float get_threshold (float value,int &log_2_n) {
    // Get largest power of 2 less than value.
    float T = 1.0;
    log_2_n = 0;
    while (fabs (value) > T) {
       T *= 2;
       log_2_n++;
       }
    log_2_n -= 1;
    return T/2;
    }

int twavelet_zerotree_window::get_max_bit_plane () {
    int value = selected_max_bit_plane;
    if (numeric_dialog (hwindow,
       "Max Bit Plane","Max Bit Plane (0 for Default Max):",3,0,
       INT_DATA,1,32,0,&value))
       selected_max_bit_plane = value;
    return 1;
    }

int twavelet_zerotree_window::show_gray_image (timage *image_obj) {
    int i,j,value,gray_levels = image_obj->gray_levels;
    int gray_factor = SCREEN_GRAY_LEVELS/gray_levels;
    HPALETTE hpalette,old_hpalette;
    BOOL BGFlag = 0;
    if (!image_obj->s.rows) return 0;
    if (!graph_setup(&gr)) return 0;
    clear_window(&gr);

    int max = (image_obj->s.pixel)[1][1];
    int min = max;

    if (!p_gray_palette)
       make_grayscale_palette ();
    if (!(hpalette = CreatePalette (p_gray_palette))) {
	message_puts (MB_EXCLAIM,"wavzwin",
	  "CreatePalette failed!");
	  }
    if (hpalette) {
	if (!(old_hpalette = SelectPalette (gr.hDC,hpalette,BGFlag)))
	   message_puts (MB_EXCLAIM,"wavzwin",
	     "SelectPalette failed!");
	int ret_value = RealizePalette (gr.hDC);
	}

     if (show_symbols) {
     char num_str[10],descr[] = "Bit Plane:";
     sprintf (num_str,"%2d of %2d",bit_plane_count,bit_plane_total);
     SetTextColor (gr.hDC,gr_setup.text_color);
     TextOut (gr.hDC,gr.iter_col,gr.iter_row_1,descr,strlen(descr));
     ExtTextOut (gr.hDC,gr.iter_col,gr.iter_row_2,
	  ETO_OPAQUE,&gr.iter_rect,num_str,strlen(num_str),NULL);

    // Show scale:
    int row_inc = 4*gr.y_space;
    int row = gr.draw_rect.top + gr.y_space;
    int col = 2*gr.x_space;
    int col_end = col + 4*gr.x_space;

    for (i=1;i<=NO_OF_SYMBOLS;i++) {
	int gray_value = (i-1)*z_incr;
	if (gray_value >= WAV_GRAY_LEVELS-1) {
	    gray_value = WAV_GRAY_LEVELS-1;
	    HPEN black_pen,old_pen;
	    black_pen = CreatePen (PS_SOLID,1,PALETTEINDEX(0));
	    old_pen = (HPEN)SelectObject (gr.hDC,black_pen);
	    MOVE_TO(gr.hDC,col,row);
	    LineTo (gr.hDC,col,row+row_inc);
	    LineTo (gr.hDC,col_end,row+row_inc);
	    LineTo (gr.hDC,col_end,row);
	    SelectObject (gr.hDC,old_pen);
	    DeleteObject (black_pen);
	    }
	 else
	 color_rect (gr.hDC,col,row,col_end,row+row_inc,
	      PALETTEINDEX(gray_value));
	 switch (i) {
	 case POS:
	     strcpy (num_str,"POS");
	     break;
	 case NEG:
	     strcpy (num_str,"NEG");
	     break;
	 case IZ:
	     strcpy (num_str,"IZ");
	     break;
	 case ZR:
	     strcpy (num_str,"ZR");
	     break;
	 case ZT:
	     strcpy (num_str,"ZT");
	     break;
	 default:
	     sprintf (num_str,"%d",i); // shouldn't get here!
	 }  // end switch
	 TextOut(gr.hDC,col_end+gr.x_space,row,
	     num_str,strlen(num_str));
	 row += row_inc;
	 }
    }  // end if show_symbols

    for (i=1;i<=image_obj->s.rows;i++)
	for (j=1;j<=image_obj->s.cols;j++) {
	    value = (image_obj->s.pixel)[i][j];
	    if (value < 0)
	       value = 0;
	    if (value > gray_levels-1)
	       value = gray_levels-1;
	    if (value < min) min = value;
	    if (value > max) max = value;
	    put_gray_pixel (&gr,i,j,
		value*gray_factor);
	    }

    get_bitmap_from_screen(gr.draw_rect.left,gr.draw_rect.top,
	  image_obj->s.cols,image_obj->s.rows);

    if (hpalette)
       SelectPalette (gr.hDC,old_hpalette,BGFlag);
    release_dc (&gr);
    DeleteObject (hpalette);
    gray_image_available = 1;
    return 1;
    }

int show_msg = 1;

void twavelet_zerotree_window::write_symbol (short symbol,FILE *output_file) {
    // Each output symbol occupies 2 bits. This routine collects the
    // output symbols and keeps count (bit_count) and writes
    // out a full byte (symbol_bits) when 4 symbols have been
    // collected.
    unsigned bit_symbol = 0;
    switch (symbol) {
    case POS:
	 bit_symbol = BIT_POS;
	 break;
    case NEG:
	 bit_symbol = BIT_NEG;
	 break;
    case IZ:
	 bit_symbol = BIT_IZ;
	 break;
    case ZR:
	 bit_symbol = BIT_ZR;
	 break;
    default:
	 if (show_msg)
	    if (!message_printf (MB_INFO,"write_symbol",
	       "Attempt to write non-valid symbol: %d",symbol))
	       show_msg = 0;
         bit_symbol = BIT_IZ;
	 break;
	 }  // end switch
    switch (bit_count) {
    case 0:
	 symbol_bits.sym_1 = bit_symbol;
	 bit_count++;
	 break;
    case 1:
	 symbol_bits.sym_2 = bit_symbol;
	 bit_count++;
	 break;
    case 2:
	 symbol_bits.sym_3 = bit_symbol;
	 bit_count++;
	 break;
    case 3:
	 symbol_bits.sym_4 = bit_symbol;
	 fwrite (&symbol_bits,sizeof(symbol_bits),1,output_file);
	 bit_count = 0;
	 break;
	 }
    return;
    }

int twavelet_zerotree_window::zerotree_encoding (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;
    float max,threshold;
    int log_2_threshold;
    int int_value;
    int z_end_row,z_start_row,z_end_col,z_start_col;
    short symbol;

    if (!image_obj->s.rows) {
       if (!image_obj->allocate_image_struct
	       (rows,cols)) return 1;
       get_gray_image(image_obj);
       }

    FILE *output;

    char *filename = new char [MAX_IMG_FILENAME_LEN+1];
    filename[0] = '\0';

    if (!get_file_name_dlg (hwindow,"*.wvz",
      "Zerotree Wavelet File",filename,MAX_IMG_FILENAME_LEN,
      SAVE_DLG)) return 1;

    if (!open_output_binary_stream (&output,filename))
      return 0;

    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);
    start_time = time(NULL);
    wavelet_array->transform();
    end_time = time(NULL);
    wavelet_transform_time = end_time - start_time;
    message_puts (MB_INFO,"Zerotree Encoding","Transform complete.");
    decimation_time = 0;
    if (compression_percent > 0.0) {
       start_time = time(NULL);
       wavelet_array->decimate (compression_percent);
       end_time = time(NULL);
       decimation_time = end_time - start_time;
       message_puts (MB_INFO,"Zerotree Encoding","Decimation complete.");
       }

    compression_time = wavelet_transform_time + decimation_time;

    if (symbol_array) delete symbol_array;
    symbol_array = new tzerotree (rows,cols,0);

    if (!symbol_array->array) return 1;

    // Get max transform value:
    max = fabs(wavelet_array->transform_max);
    if (max < fabs(wavelet_array->transform_min))
       max = fabs(wavelet_array->transform_min);

    threshold = get_threshold (max,log_2_threshold);

    bit_plane_count = 0;
    bit_plane_total = log_2_threshold + 1;
    bit_count = 0;

    if (selected_max_bit_plane)