Coding with JPEG standard

breezebongΤεχνίτη Νοημοσύνη και Ρομποτική

6 Νοε 2013 (πριν από 3 χρόνια και 11 μήνες)

54 εμφανίσεις

Image Processing


In this deliverable we have start
ed with the conversion from what
ever format to JPEG
format for images. First of all, we have done a practice about transform the
format of a
picture with
the program
VCDemo:



Coding with JPEG standard


Gr
oup B: Clown256B (8 bits per pixel)



Practical session
-

JPEG Module


1.

Encode the test image with quality parameters equal to 10, 20 and 36. Use the
standard quantization matrix (‘Standard Y’, default option).

a)

Calculate the compression factor for each case
. Do the computations in
two different ways:

(i)

From the bit rate (the one given by Image Information:
click on the image with the right button of the mouse)

(ii)

By comparing the file size of the input image with that
of the compressed image


Quality

Bpp

C.F.

Si
ze (Kbytes)

C.F.

10

0,42

19,0476

3,37

19,3

20

0,62

12,9032

4,95

13,13

36

0,84

9,5238

6,73

9,65

Original

8

-

65

-


How do the compressed image size, the bit rate and the compression factor
change with the quality parameter?



When the quality parameter

increases, the image size and the bit rate increases
too, this is because of the bit rate and the quality of the image are directly
proportional, if an image have more bits per pixel, it’s quality will be better but
also it will have a bigger size. On the

other hand the C.F. decreases, this is
because the C.F. is the relation between the bits per pixel of the original image
(8bpp) and the bits per pixel of the decoded image, and, as we said before, there
are more bits per pixel in an image with better qual
ity.



b)

Compare the visual quality of the coded images (
strictly

speaking of the
decoded images). In particular, describe the different
distortions

and
why they appear.













As we can see in the images above, every time we are decoding the image with a
bigger C.F. we can see more significant the distortions that JPEG introduces. If
we take the image with an optimized quality factor of
10, we can see these two
distortions better:


Blocking
: Showed below with a green line, the blocking artifacts, as its name
suggest, produce annoying blocking artifacts near block boundaries.


Ringing
: Showed below with the red line, the ringing artifacts

created a light halo
in the edge of some parts of the image.



Original image





10



20




36





c)

Check the effect of applying a low
-
pass filtering (smoothing) to the
decoded image. (Che
c
k the option off once you have finished.)



36



36 Smoothed





20



20 Smoothed




10



10 Smoothed




As we can see in the images above, there is no difference, ore almost we can’t
differentiate it, between the decoded images without applying a low
-
pass filtering,
and the images decoded ap
plying it.


2.

Repeat the previous coding but using
an
uniform quantization matrix (‘Flat’
option).

a)

Compute the compression factor for each case (just as in 1a(i)).



Quality

Bpp

C.F.

10

0,20

40

20

0,30

26,6666

36

0,47

17,0213

Original

8

-


b)

Experiment w
ith different quality parameters until obtaining similar
compression factors to those obtained in section 1a.



Quality

Bpp

C.F.

31

0,42

19,0476

53
-
54

0,62

12,9032

69

0,84

9,5238

Original

8

-



c)

Compare the quality of the images with respect to section

1a.










36




36 using an uniform quantization matrix



20




20 using an uniform quantization matrix



10




10 using an uniform quantization matrix


As we can see in the images above, a

decoded image using a uniform
quantization matrix will have
fewer

bits per pixel to obtain the same optimized
quality factor than an image decoded without use a uniform quantization matrix.
We also can see more significant the distortions occurred because

of the
encoding in the image decoded with a uniform quantization matrix.


3.

For each of the entropy coding options (three in total: ‘FLC’, ‘Standard VLC’ and
‘Optimal VLC’), draw the SNR
-
bit rate and Quality
-
SNR curves . What
conclusions can you infer?


SN
R
-
bit rate curves





With the SNR
-
bit rate curves showed above, we can see that the images
encoded with optimal VLC and Standard VLC have a similar SNR, the image
encoded with optimal VLC has a bigger value of SNR than the image encoded
with standard VLC

with a bit rate lower than 0,6 bits per pixel. The image
encoded with FLC has a value of SNR very lower than the other two images.

But below we can see the Quality
-
SNR curves; there we saw that the image
encoded with FLC has very low values of quality, th
e images encoded with
optimal VLC and Standard VLC have a similar quality values per SNR.

In conclusion, the image encoded with FLC will have less SNR but also will have
less quality, too much less quality.














Quality
-
SNR curves




