(************** Content-type: application/mathematica **************
                     CreatedBy='Mathematica 5.2'

                    Mathematica-Compatible Notebook

This notebook can be used with any Mathematica-compatible
application, such as Mathematica, MathReader or Publicon. The data
for the notebook starts with the line containing stars above.

To get the notebook into a Mathematica-compatible application, do
one of the following:

* Save the data starting with the line of stars above into a file
  with a name ending in .nb, then open the file inside the
  application;

* Copy the data starting with the line of stars above to the
  clipboard, then use the Paste menu command inside the application.

Data for notebooks contains only printable 7-bit ASCII and can be
sent directly in email or through ftp in text mode.  Newlines can be
CR, LF or CRLF (Unix, Macintosh or MS-DOS style).

NOTE: If you modify the data for this notebook not in a Mathematica-
compatible application, you must delete the line below containing
the word CacheID, otherwise Mathematica-compatible applications may
try to use invalid cache data.

For more information on notebooks and Mathematica-compatible 
applications, contact Wolfram Research:
  web: http://www.wolfram.com
  email: info@wolfram.com
  phone: +1-217-398-0700 (U.S.)

Notebook reader applications are available free of charge from 
Wolfram Research.
*******************************************************************)

(*CacheID: 232*)


(*NotebookFileLineBreakTest
NotebookFileLineBreakTest*)
(*NotebookOptionsPosition[     21554,        676]*)
(*NotebookOutlinePosition[     22340,        703]*)
(*  CellTagsIndexPosition[     22296,        699]*)
(*WindowFrame->Normal*)



