wavdzwin.cpp

wavlet compression on c++ only cods

// Copyright (c) 1999 Stephen T. Welstead. All rights reserved.
// File WAVDZWIN.CPP  Wavelet zerotree decoding 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 "wavdzwin.h"

tdecode_zerotree_window_manager *the_decode_zerotree_window_manager;

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

tdecode_zerotree_window_manager::tdecode_zerotree_window_manager
    (HINSTANCE hInstance,tmdi_frame_window *parent, LPCSTR menu_name,
     LPCSTR class_name):
    tmdi_manager (hInstance,parent,(LRESULT CALLBACK)DecodeZWndProc,
	0,menu_name,"Decode Zerotree Window",class_name,"WAV_ICON"){ }

void tdecode_zerotree_window_manager::set_global_ptr (void) {
    the_decode_zerotree_window_manager = this;}

int tdecode_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,"*.wvz",
      "Wavelet Zerotree 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 tdecode_zerotree_window(hwnd,this,file_name);
    add_child_window (hwnd,child);
    return 1;
    }

tdecode_zerotree_window::tdecode_zerotree_window(HWND hwnd,
     tmdi_manager *the_manager,LPSTR the_decode_filename)
     : twavelet_window(hwnd,the_manager,0)
{
   decode_filename = the_decode_filename;
   symbol_array = 0;
   show_progressive_decoding = 0;
   bit_count = 0;
   bit_plane_count = 0;
   bit_plane_total = 0;
}

int tdecode_zerotree_window::respond_wm_create(HWND hwnd) {
    timg_window::respond_wm_create(hwnd);
    strcpy ((char *)the_title,decode_filename);
    SetWindowText (hwnd,the_title);
    return 1;
    }

int tdecode_zerotree_window::get_wavelet_compressed_image ()
    {
    int rows;
    float lowpass_value;
    int log_2_threshold;
    HCURSOR save_cursor,hour_glass_cursor;
    FILE *input;

    if (!open_input_binary_stream (&input,decode_filename))
      return 1;

    fread (&(wavelet_type),sizeof(wavelet_type),1,input);
    fread (&(rows),sizeof(rows),1,input);
    fread (&(lowpass_value),sizeof(lowpass_value),1,input);
    fread (&(log_2_threshold),sizeof(log_2_threshold),1,input);
    fread (&(bit_plane_total),sizeof(bit_plane_total),1,input);

    if (!message_printf (MB_INFO,"Zerotree Decoding",
       "Wavelet Type: %d\r\n"
       "Rows: %d\r\n"
       "Lowpass Value: %8.4f\r\n"
       "Max Bit Plane: %d\r\n"
       "Bit Plane Total: %d\r\n",
       wavelet_type,rows,lowpass_value,log_2_threshold+1,
       bit_plane_total))
       return 1;

    hour_glass_cursor = LoadCursor(NULL,IDC_WAIT);
    save_cursor = SetCursor (hour_glass_cursor);

    switch (wavelet_type) {
    case 1:
	 Daub4_wavelet = new tDaub4_wavelet();
	 zerotree_decoding (input,Daub4_wavelet,rows,lowpass_value,
		log_2_threshold);
	 delete Daub4_wavelet;
	 break;
    case 2:
	 Daub6_wavelet = new tDaub6_wavelet();
	 zerotree_decoding (input,Daub6_wavelet,rows,lowpass_value,
		log_2_threshold);
	 delete Daub6_wavelet;
	 break;
    default:
	 Haar_wavelet = new tHaar_wavelet();
	 zerotree_decoding (input,Haar_wavelet,rows,lowpass_value,
		log_2_threshold);
	 delete Haar_wavelet;
	 }  //
    fclose (input);

    SetCursor (save_cursor);
    SetWindowText (hwindow,decode_filename);

    return 1;
    }

float pos_power_of_2 (int n) {
    // Valid only for n >= 0!
    float p = 1.0;
    if (n <=0) return p;
    for (int i=1;i<=n;i++)
       p *= 2.0;
    return p;
    }

