Embed Size (px)
Citation preview
Wavelet Image Compression on the DSPEE113D Final Project, Spring 2007
Csaba Petre and Vineet Varma
Introduction and Theory:
The objective of our project was to perform the discrete Haar wavelet transformation on an image for the purpose of compression. The Haar wavelet transformation is composed of a sequence of low-pass and high-pass filters, known as a filter bank. These filter sequences can be applied in the same way as a discrete FIR filter in the DSP, using the MACP command, except as multiple successive FIR filters. The low pass filter performs an averaging/blurring operation, and is expressed as:
and the high-pass filter performs a differencing operation and can be expressed as:
on any adjacent pixel pair. The complete wavelet transform can be represented in matrix format by:
where A is the matrix representing the 2D image pixels, T is the Haar wavelet transformation of the image, and
in the case of transforming a 4x4 pixel image. The equivalent matrix can be expanded
TN NT W AW
First half: Applying 1D Transformation to Rows of Image
Second half: Applying 1D Transformation to Columns of Image
for larger images. This transformation can be represented by an FIR filter approach for use with the DSP’s MACP operation. We will discuss this in more detail later.
The result of the complete transformation, T, is composed of 4 new sub-images, which correspond to the blurred image, and the vertical, diagonal, and horizontal differences between the original image and the blurred image. The blurred representation of the image removes the details (high frequency components), which are represented separately in the other three images, in a manner that produces a sparser representation overall, making it is easier to store and transmit. Below is an example of a wavelet transformed image portraying the four sub-images as explained above.
The inverse transformation can be applied to T, resulting in lossless compression. Lossy compression can be implemented by manually setting to zero the elements below a certain threshold in T. The equation of the inverse transformation is:
(Ã = A after lossless compression)
In assembly, we implemented the matrix multiplication using a filter representation of the process. We first applied the filter G and H over the rows and then the columns as an FIR filter. While performing this step we use a technique called downsampling to prevent redundancies. As will be demonstrated later, we need to work with only successive pairs of elements. To perform this process, we throw away every other result and keep only the ones obtained from successive pairs of elements. Below is an explanatory diagram of the mechanism of the filter application (first half). A similar process is used for the second half of the transformation:
The wavelet transformation employs the use of a technique called averaging and differencing. Below is a simple example of the technique performed on a single row of the matrix of pixels that represent an image.
Imagine extracting one row from a 16x16 black and white, 256-color image in its matrix form. For example:
Original Sequence:45 45 46 46 47 48 53 101 104 105 106 106 107 106 106 106
Every element in this 16-element vector has a value between 0 and 255 since the image is 256-color. The magnitude of the element represents the brightness of its corresponding pixel. Hence, the darker it is, the closer it is to black (0).
Inside most of the pixel sequence, we notice that most of the elements have values very close to the values of their neighbors – this indicates a gradual shift in color. Sudden jumps in values occur at the outlines (edges) of objects in the image (53 to 101), which are sudden transitions in brightness.
We also know that any two numbers can be completely characterized by their average and their difference. In the sequence above, the averages and differences of successive pairs are:
Averages:45 46 47.5 77 105 106 107 106
Differences:0 0 -1 -48 -1 0 1 0
Now, we observe that the sequence of differences has many small (recall that neighboring values are very similar, implying small differences). This sequence is therefore very easy to compress. We perform the compression by making all the values of small magnitude 0. Hence we have a very ‘sparse’ sequence.
Differences (with threshold):0 0 0 -48 0 0 0 0
This sequence is highly compressible. Using this new sequence of differences and the same sequence of averages, we can easily recompute the original sequence that
Apply G over first column of image with downsampling
Apply H over first column of image with downsampling
Second column, third column, etc
Delay 0Delay 2Delay 4
…
Delay 0Delay 2Delay 4
…
Downsampling:
…
…
NW A
Second column, third column, etc
defined a section of the image:
Recovered Sequence:45 45 46 46 47 47 53 101 104 104 106 106 106 106 106 106
This is a very good approximation of our original sequence.
To perform the transformation in DSP we loaded the pixel values for the image into DSP memory, process the image in the DSP assembly program, and output the transformed image, or transformed-compressed image, to a memory location below the original image. This data would be processed again to recover the original image. To be more specific, our original image was loaded at location 0x1800, the intermediate result, which is the first half of the transformation is stored immediately below the original image at location 0x1C00. Finally, we store the final output directly below this at address 0x2000. Below is a memory map showing the addresses used in the memory for the intermediate result and final result of our output:
Project Development:
Week 1: Research and Wavelet Reviewing
In this first week, we educated ourselves on the theory of wavelet transformations, a subject neither of us had encountered previously. We also gathered many reports and other documents that we believed would help us in our project. During the week, we read these reports and discussed aspects of the reports that could be adapted to the objective of our project.
Week 2: MATLAB coding
By the second week, we were well versed with the process of the transformation. Our goal now was to successfully perform the Haar wavelet transformation of a sample image in MATLAB. If successful, we expected to see the image in the compressed, yet lossless form. We imposed no restrictions on the complexity of functions used, since at this stage all we wanted was to see a result. All our programming at this stage
Original Image AHex Grayscale Values1800
Memory Storage Map
1C00
2000
A
NB W A
TNT BW
Intermediate Result BHex Grayscale Values
Transformed Image THex Grayscale Values
was in MATLAB. At first we used the various functions to perform the matrix multiplications. Once successful, we broke down the MATLAB functions that we used into computations into code that could easily be transferred to assembly language. The most important process here was the conversion of the matrix multiplication into a filter representation. We also recreated the MACP command in MATLAB; this would prove very helpful in the following week when we begin to convert our MATLAB code to assembly.
Week 3: Assembly Coding – First half.
After the success of the MATLAB program, we immediately began to rewrite our code in assembly. Progress slowed down dramatically at this stage, given the many restrictions and the complexity of programming in assembly. To test our program at each stage, we performed only the first half of the filter representation of the matrix multiplication during this week. We constantly compared our results with the results obtained from performing only the first half of the transformation in MATLAB. This way we believed that the time spent debugging the program at a later date would be reduced significantly. Fortunately, progress was satisfactory in this week, and we were able to move on to the second half of the transformation in the following week.
Week 4: Assembly Coding – Second half and Debugging
By this stage in the timeline, we were quite confident of our programming skills in assembly. We identified errors more quickly, which made the programming less frustrating. Nonetheless, our progress was always fraught with unexpected and sometimes arbitrary errors that required much time to correct, mostly by using brute force. We had a major problem running our code right through. To check our results, we had to ‘break through’ the code in code explorer. Because of this problem, our progress began to crawl. Due to this, we realized that we would not be able to achieve our initial objective of performing lossless and lossy compression in assembly. We had also hoped to perform the inverse transformation in assembly. We decided to pursue only lossless compression because doing this would in itself demonstrate the capabilities of compression using the wavelet transform. Finally, we realized that the pipelining of operations was the cause of our inability to run the code in entirety. To solve this problem, we inserted multiple ‘nop’ commands after nearly every line of the code. After this, we successfully got our result and verified it in MATLAB. We also transferred the hex data from the memory to MATLAB, and performed the inverse transformation to recover the original, lossless image.
Week 5: Presentation
During this week, we gathered our results and compiled a report of them that was then transferred to a presentation that was used in class. We reviewed the details of the wavelet transformation so that we could educate the rest of the class on it too before demonstrating the results of our project during the presentation.
Discussion of Results:
We were able to successfully perform the Haar wavelet transform for image compression in Matlab and also on DSP. In Matlab, the forward and inverse transformation ran as desired and was tested for several different test images. Two
different forward transformations were tested in Matlab; the original matrix representation of the transformation and its inverse, and the forward transformation as represented by filter operations on the rows and columns, which is a closer model of the algorithm used on the DSP. Both representations obtained identical results for the forward transformation. Two examples tested are shown below, with the original image on the left and the transformed image on the right, and their sizes as JPEG files below.
Thus the MATLAB code successfully performed the Haar wavelet transform over the rows and columns of the image and found the transform T of the image, representing the transformation:
The inverse transformation using the matrix equation,
recovered the original test image without any changes, showing that the lossless transformation was implemented correctly.
We implemented only the forward transformation on the DSP, due to time limitations. We were not able to use the test images above to test our algorithm due to the smaller memory capacity of the DSP. We were only able to use images of size 32x32. We
tested our DSP code for one particular 32x32 test image, and we compared the resulting transformed image with the transformation as done using our MATLAB code. We also compared the result of the inverse transformation on both transformed images. The results are shown in the diagram below.
It is clear that the DSP successfully performed the lossless Haar wavelet transform on the sample image correctly. There is some difference in compressed image size, due to the limited 16-bit precision of computations on the DSP. However, despite this lack of precision equivalent to Matlab’s transform, the inverse transformation yielded images that were not recognizably different from the original image. Thus, any error introduced by the limited precision of calculation on the DSP does not actually affect the accuracy of the transformation in any significant way.
We faced some issues with running the code on the DSP. Debugging various errors took a significant portion of our development time. One particular problem we encountered had to do with pipelining of operations. Portions of the code would work perfectly when we step through line by line, but the program would not run correctly when we try to run it from beginning to end, or even continuously between certain breakpoints. We found that the solution was to place NOP commands between lines, and even multiple NOP commands between some lines. This command tells the DSP processor to halt processing for one cycle, to allow operations to catch up and the correct computation results to be used in subsequent commands. Our code ran flawlessly after this correction. The NOP command, of course, will slow the overall performance of the code, but our algorithm was not meant to run continuously since it does not operate on time-domain signals. We noticed no slowdown since it only runs once. Another issue involved the limitation of how values can be assigned to registers and accumulators. A seemingly simple command like adding two memory addresses and setting the resulting memory location to an accumulator value is actually a somewhat complex command to implement correctly in assembly code. It took time to find workarounds for unforeseen issues such as these. Thus, in the end we only had time to implement the lossless forward transform on the DSP, and not the lossy transform or the inverse transform.
Conclusion:
We successfully implemented the 2-dimensional Haar wavelet transformation on the DSP as applied to lossless image compression. We also implemented the transformation and its inverse in Matlab and compared the results to verify that our algorithm was working correctly. We found that compression on the DSP actually worked, as we achieved smaller JPEG file sizes for the transformed images when compared to file sizes for the original images, and we were able to fully recover the original image from these compressed images using Matlab. Challenges and problems included memory limitation of the DSP, assembly language issues, and automatic pipelining of processing. Future extensions of this project could include implementation of the inverse transform on DSP, and implementation of lossy image compression by setting a threshold value for the transformed image.
References:
Cheng, H, Huang, Z., Kumimoto, M. “Final Project Report – Image Processing Techniques”, Spring 2006, <http://mkumimoto.bol.ucla.edu/>
Mulcahy, C. “Image compression using the Haar wavelet transform”, Spelman Science and Math Journal, pp. 22-31, <http://www.cs.toronto.edu/~arnold/320/Readings/haarWavelets.pdf>
Texas Instruments, Application Report SPRA800, “Wavelet Transforms in the TMS320C55x”, January 2002, <http://focus.ti.com/dsp/docs/dspsupporttechdocsc.tsp?sectionId=3&tabId=409&abstractName=spra800>
Valens, C. “A Really Friendly Guide to Wavelets”, 1999-2004, <http://perso.orange.fr/polyvalens/clemens/wavelets/wavelets.html#section4>
Van Fleet, P. “Discrete Haar Wavelet Transforms”, PREP Wavelet Workshop 2006, June 7, 2006, <http://cam.mathlab.stthomas.edu/wavelets/pdffiles/UST06/Lecture4.pdf>
Yusof, Z., Manap, N., Suleiman, I., Saleh, S., Aspar, Z. “Impelementation of Wavelet Codec by using Texas Instruments DSP TMS320C6701 EVM Board”, International Symposium on Signal Processing and its Applications, August 13-16, 2001.
Project Files:
original.jpg:This is the input image file that will be compressed.
ee113filters.m:This MATLAB program takes the original input image ‘original.jpg’, performs the wavelet transform on it, and saves the transformed, compressed representation of the image to ‘transformed_image.jpg’.
32.asm: This file holds the values of the pixels of the image in vector form. These values will
be read by wavelet.asm using the table look-up method.
32noword.asm: This file is the same as 32.asm, only without the ‘.word’ directives. This file will is used by output.m.
8tap.asm:This file holds the two coefficients of each the two filters that will be used in the filters in wavelet.asm.
wavelet.asm:This is the main assembly program file. This program retrieves filter and image content from 8tap.asm and 32.asm respectively. It then outputs the compressed form of the image to memory location 0x2000 of the DSP memory.
dsp_output.dat:This data file contains the output of memory location 0x2000 of the DSP obtained after running wavelet.asm. The memory, starting at 0x2000, holds the pixel values of the image that is in the compressed form.
output.m:This MATLAB program converts the raw data from dsp_output.dat to an image form. It then displays the original image (using 32noword.asm), the image in compressed form and the recovered image for comparison.
Code:
wavelet.asm:
.title "Image Compression using Wavelet Transform" .width 80 .length 55 .mmregs
.setsect ".data", 0x07EF, 0 ;all program code, FIR coeffs and temp data stored in first block .setsect ".text", 0x0180, 0 ;of program memory .setsect "coeff", 0x07F8, 0
.setsect "pic" , 0x1800, 0 ;pictures will be stored in second block of program memory
.setsect "OPpic", 0x1C00, 0
.sect "pic"picbeg
.copy "32.asm" ;original pic, loaded as array of 8bit luminance values
.sect "OPpic"pic2 ;label for output picture
.sect "coeff"
.copy "8tap.asm" ; 2-tap wavelet FIR ; coefficient values here
.data ; data section where ; intermediate results of the ; calculations will be stored
XN .word 0,0,0,0,0,0,0XNLAST .word 0 ;OUTPUT .word 0 ; extra word for the bit bucket
.text ; main program section
**********SET CONSTANTS HERE************size .set 400h ;set pic size = N^2ntaps .set 2 ;num tapslag .set 4 ;num pixels behind input (to store average in 'middle')
ncols .set 32 ;num pixels per rownrows .set 32 ;num pixels per colhalfn .set 16****************************************
;WHAT FOLLOWS IS SECOND PART (?) C = WN * B^Tstart:
AR5 = #0 ;AR5 holds current column (array indexing)AR6 = #(ncols - 1) ;counter to loop through each row
new:;DP = #XNLAST ;data ptr to allow buffer access
*********************FIRST PART HERE:***************
colp AR2 = #(halfn - 1) ;num times to loop in col (nrows?)AR1 = #picbeg ;AR1 (input pointer) set to beginning of
pic
*******initialize the input/output pointers*****
B = AR5 ;init input ptr
nopnopnopnop
A = AR1 ;(this setup specific to ncols = 32)
nopnopnopnop
B = B + A ;add to beg of pic to getAR1 = B ;beginning of column
nopnopnopnop
B = B + #size ;setup output ptrAR3 = B ;one full size ahead of input to place after
original pic in memory
nopnopnopnop
;situation:;AR2 is 32;AR6 is counter;AR1 is beginning of current input column;AR3 is beginning of current output column;AR5 is column number for next column;AR0, AR4, AR7 unused
********move down each column and compute h1/h2 filters******AR4 = #0 ;index variable
nopnopnopnop
aloop ;loop through each pixel; *AR1, *AR1 + 1 are current pixels right now
;FIR code goes here;A first input pixel
*******FIR CODE****************;AR0, AR7 unused;B(index, c) = macd([A(r,c) A(r+1,c)],h1);
;index = index+1;
B = #0 ;n-pixels
nopnopnopnop
AR7 = #2020h ;sets *AR7 to first of *AR1
nopnopnopnop
A = *AR1
nopnopnopnop
*AR7+ = A
nopnopnopnop
A = #0 ;sets A to AR1+32
nopnopnopnop
B = AR1
nopnop
nopnop
A = A+B
nopnopnopnop
A = A+#32
nopnopnopnop
AR0 = A
nopnopnopnop
A = *AR0
nopnopnopnop
*AR7+ = A
nopnopnopnop
A = *AR7-
nopnopnopnop
A = *AR7-
nopnopnopnop
B = #0
nopnopnopnop
repeat(#ntaps - 1)MACP(*AR7+, h0, B)
nopnop
nop
B = B >> 10
nopnopnopnopnopnopnopnopnopnopnopnopnopnop
nopnop
;RIGHT NOW WHERE WE ARE: above, made MACP work with one element in row above another for this case
;MUST CHANGE this!!!!! below - not AR3+AR4; have to be AR3 + AR4*32 = <<5;store into output - MEMORY ADDRESSING;must store B to column which starts at AR3;row of AR4;memory location is going to be ;AR3+AR4*32
;have A, AR0, AR7
AR7 = B
nopnop
nopnop
A = AR3
nopnopnopnop
B = AR4
nopnopnopnop
AR0 = B
nopnopnopnop
B = B << 5
nopnopnopnop
A = A+B
nopnopnopnop
AR0 = A
nopnopnopnop
A = AR7
nopnopnopnop
nopnopnop
*AR0 = A
nopnopnopnop
A = AR4
nopnopnopnop
A = A + #1 ;increments index
nopnopnopnop
AR4 = A
nopnopnopnop
A = AR1
nopnopnopnop
A = A + #64
nopnopnopnop
AR1 = A*******************************
nopnopnopnop
;increment current pixel again (total by 2)
;B = *AR2-if(*AR2- != 0) goto aloop ;if pixels remaining continue
*************************************************************
nopnopnopnop
AR2 = #(halfn - 1) ;num times to loop in row (ncols?)AR1 = #picbeg ;AR1 (input pointer) set to beginning of
pic
nopnopnopnop
B = AR5 ;init input ptr
nopnopnopnop
nop
A = AR1 ;(this setup specific to ncols = 32)
nopnopnopnop
B = B + A ;add to beg of pic to get
nopnop
nop
AR1 = B ;beginning of row
nopnopnopnop
B = B + #size ;setup output ptr
nopnopnop
AR3 = B ;one full size ahead of input to place after original pic in memory
nopnopnopnop
B = AR5 ;increment current column
nopnopnop
B = B + #1
nopnopnopnop
AR5 = B
aloop2 ;loop through each pixel; *AR1, *AR1 + 1 are current pixels right now
;FIR code goes here;A first input pixel
*******FIR CODE****************;AR0, AR7 unused;C(r, index) = macd([B(r,c) B(r,c+1)],h1);
;C(r, index+cols/2) = macd([B(r,c) B(r,c+1)],h2); ;index = index+1;
B = #0 ;n-pixels
nopnopnopnop
AR7 = #2020h ;sets *AR7 to first of *AR1
nopnopnop
A = *AR1
nopnopnopnop
*AR7+ = A
nopnopnopnop
A = #0 ;sets A to AR1+32
nopnopnop
B = AR1
nopnopnopnop
A = A+B
nopnopnopnop
A = A+#32
nopnop
nopnop
AR0 = A
nopnopnopnop
A = *AR0
nopnopnopnop
*AR7+ = A
nopnopnopnop
A = *AR7-
nopnopnop
A = *AR7-
nopnopnopnop
B = #0
nopnopnopnop
repeat(#ntaps - 1)MACP(*AR7+, h2, B)
nop
B = B >> 10
nop
nopnopnopnopnopnopnopnopnopnopnopnopnopnop
;store into output - MEMORY ADDRESSING;must store B to row which starts at AR3;column of AR4;memory location is going to be ;AR3+AR4*32
;have A, AR0, AR7
AR7 = BA = AR3
nopnopnopnop
B = AR4AR0 = B
nop
B = B << 5
nop
A = A+B
nop
AR0 = A
nop
A = AR7
nop
nopnopnop
*AR0 = A
nop
A = AR4
nop
A = A + #1 ;increments index
nop
AR4 = A
A = AR1
nop
A = A + #64
nop
AR1 = A
*******************************
nop
;increment current pixel again (total by 2)
;B = *AR2-if(*AR2- != 0) goto aloop2 ;if pixels remaining continue
*************************************************************
nop
if(*AR6- != 0) goto colp ;if columns remain continue
*********************END FIRST PART*****************
start2AR5 = #0 ;AR5 holds current row (array indexing)AR6 = #(nrows - 1) ;counter to loop through each row
rolp AR2 = #(halfn - 1) ;num times to loop in row (ncols?)AR1 = #picbeg ;AR1 (input pointer) set to
beginning of picA = AR1A = A+#sizeAR1 = A
*******initialize the input/output pointers*****B = AR5 ;init input ptr
nop
B = B << 5 ;find current row, mult by row lengthA = AR1 ;(this setup specific to ncols = 32)
nop
B = B + A ;add to beg of pic to getAR1 = B ;beginning of row
nop
B = B + #size ;setup output ptrAR3 = B ;one full size ahead of input to place after
original pic in memory
nop
;situation:;AR2 is 32;AR6 is counter;AR1 is beginning of current input row;AR3 is beginning of current output row;AR5 is row number for next row;AR0, AR4, AR7 unused
********move down each column and compute h1/h2 filters******AR4 = #0 ;index variable
nop
loop ;loop through each pixel; *AR1, *AR1 + 1 are current pixels right now
;FIR code goes here;A first input pixel
*******FIR CODE****************;AR0, AR7 unused;C(r, index) = macd([B(r,c) B(r,c+1)],h1);
;C(r, index+cols/2) = macd([B(r,c) B(r,c+1)],h2); ;index = index+1;
B = #0 ;n-pixels
nop
repeat(#ntaps - 1)MACP(*AR1+, h0, B)
nopnop
B = B >> 10
nopnopnopnopnopnopnopnopnopnopnopnopnopnop
;store into output - MEMORY ADDRESSING;must store B to row which starts at AR3;column of AR4
;memory location is going to be ;AR3+AR4
;have A, AR0, AR7
nop
AR7 = BA = AR3
nop
B = AR4A = A+B
nop
AR0 = AA = AR7
nop
nopnopnop
*AR0 = A
nop
A = AR4A = A + #1 ;increments indexAR4 = A
*******************************
nop
;increment current pixel again (total by 2)
;B = *AR2-if(*AR2- != 0) goto loop ;if pixels remaining continue
*************************************************************
nop
AR2 = #(halfn - 1) ;num times to loop in row (ncols?)AR1 = #picbeg ;AR1 (input pointer) set to beginning of
picA = AR1A = A+#sizeAR1 = A ;Add size to AR1 to set part 2s i/p to part
1s o/p
nop
B = AR5 ;init input ptr
nop
B = B << 5 ;find current row, mult by row length (32)
nop
A = AR1 ;(this setup specific to ncols = 32)
nop
B = B + A ;add to beg of pic to getAR1 = B ;beginning of row
nop
B = B + #size ;setup output ptrAR3 = B ;one full size ahead of input to place after
original pic in memory
nop
B = AR5 ;increment current rowB = B + #1
nop
AR5 = B
loop2 ;loop through each pixel; *AR1, *AR1 + 1 are current pixels right now
;FIR code goes here;A first input pixel
*******FIR CODE****************;AR0, AR7 unused;C(r, index) = macd([B(r,c) B(r,c+1)],h1);
;C(r, index+cols/2) = macd([B(r,c) B(r,c+1)],h2); ;index = index+1;
B = #0 ;n-pixels
nop
repeat(#ntaps - 1)MACP(*AR1+, h2, B)
nopnop
B = B >> 10
nopnopnopnopnopnopnopnopnopnopnopnopnopnop
;store into output - MEMORY ADDRESSING;must store B to row which starts at AR3;column of AR4;memory location is going to be ;AR3+AR4
;have A, AR0, AR7
AR7 = BA = AR3
nop
B = AR4A = A+B
nop
AR0 = AA = AR7
nopnopnop
*AR0 = A
nop
A = AR4A = A + #1 ;increments index
nop
AR4 = A
*******************************
nop
;increment current pixel again (total by 2)
;B = *AR2-if(*AR2- != 0) goto loop2 ;if pixels remaining continue
*************************************************************
nop
if(*AR6- != 0) goto rolp ;if rows remain continue
WAIT: nopgoto WAIT ; infinite loop at end of execution
.end
ee113filters.m:
function ee113filters()function sum = macd(ar,h) %incorporates repeat as well sum = 0; for i = 1:length(h) sum = sum + h(i)*ar(i); end end
clear all;
[A,map] = imread('original.jpg','jpg');
B = double(A(:,:,1));
dim = length(B(1,:));
h1 = [0.707 0.707];h2 = [-0.707 0.707];
A= B;% the algorithm:
%A is image%first step: perform B = Wn * A
%perform on each column in order: % h1 filter % h2 filter % throw away every other result
for c = 1:dim; %for each column % h1 filter index = 1; for r = 1:2:dim; %move down the column of A B(index, c) = macd([A(r,c) A(r+1,c)],h1); index = index+1; end % h2 filter for r = 1:2:dim; %move down the column of A B(index, c) = macd([A(r,c) A(r+1,c)],h2); index = index+1;
end end
%second step: perform C = (Wn * B^T)
for r = 1:dim; %for each row of B % h2 filter index = 1; for c = 1:2:dim; %move down the row of B C(r, index) = macd([B(r,c) B(r,c+1)],h1); index = index+1; end % h2 filter for c = 1:2:dim; %move down the row of B C(r, index) = macd([B(r,c) B(r,c+1)],h2); index = index+1; end end
%third step: perform T = transpose of C
out = C;
out2(:,:,1) = uint8(out);out2(:,:,2) = uint8(out);out2(:,:,3) = uint8(out);
imwrite(out2,'transformed_image.jpg','jpg');
end
output.m:
% EE 113D Final Project% Herman Cheng, Zhicong Huang, Mark Kumimoto
% This program converts the raw data points from the DSP output into an% image. It also outputs the image onto the computer.
close all;clear all;clc;
% VARIABLES =============================================================ORIGINAL = '32noword.asm'; % original imageRAW = 'dsp_output.dat'; % processed raw data pointsOUTPUT = 'dsp_output.jpg'; % name of output file% =======================================================================
% Read data ===============================================================original = load(ORIGINAL); % original image data with .word directives removed[row,col] = size(original);raw1 = load(RAW); % raw data% =======================================================================
% Convert N^2 vector into NxN matrix =============================================raw1 = raw1'; % convert the column data into row datafiltered11 = []; % empty matrix ready for NxN imagefor n = 1:row filtered11(n,:) = raw1(col*(n-1)+1:col*n);end
filtered1(:,:,1) = uint8(filtered11);filtered1(:,:,2) = uint8(filtered11);filtered1(:,:,3) = uint8(filtered11);% =======================================================================
imwrite(filtered1, OUTPUT, 'jpg'); % writes file to computer
dim = 32;for r = 1:dim; for c = 1:dim;
if (c == 2*r || c == 2*r - 1 ) Wn(r,c) = 0.707; elseif c == 2*(r-dim/2) Wn(r,c) = 0.707; elseif c == 2*(r-dim/2)-1 Wn(r,c) = -0.707; else Wn(r,c) = 0; end endend
original = inv(Wn)*filtered11*inv(Wn');original2(:,:,1) = uint8(original);original2(:,:,2) = uint8(original);original2(:,:,3) = uint8(original);imwrite(original2,'original_actual.jpg','jpg'); %Save the recovered image
% Plot data ================================================================figure(1);subplot(3,3,2);colormap('gray(256)');imagesc(original);title('Original Image');
subplot(3,3,5);colormap('gray(256)');imagesc(filtered1);title('Image in Compressed Form');
subplot(3,3,8);colormap('gray(256)');imagesc(original2);title('Recovered Image');% =======================================================================
% Clear data ===============================================================clear ORIGINAL;clear OUTPUT;clear RAW;clear raw1;clear row;clear col;clear n;