Notebook[{

Cell[CellGroupData[{
Cell["Haar Transform 2D", "Title"],

Cell["\<\
Wavelet Workshop
June 6-9, 2007
University of St. Thomas\
\>", "Subtitle"],

Cell[CellGroupData[{

Cell["Objectives", "Section"],

Cell["\<\
The purpose of this notebook is to show you how to code and use the \
two-dimensional Discrete Haar Wavelet Transform.\
\>", "Text"]
}, Open  ]],

Cell[CellGroupData[{

Cell["DiscreteWavelets", "Section"],

Cell[TextData[{
  StyleBox["You should run this cell each time you open this notebook!!",
    FontColor->RGBColor[1, 0, 0]],
  "  It loads the ",
  StyleBox["Mathematica",
    FontSlant->"Italic"],
  " package ",
  StyleBox["DiscreteWavelets",
    FontFamily->"Courier"],
  " for use in subsequent computations."
}], "Text"],

Cell[BoxData[
    StyleBox[\(<< DiscreteWavelets`DiscreteWavelets`\),
      FontColor->GrayLevel[0.500008]]], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell["Help on DiscreteWavelets", "Section"],

Cell[TextData[{
  "If you ever need help with ",
  StyleBox["DiscreteWavelets",
    FontFamily->"Courier"],
  ", go to ",
  StyleBox["Help",
    FontSlant->"Italic"],
  ", then ",
  StyleBox["Help Browser",
    FontSlant->"Italic"],
  ", and click on ",
  StyleBox["AddOns & Links",
    FontSlant->"Italic"],
  ".  If you scroll down you will find ",
  StyleBox["DiscreteWavelets",
    FontFamily->"Courier"],
  ".  "
}], "Text"]
}, Open  ]],

Cell[CellGroupData[{

Cell["Computing the 2D HWT", "Section"],

Cell[TextData[{
  "The package DiscreteWavelets comes with a routine for computing one \
iteration of the two-dimensional Haar wavelet transform.  It is called ",
  StyleBox["HWT2D1",
    FontWeight->"Bold"],
  ".    Here is an example of how to use it."
}], "Text"],

Cell[BoxData[{
    RowBox[{
      RowBox[{"gray", "=", 
        RowBox[{
          StyleBox["ImageNames",
            FontColor->GrayLevel[0.500008]], 
          "[", \(ImageType \[Rule] GrayScale, ListThumbnails \[Rule] True\), 
          "]"}]}], ";"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{"A", "=", 
        RowBox[{
          StyleBox["ImageRead",
            FontColor->GrayLevel[0.500008]], "[", \(gray[\([6]\)]\), "]"}]}], 
      ";"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        StyleBox["ImagePlot",
          FontColor->GrayLevel[0.500008]], "[", \(A, 
        PlotLabel -> "\<Image\>"\), "]"}], ";"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{"wt", "=", 
        RowBox[{
          StyleBox["HWT2D1",
            FontColor->GrayLevel[0.500008]], "[", "A", "]"}]}], 
      ";"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        StyleBox["WaveletDensityPlot",
          FontColor->GrayLevel[0.500008]], "[", \(wt, 
        NumIterations \[Rule] 1, PlotLabel -> "\<HWT\>"\), "]"}], 
      ";"}]}], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell["Coding HWT2D1", "Section"],

Cell[TextData[{
  "To compute this transform, we first compute B = ",
  Cell[BoxData[
      \(W\_N\)]],
  "A.  A module exists for performing this computation.  It is called ",
  StyleBox["LeftHWT",
    FontWeight->"Bold"],
  ".  The directive ",
  StyleBox["LinearScaling",
    FontWeight->"Bold"],
  " in ",
  StyleBox["ImagePlot",
    FontWeight->"Bold"],
  " can be set to ",
  StyleBox["LeftWT",
    FontWeight->"Bold"],
  " to better illustrate the result of this computation."
}], "Text"],

Cell[BoxData[{
    RowBox[{
      RowBox[{"B", "=", 
        RowBox[{
          StyleBox["LeftHWT",
            FontColor->GrayLevel[0.500008]], "[", "A", "]"}]}], 
      ";"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        StyleBox["ImagePlot",
          FontColor->GrayLevel[0.500008]], "[", \(B, 
        LinearScaling \[Rule] LeftWT\), "]"}], ";"}]}], "Input"],

Cell[TextData[{
  "Recall the 2D transform is U = ",
  Cell[BoxData[
      \(W\_N\)]],
  " A ",
  Cell[BoxData[
      \(W\_M\%T\)]],
  " = B",
  Cell[BoxData[
      \(W\_M\%T\)]],
  ".  To compute U = B",
  Cell[BoxData[
      \(W\_M\%T\)]],
  ", we first transpose this identity to write ",
  Cell[BoxData[
      \(U\^T\)]],
  "= ",
  Cell[BoxData[
      \(W\_M\)]],
  Cell[BoxData[
      \(\(\(B\^T\)\(.\)\)\)]],
  "  We can call ",
  StyleBox["LeftHWT",
    FontWeight->"Bold"],
  " again and then simply transpose the result.\n\nSo to code ",
  StyleBox["HWT2D1",
    FontWeight->"Bold"],
  ", you must first write a module that performs ",
  StyleBox["LeftHWT",
    FontWeight->"Bold"],
  ".  Then ",
  StyleBox["HWT2D1",
    FontWeight->"Bold"],
  " calls ",
  StyleBox["LeftHWT",
    FontWeight->"Bold"],
  " twice to produce the 2D transform.\n\nIn the cell below, write a module \
called ",
  StyleBox["sLeftHWT",
    FontWeight->"Bold"],
  " that computes ",
  StyleBox["LeftHWT",
    FontWeight->"Bold"],
  ".  The easiest way to do this is to copy and paste your module ",
  StyleBox["sHWT1D1",
    FontWeight->"Bold"],
  " into the cell below and then call it for each column of the input matrix \
A.  Remember though that the computation ",
  StyleBox["sHWT1D1",
    FontWeight->"Bold"],
  "[ A[[1]] ] applies the wavelet matrix to the first ",
  StyleBox["row",
    FontSlant->"Italic"],
  " of A - ",
  StyleBox["Mathematica",
    FontSlant->"Italic"],
  " is a row-oriented language!!  You will probably want to use a For loop to \
apply sHWT1D1 to each column of A.  That is a bit slow - look at the ",
  StyleBox["Map",
    FontWeight->"Bold"],
  " command in Help to accelerate this computation."
}], "Text"],

Cell[BoxData[
    \(\(\( (*\ 
      Replace\ this\ comment\ with\ your\ module\ sHWT1D1\ *) \)\(\
\[IndentingNewLine]\)\(\[IndentingNewLine]\)\(sLeftHWT[a_] := 
        Module[\({\  (*\ 
              Replace\ this\ comment\ with\ local\ variables\ *) }\)\(,\)\
\[IndentingNewLine]\[IndentingNewLine] (*\ 
            Put\ your\ code\ \(\(here\)\(.\)\)\ *) \[IndentingNewLine]\
\[IndentingNewLine]];\)\)\)], "Input"],

Cell["Use the cell below to check your code.", "Text"],

Cell[BoxData[{\(B = sLeftHWT[A];\), "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        StyleBox["ImagePlot",
          FontColor->GrayLevel[0.500008]], "[", \(B, 
        LinearScaling \[Rule] LeftWT\), "]"}], ";"}]}], "Input"],