void tdecode_zerotree_window::read_symbol (short *symbol,FILE *input_file) {
    short bit_symbol;
    switch (bit_count) {
    case 0:
	 fread (&symbol_bits,sizeof(symbol_bits),1,input_file);
	 bit_symbol = symbol_bits.sym_1;
	 bit_count++;
	 break;
    case 1:
	 bit_symbol = symbol_bits.sym_2;
	 bit_count++;
	 break;
    case 2:
	 bit_symbol = symbol_bits.sym_3;
	 bit_count++;
	 break;
    case 3:
	 bit_symbol = symbol_bits.sym_4;
	 bit_count = 0;
	 break;
	 }
    switch (bit_symbol) {
    case BIT_POS:
	 *symbol = POS;
	 break;
    case BIT_NEG:
	 *symbol = NEG;
	 break;
    case BIT_IZ:
	 *symbol = IZ;
	 break;
    case BIT_ZR:
	 *symbol = ZR;
	 break;
	 }  // end switch
    return;
    }

int tdecode_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_progressive_decoding) {
	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);
        }

    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 tdecode_zerotree_window::zerotree_decoding (FILE *input,twavelet *wavelet,
	  int rows,float lowpass_value,int log_2_threshold) {
    float **values = 0,**w_values = 0;
    int cols = rows,i,j;
    float threshold;
    int int_value;
    int z_end_row,z_start_row,z_end_col,z_start_col;
    short symbol;

    threshold = pos_power_of_2 (log_2_threshold);

    if (!(values = matrix2d (1,rows,1,cols))) return 1;
    init_2d_matrix (values,rows,cols,0.0);

    // Need a separate array to hold wavelet values.
    if (!(w_values = matrix2d (1,rows,1,cols))) return 1;
    init_2d_matrix (w_values,rows,cols,0.0);

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

    if (!symbol_array->array) return 1;

    if (wavelet_image->s.rows)
       wavelet_image->delete_image_struct ();

    if (!wavelet_image->allocate_image_struct
	   (rows,cols)) return 1;

    twavelet_2d_array *wavelet_array = new twavelet_2d_array (w_values,
	wavelet,rows,cols);

    bit_count = 0;
    bit_plane_count = 0;

    while (threshold >= 1) {
    symbol_array->init(0);

    bit_plane_count++;

    // Check LH band from the top down:
    z_end_row = 1;
    z_start_row = 1;
    z_end_col = 2;
    z_start_col = 2;

    while ((z_end_row<=rows)&&(z_end_col<=cols)) {
	for (i=z_start_row;i<=z_end_row;i++)
	    for (j=z_start_col;j<=z_end_col;j++) {
		if (!symbol_array->get(i,j)) {
		   read_symbol (&symbol,input);
		   symbol_array->set(i,j,symbol);
		   if (symbol == ZR)
		      // Mark children as zerotree children:
		      symbol_array->mark_children (i,j,rows,cols,ZT);
		   }
		}  // end i,j
	z_end_row *= 2;
	z_start_row = 1;
	z_start_col = z_end_col+1;
	z_end_col *= 2;
	}  // end while

    // Check HH band from the top down:
    z_end_row = 2;
    z_start_row = 2;
    z_end_col = 2;
    z_start_col = 2;

    while ((z_end_row<=rows)&&(z_end_col<=cols)) {
	for (i=z_start_row;i<=z_end_row;i++)
	    for (j=z_start_col;j<=z_end_col;j++) {
		if (!symbol_array->get(i,j)) {
		   read_symbol (&symbol,input);
		   symbol_array->set(i,j,symbol);
		   if (symbol == ZR)
		      // Mark children as zerotree children:
		      symbol_array->mark_children (i,j,rows,cols,ZT);
		   }
		}  // end i,j
	z_start_row = z_end_row + 1;
	z_end_row *= 2;
	z_start_col = z_end_col + 1;
	z_end_col *= 2;
	}  // end while

    // Check HL band from the top down:
    z_end_row = 2;
    z_start_row = 2;
    z_end_col = 1;
    z_start_col = 1;

    while ((z_end_row<=rows)&&(z_end_col<=cols)) {
	for (i=z_start_row;i<=z_end_row;i++)
	    for (j=z_start_col;j<=z_end_col;j++) {
		if (!symbol_array->get(i,j)) {
		   read_symbol (&symbol,input);
		   symbol_array->set(i,j,symbol);
		   if (symbol == ZR)
		      // Mark children as zerotree children:
		      symbol_array->mark_children (i,j,rows,cols,ZT);
		   }
		} // end i,j
	z_start_row = z_end_row + 1;
	z_end_row *= 2;
	z_start_col = 1;
	z_end_col *= 2;
	}  // end while

    // Now build up values array using threshold value:
    for (i=1;i<=rows;i++)
	for (j=1;j<=cols;j++) {
	    if (symbol_array->get(i,j) == POS)
	       values[i][j] += threshold;
	    if (symbol_array->get(i,j) == NEG)
	       values[i][j] -= threshold;
	    wavelet_array->values[i][j] =  values[i][j];
	    }  // end i,j

    wavelet_array->values[1][1] = lowpass_value;

    if ((show_progressive_decoding)||(bit_plane_count >= bit_plane_total)) {
       wavelet_array->inverse_transform();

       for (i=1;i<=rows;i++)
	   for (j=1;j<=cols;j++) {
	       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] = int_value;
		}

       display_image = wavelet_image;
       show_gray_image(wavelet_image);

       }  // end if

    threshold /= 2;

    if (bit_plane_count >= bit_plane_total) break;

    }  // end while

    delete wavelet_array;
    free_matrix2d (values,1,rows,1);
    free_matrix2d (w_values,1,rows,1);

    return 1;
    }