Quality-SNR curve
0
10
20
30
40
50
60
70
80
90
0
5
10
15
20
25
30
Quality
Optimal VLC
Standard VLC
FLC


4.

Encode the image

‘Noise256B’
at 0.5 bpp, 1 bpp and 1.5 bpp. Compare the
results with the ones you would obtain with your test image. What conclusions
can you draw?


As the images below show, we can appreciate more the differences between t
he
different encodes in the Noise256B than with our image. In our image, the
difference between the encoding with 1.5 bpp and the encoding between 1 bpp is
very small, we practically can’t appreciate it, when the image is decoded with 0,5
bpp the differenc
es are bigger, but not too much. On the other hand, in
Noise256B the differences between 1,5 bpp and 1bpp are bigger, and in the
decoded image with 0,5 bpp the distortions are very visible.

The fact that makes the Noise256B decoding effects more visible t
han in
Clown256B is that in Noise256B there are more abrupt changes between the
colors, the frequency of a change of color is very big, so there are more edges
and the distortion effects of JPEG are more visible.










NOISE256B

CLOWN256B


0.5 bpp




0.5 bpp



1 bpp




1 bpp



10




1.5 bpp


JPEG Converter application


The second part of this deliverable is the implementation of a mini application
without
GUI
about JPEG conversion
. This application have to read and incoming image

that
have to

be in the same directory of the main class
, apply a filter (in our case a
convolution to sharp the i
mage) and store the new image as

JPEG
with a desired
quality
(applying the conversion to JPEG).


First of all, we have made an interface
called
iConvertion

explaining the functions to
implement.
In this interface are the functions reader, convolution and ToJPEG.


public interface iConvertion {


public PlanarImage reader(String orig_name);


public PlanarImage convolution(PlanarImage img);


public vo
id ToJPEG(String conv_name, PlanarImage img, float qual) throws
FileNotFoundException, IOException;

}


We have decided to
make it in this way because the structure for every part of the
application will be defined as interfaces or classes implementing inte
rfaces. It will be
much easier to integrate it into our application.



After this, we have created the class that implements de interface.

It is being called
Convertion
.


public class Convertion implements iConvertion{



In this class, there are the functi
ons to call from the main class and make the different
requirements for this deliverable:




Function
reader
:


public PlanarImage reader(String orig_name){ //Load the picture



PlanarImage img=null;


img= JAI.create("fileload", orig_name);



return img;


}




This function will catch a string where we put the original name of the picture

and
create a planar image from the

original picture. It would read that picture.





Function
convolution
:


public PlanarImage convolution(PlanarImage im
g){

//Sharp the image



KernelJAI kernels;


float[] sharpenMoreData = {
-
1.0F/ 4.0F,
-
1.0F/ 4.0F,
-
1.0F/ 4.0F,


-
1.0F/ 4.0F, 12.0F/ 4.0F,
-
1.0F/ 4.0F,


-
1.0F/ 4.0F,
-
1.0F/
4.0F,
-
1.0F/ 4.0F };



kernels = new KernelJAI(3, 3, 1, 1, sharpenMoreData);


ParameterBlock paramBlock = new ParameterBlock();


paramBlock.addSource(img);


paramBlock.add(kernels);


img=JAI.create("convolve", paramBlock);



return img;


}


In this part, the planar image created before in
reader

will be convolv
ed
with a
matrix that will sharp the image. The first thing is the creation of a matrix that will
sharp

some image when it is convolve
d with this

image.

We create

a
ParameterBlock

and add the two images in it. After that we have only to create the
convolved image from the
ParameterBlock
.






Function
ToJPEG
:


public void ToJPEG(String conv_name, PlanarImage img, float qual) throws
FileNotFoundException, IOException
{



OutputStream out = new FileOutputStream(conv_name);


//Convert to JPEG with quality selected and store



JPEGEncodeParam encodeParam = new JPEGEncodeParam();


encodeParam.setQuality(qual);


ImageEncoder encoder = ImageCodec.create
ImageEncoder("JPEG", out,
encodeParam);


encoder.encode(img);




}



In this last part we have only to convert the image to JPEG format but with the
quality desired by the user.
First, we have created the output image file, where the
convolved i
maged will be created. After that, the have created a encoding
parameter where we set the quality inserted by the user and then, we have created
the encoder with the name of the output file, the quality encoding parameter and
the format we want to convert.


After that, the new convolved image is created in the same folder of the original
picture.


We think this mini application will be useful for the application of this project
because the fact of convert to JPEG would be interesting when downloading a
pict
ure. The application of a filter is also useful for the editor tool bar in our
application (explained in the User Interface part
, paper prototype
).