Cell["\<\
Now that you have the routine sLeftHWT, use it twice to compute the 2D Haar \
wavelet transform of an input matrix.  Write your code in the cell below.\
\>", "Text"],

Cell[BoxData[
    \(\(sHWT2D1[a_] := 
        Module[\({\  (*\ 
              Replace\ this\ comment\ with\ local\ variables\ *) \ }\)\(,\)\
\[IndentingNewLine]\t\[IndentingNewLine] (*\ 
            Put\ your\ code\ here\ *) \[IndentingNewLine]];\)\)], "Input"],

Cell["You can use this module to check your code.", "Text"],

Cell[BoxData[{\(wt = sHWT2D1[A];\), "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        StyleBox["WaveletDensityPlot",
          FontColor->GrayLevel[0.500008]], "[", \(wt, 
        NumIterations \[Rule] 1\), "]"}], ";"}]}], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell["Features of WaveletDensityPlot", "Section"],

Cell[TextData[{
  "One of the nice options with ",
  StyleBox["WaveletDensityPlot ",
    FontWeight->"Bold"],
  "is you can pick out various parts of the transform.  For example,"
}], "Text"],

Cell[BoxData[{
    RowBox[{
      RowBox[{"gray", " ", "=", " ", 
        RowBox[{
          StyleBox["ImageNames",
            FontColor->GrayLevel[0.500008]], 
          "[", \(ImageType \[Rule] GrayScale\), "]"}]}], 
      ";"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{"A", "=", 
        RowBox[{
          StyleBox["ImageRead",
            FontColor->GrayLevel[0.500008]], "[", \(gray[\([5]\)]\), "]"}]}], 
      ";"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{"wt", "=", 
        RowBox[{
          StyleBox["HWT2D1",
            FontColor->GrayLevel[0.500008]], "[", \(N[A]\), "]"}]}], 
      ";"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        StyleBox["WaveletDensityPlot",
          FontColor->GrayLevel[0.500008]], "[", \(wt, 
        NumIterations \[Rule] 1\), "]"}], ";"}]}], "Input"],

Cell[BoxData[{
    RowBox[{
      RowBox[{
        StyleBox["WaveletDensityPlot",
          FontColor->GrayLevel[0.500008]], "[", \(wt, 
        NumIterations \[Rule] 1, Region \[Rule] Vertical\), "]"}], 
      ";"}], "\[IndentingNewLine]", \(Dimensions[wt]\)}], "Input"],

Cell[BoxData[
    RowBox[{
      RowBox[{
        StyleBox["WaveletDensityPlot",
          FontColor->GrayLevel[0.500008]], "[", \(wt, 
        NumIterations \[Rule] 1, Region \[Rule] Vertical, 
        ImageSize \[Rule] Dimensions[wt]\), "]"}], ";"}]], "Input"],

Cell[BoxData[
    RowBox[{
      RowBox[{
        StyleBox["WaveletDensityPlot",
          FontColor->GrayLevel[0.500008]], "[", \(wt, 
        NumIterations \[Rule] 1, Region \[Rule] Blur, 
        ImageSize \[Rule] Dimensions[wt]\), "]"}], ";"}]], "Input"],

Cell[BoxData[
    RowBox[{
      RowBox[{
        StyleBox["WaveletDensityPlot",
          FontColor->GrayLevel[0.500008]], "[", \(wt, 
        NumIterations \[Rule] 1, Region \[Rule] Horizontal, 
        ImageSize \[Rule] Dimensions[wt]\), "]"}], ";"}]], "Input"],