int tdecode_zerotree_window::respond_wm_paint () {
    return timg_window::respond_wm_paint();
   }

int tdecode_zerotree_window::respond_wm_command (WPARAM wParam,
    LPARAM) {
    switch (wParam)
       {
       case WAV_PROGRESSIVE_DEC:
	    show_progressive_decoding = !show_progressive_decoding;
	    CheckMenuItem (manager->window_menu, WAV_PROGRESSIVE_DEC,
		   show_progressive_decoding ? MF_CHECKED : MF_UNCHECKED);
	    break;
       }  // end switch
    return twavelet_window::respond_wm_command (wParam,0L);
    }

int tdecode_zerotree_window::respond_wm_mdiactivate (HWND hwnd,
		 WPARAM wParam,LPARAM lParam) {
    if ACTIVATE_MDI_CHILD_WINDOW(hwnd,wParam,lParam)
          SendMessage (manager->hwndClient, WM_MDISETMENU,
	  MDI_SETMENU_MSGPARAMS(manager->window_menu,
	  manager->window_submenu)) ;

    // check or uncheck menu items

    CheckMenuItem (manager->window_menu, WAV_PROGRESSIVE_DEC,
	 show_progressive_decoding ? MF_CHECKED : MF_UNCHECKED) ;

    // Set the Init menu if losing focus
    if (!ACTIVATE_MDI_CHILD_WINDOW(hwnd,wParam,lParam))
          SendMessage (manager->hwndClient, WM_MDISETMENU,
	  MDI_SETMENU_MSGPARAMS(manager->frame_menu,
	  manager->frame_submenu)) ;

    DrawMenuBar (manager->hwndFrame) ;
    return 1 ;
    }


int tdecode_zerotree_window::respond_wm_destroy (HWND hwnd) {
    if (decode_filename) delete [] decode_filename;
    if (symbol_array) delete symbol_array;
    twavelet_window::respond_wm_destroy (hwnd);
    return 1;
    }