Cell[BoxData[
    RowBox[{
      RowBox[{
        StyleBox["WaveletDensityPlot",
          FontColor->GrayLevel[0.500008]], "[", \(wt, 
        NumIterations \[Rule] 1, Region \[Rule] Diagonal, 
        ImageSize \[Rule] Dimensions[wt]\), "]"}], ";"}]], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell["The Inverse 2D Haar Wavelet Transform", "Section"],

Cell[TextData[{
  "For the inverse 2D Haar wavelet transform, we must compute A = ",
  Cell[BoxData[
      \(W\_N\%T\)]],
  "U ",
  Cell[BoxData[
      \(W\_M\)]],
  ".  The first step is to compute ",
  Cell[BoxData[
      \(W\_N\%T\)]],
  " U.  There is a routine in DiscreteWavelets that performs this task.  It \
is called ",
  StyleBox["LeftIHWT",
    FontWeight->"Bold"],
  ".  As you might guess it simply applies IHWT1D1 to each column of U.\n\nIn \
the cell below, write a routine that computes LeftIHWT.  You will want to \
copy and paste your module sIHWT1D1 into the cell below."
}], "Text"],

Cell[BoxData[
    \(\(\( (*\ 
      Replace\ this\ comment\ with\ your\ module\ sIHWT1D1\ *) \)\(\
\[IndentingNewLine]\)\(\[IndentingNewLine]\)\(sLeftIHWT[a_] := 
        Module[\({\  (*\ 
              Replace\ this\ comment\ with\ local\ variables\ *) }\)\(,\)\
\[IndentingNewLine]\[IndentingNewLine] (*\ 
            Put\ your\ code\ \(\(here\)\(.\)\)\ *) \[IndentingNewLine]\
\[IndentingNewLine]];\)\)\)], "Input"],

Cell["\<\
Now that you have the module sLeftIHWT, use it to write a module to compute \
the inverse 2D Haar wavelet transform.  You will use the same \"transpose \
trick\" that you used for sHWT2D1.\
\>", "Text"],

Cell[BoxData[
    \(\(sIHWT2D1[a_] := 
        Module[\({\  (*\ 
              Replace\ this\ comment\ with\ local\ variables\ *) \ }\)\(,\)\
\[IndentingNewLine]\t\[IndentingNewLine] (*\ 
            Put\ your\ code\ here\ *) \[IndentingNewLine]];\)\)], "Input"],

Cell["Use the cell below to check your work.", "Text"],

Cell[BoxData[{
    RowBox[{
      RowBox[{"gray", "=", 
        RowBox[{
          StyleBox["ImageNames",
            FontColor->GrayLevel[0.500008]], 
          "[", \(ImageType \[Rule] GrayScale, ListThumbnails \[Rule] True\), 
          "]"}]}], ";"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{"A", "=", 
        RowBox[{
          StyleBox["ImageRead",
            FontColor->GrayLevel[0.500008]], "[", \(gray[\([12]\)]\), "]"}]}],
       ";"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        StyleBox["ImagePlot",
          FontColor->GrayLevel[0.500008]], "[", "B", "]"}], 
      ";"}], "\[IndentingNewLine]", \(wt = 
        sHWT2D1[N[A]];\), "\[IndentingNewLine]", \(B = 
        sIHWT2D1[wt];\), "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        StyleBox["ImagePlot",
          FontColor->GrayLevel[0.500008]], "[", "B", "]"}], ";"}]}], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell["Extra Credit - Iterating the Transform", "Section"],

Cell[TextData[{
  "It is straightforward  to iterate the wavelet transform.    The command in \
",
  StyleBox["DiscreteWavelets",
    FontFamily->"Courier"],
  " is ",
  StyleBox["HWT2D",
    FontWeight->"Bold"],
  ".  You can set the NumIterations directive to i where ",
  Cell[BoxData[
      \(2\^i\)]],
  "divides the dimensions of the input matrix.  Here is an example:"
}], "Text"],

Cell[BoxData[{
    RowBox[{
      RowBox[{"gray", "=", 
        RowBox[{
          StyleBox["ImageNames",
            FontColor->GrayLevel[0.500008]], 
          "[", \(ImageType \[Rule] GrayScale, ListThumbnails \[Rule] True\), 
          "]"}]}], ";"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{"A", "=", 
        RowBox[{
          StyleBox["ImageRead",
            FontColor->GrayLevel[0.500008]], "[", \(gray[\([17]\)]\), "]"}]}],
       ";"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        StyleBox["ImagePlot",
          FontColor->GrayLevel[0.500008]], "[", "A", "]"}], 
      ";"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{"wt", "=", 
        RowBox[{
          StyleBox["HWT2D",
            FontColor->GrayLevel[0.500008]], "[", \(N[A], 
          NumIterations \[Rule] 2\), "]"}]}], ";"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        StyleBox["WaveletDensityPlot",
          FontColor->GrayLevel[0.500008]], "[", \(wt, 
        NumIterations \[Rule] 2\), "]"}], ";"}]}], "Input"],

Cell[TextData[{
  "\n\nThe inverse routine works exactly the same.  It is called ",
  StyleBox["IHWT2D",
    FontWeight->"Bold"],
  ".  Here is an example:"
}], "Text"],

Cell[BoxData[{\(iwt\  = \ 
        IHWT2D[wt, NumIterations \[Rule] 2];\), "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        StyleBox["ImagePlot",
          FontColor->GrayLevel[0.500008]], "[", "iwt", "]"}], ";"}]}], "Input"],

Cell["\<\
In the cell below, write a module that computes the iterated two-dimensional \
HWT.  To assist you, look at Algorithm 6.9 on page 195 of the text.  The \
commands for Extract and Insert exist in DiscreteWavelets - they are called \
GetCorner and PutCorner, respectively.  Consult help for how to use them.  As \
was the case for HWT1D, you need to make a copy of the input matrix.\
\>", "Text"],

Cell[BoxData[
    \(\(\( (*\ 
      Replace\ this\ comment\ with\ your\ module\ sHWT1D1\ *) \)\(\
\[IndentingNewLine]\)\(\[IndentingNewLine]\)\(sHWT2D[a_, opts___] := 
        Module[{i, \ 
            c (*\ Replace\ this\ comment\ with\ local\ variables\ *) }, \
\[IndentingNewLine]\[IndentingNewLine]c = 
            a; \[IndentingNewLine]i = \(NumIterations /. {opts}\) /. 
              Options[HWT2D]; \[IndentingNewLine]\[IndentingNewLine] (*\ 
            Put\ your\ code\ \(\(here\)\(.\)\)\ *) \[IndentingNewLine]\
\[IndentingNewLine]];\)\)\)], "Input"],

Cell["Here is some code to check your work.", "Text"],

Cell[BoxData[{
    RowBox[{
      RowBox[{"gray", "=", 
        RowBox[{
          StyleBox["ImageNames",
            FontColor->GrayLevel[0.500008]], 
          "[", \(ImageType \[Rule] GrayScale, ListThumbnails \[Rule] True\), 
          "]"}]}], ";"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{"A", "=", 
        RowBox[{
          StyleBox["ImageRead",
            FontColor->GrayLevel[0.500008]], "[", \(gray[\([17]\)]\), "]"}]}],
       ";"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        StyleBox["ImagePlot",
          FontColor->GrayLevel[0.500008]], "[", "A", "]"}], 
      ";"}], "\[IndentingNewLine]", \(wt = 
        sHWT2D[N[A], NumIterations \[Rule] 2];\), "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        StyleBox["WaveletDensityPlot",
          FontColor->GrayLevel[0.500008]], "[", \(wt, 
        NumIterations \[Rule] 2\), "]"}], ";"}]}], "Input"],

Cell["\<\
In the cell below, write a routine to compute the iterated inverse \
two-dimensional HWT.  Algorithm 6.10 on page 195 will help you.\
\>", "Text"],

Cell[BoxData[
    \(\(\( (*\ 
      Replace\ this\ comment\ with\ your\ module\ sHWT1D1\ *) \)\(\
\[IndentingNewLine]\)\(\[IndentingNewLine]\)\(sIHWT2D[c_, opts___] := 
        Module[{i, \ 
            a (*\ Replace\ this\ comment\ with\ local\ variables\ *) }, \
\[IndentingNewLine]\[IndentingNewLine]a = 
            c; \[IndentingNewLine]i = \(NumIterations /. {opts}\) /. 
              Options[HWT2D]; \[IndentingNewLine]\[IndentingNewLine] (*\ 
            Put\ your\ code\ \(\(here\)\(.\)\)\ *) \[IndentingNewLine]\
\[IndentingNewLine]];\)\)\)], "Input"],

Cell["Here is some code to check your work:", "Text"],

Cell[BoxData[{
    RowBox[{
      RowBox[{"gray", "=", 
        RowBox[{
          StyleBox["ImageNames",
            FontColor->GrayLevel[0.500008]], 
          "[", \(ImageType \[Rule] GrayScale, ListThumbnails \[Rule] True\), 
          "]"}]}], ";"}], "\n", 
    RowBox[{
      RowBox[{"A", "=", 
        RowBox[{
          StyleBox["ImageRead",
            FontColor->GrayLevel[0.500008]], "[", \(gray[\([\)\(17\)\(]\)]\), 
          "]"}]}], ";"}], "\n", 
    RowBox[{
      RowBox[{
        StyleBox["ImagePlot",
          FontColor->GrayLevel[0.500008]], "[", "A", "]"}], 
      ";"}], "\n", \(wt = 
        sHWT2D[N[A], NumIterations \[Rule] 2];\), "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        StyleBox["WaveletDensityPlot",
          FontColor->GrayLevel[0.500008]], "[", \(wt, 
        NumIterations \[Rule] 2\), "]"}], 
      ";"}], "\[IndentingNewLine]", \(iwt = 
        sIHWT2D[wt, NumIterations \[Rule] 2];\), "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        StyleBox["ImagePlot",
          FontColor->GrayLevel[0.500008]], "[", "iwt", "]"}], ";"}]}], "Input"]
}, Open  ]],

Cell[CellGroupData[{

Cell["Progressive Inversion", "Section"],

Cell["Here is a fun one to see how images are often reconstructed", "Text"],

Cell[BoxData[{
    RowBox[{
      RowBox[{"gray", "=", 
        RowBox[{
          StyleBox["ImageNames",
            FontColor->GrayLevel[0.500008]], 
          "[", \(ImageType \[Rule] GrayScale\), "]"}]}], 
      ";"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{"A", "=", 
        RowBox[{
          StyleBox["ImageRead",
            FontColor->GrayLevel[0.500008]], "[", \(gray[\([6]\)]\), "]"}]}], 
      ";"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        RowBox[{"WT", "=", 
          RowBox[{"Table", "[", 
            RowBox[{
              RowBox[{
                StyleBox["HWT2D",
                  FontColor->GrayLevel[0.500008]], "[", \(N[A], 
                NumIterations \[Rule] k\), "]"}], ",", \({k, 1, 4}\)}], 
            "]"}]}], ";"}], 
      "\[IndentingNewLine]"}], "\[IndentingNewLine]", \(plts = 
        Table[{}, {k, 1, 5}];\), "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        RowBox[{\(plts[\([1]\)]\), "=", 
          RowBox[{
            StyleBox["ImagePlot",
              FontColor->GrayLevel[0.500008]], "[", \(A, 
            ImageSize \[Rule] Dimensions[A]\), "]"}]}], ";"}], 
      "\[IndentingNewLine]"}], "\[IndentingNewLine]", 
    RowBox[{
      RowBox[{
        RowBox[{"plts", "=", 
          RowBox[{"Table", "[", 
            RowBox[{
              RowBox[{
                StyleBox["WaveletDensityPlot",
                  FontColor->GrayLevel[0.500008]], "[", \(WT[\([k - 1]\)], 
                NumIterations \[Rule] k - 1, Region \[Rule] Blur, 
                ImageSize \[Rule] Dimensions[A]\), "]"}], 
              ",", \({k, 2, 5}\)}], "]"}]}], ";"}], "\[IndentingNewLine]", 
      "\[IndentingNewLine]", \( (*\ 
        Double\ click\ any\ picture\ below\ to\ animate\  - \ 
          controls\ at\ the\ bottom\ left\ will\ appear\ that\ allow\ you\ to\
\ control\ the\ speed\ of\ the\ animation\ *) \)}], "\[IndentingNewLine]", \
}], "Input"]
}, Open  ]]
}, Open  ]]
},
FrontEndVersion->"5.2 for Microsoft Windows",
ScreenRectangle->{{0, 1024}, {0, 685}},
AutoGeneratedPackage->None,
ScreenStyleEnvironment->"Presentation",
WindowSize->{1016, 651},
WindowMargins->{{4, Automatic}, {Automatic, -18}},
ShowSelection->True,
Magnification->1,
StyleDefinitions -> "Report.nb"
]

(*******************************************************************
Cached data follows.  If you edit this Notebook file directly, not
using Mathematica, you must remove the line containing CacheID at
the top of  the file.  The cache data will then be recreated when
you save this file from within Mathematica.
*******************************************************************)

(*CellTagsOutline
CellTagsIndex->{}
*)

(*CellTagsIndex
CellTagsIndex->{}
*)

(*NotebookFileOutline
Notebook[{

Cell[CellGroupData[{
Cell[1776, 53, 34, 0, 120, "Title"],
Cell[1813, 55, 84, 4, 146, "Subtitle"],

Cell[CellGroupData[{
Cell[1922, 63, 29, 0, 98, "Section"],
Cell[1954, 65, 142, 3, 46, "Text"]
}, Open  ]],

Cell[CellGroupData[{
Cell[2133, 73, 35, 0, 98, "Section"],
Cell[2171, 75, 324, 10, 48, "Text"],
Cell[2498, 87, 118, 2, 54, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[2653, 94, 43, 0, 98, "Section"],
Cell[2699, 96, 429, 17, 48, "Text"]
}, Open  ]],

Cell[CellGroupData[{
Cell[3165, 118, 39, 0, 98, "Section"],
Cell[3207, 120, 266, 6, 46, "Text"],
Cell[3476, 128, 1068, 30, 174, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[4581, 163, 32, 0, 98, "Section"],
Cell[4616, 165, 495, 17, 46, "Text"],
Cell[5114, 184, 378, 11, 84, "Input"],
Cell[5495, 197, 1728, 61, 214, "Text"],
Cell[7226, 260, 416, 8, 234, "Input"],
Cell[7645, 270, 54, 0, 46, "Text"],
Cell[7702, 272, 236, 5, 84, "Input"],
Cell[7941, 279, 175, 3, 46, "Text"],
Cell[8119, 284, 261, 5, 144, "Input"],
Cell[8383, 291, 59, 0, 46, "Text"],
Cell[8445, 293, 241, 5, 84, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[8723, 303, 49, 0, 98, "Section"],
Cell[8775, 305, 191, 5, 46, "Text"],
Cell[8969, 312, 833, 24, 144, "Input"],
Cell[9805, 338, 271, 6, 84, "Input"],
Cell[10079, 346, 262, 6, 54, "Input"],
Cell[10344, 354, 258, 6, 54, "Input"],
Cell[10605, 362, 264, 6, 54, "Input"],
Cell[10872, 370, 262, 6, 54, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[11171, 381, 56, 0, 98, "Section"],
Cell[11230, 383, 603, 17, 130, "Text"],
Cell[11836, 402, 418, 8, 234, "Input"],
Cell[12257, 412, 212, 4, 46, "Text"],
Cell[12472, 418, 262, 5, 144, "Input"],
Cell[12737, 425, 54, 0, 46, "Text"],
Cell[12794, 427, 887, 24, 204, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[13718, 456, 57, 0, 98, "Section"],
Cell[13778, 458, 387, 12, 63, "Text"],
Cell[14168, 472, 1041, 29, 155, "Input"],
Cell[15212, 503, 168, 5, 84, "Text"],
Cell[15383, 510, 236, 5, 77, "Input"],
Cell[15622, 517, 404, 6, 106, "Text"],
Cell[16029, 525, 561, 10, 311, "Input"],
Cell[16593, 537, 53, 0, 40, "Text"],
Cell[16649, 539, 902, 24, 155, "Input"],
Cell[17554, 565, 156, 3, 62, "Text"],
Cell[17713, 570, 562, 10, 311, "Input"],
Cell[18278, 582, 53, 0, 40, "Text"],
Cell[18334, 584, 1102, 30, 207, "Input"]
}, Open  ]],

Cell[CellGroupData[{
Cell[19473, 619, 40, 0, 96, "Section"],
Cell[19516, 621, 75, 0, 40, "Text"],
Cell[19594, 623, 1932, 49, 389, "Input"]
}, Open  ]]
}, Open  ]]
}
]
*)



(*******************************************************************
End of Mathematica Notebook file.
*******************************************************************)