Table of Contents

illinoiseggoSoftware and s/w Development

Oct 28, 2013 (3 years and 10 months ago)

128 views

Abstract:

Digital image processing is the use of computer algorithms to perform image processing on
digital images. Digital image processing has the same advantages over analog image processing
as digital signal processing has over analog signal
processing


it allows a much wider range of
algorithms to be applied to the input data, and can avoid problems such as the build
-
up of noise
and signal distortion during processing. The most common kind of digital image processing is
digital image editing
.

Pattern recognition aims to classify data (patterns) based on either a priori knowledge or
on statistical information extracted from the patterns. The patterns to be classified are usually
groups of measurements or observations, defining points in an app
ropriate multidimensional
space. This is in contrast to pattern matching, where the pattern is rigidly specified
.



Table of Contents

1.

Front Page

2.

Candidate Declaration

3.

Certificate

4.

Certificate (External, Internal)

5.

Acknowledgement


6.

1.Fundamentals

7.

2.Image
formats supported by Matlab

8.

3.Working formats in Matlab

9.

4.Intensity image (gray scale image)

10.

5.Binary image

11.

6.Indexed image

12.

7.RGB image

13.

8.Multiframe image

14.

9.How to convert between different formats

15.

10.Image format conversion

16.

.

How to display an image in Matlab


Working with Strings in MATLAB

Distance Measures in MATLAB

Computing

Forming Pattern Vectors

Recognition Based on Decision
-
Theoretic Methods


Introduction:

Image: An image may be defined as a two
-
dimensional function

( x,y ) ,where x and y are spatial
(plane) coordinates, and the amplitude of f at any pair of coordinates (x,y)is called the intensity or gray
level of the image at that point.


Analog Image:

Can be mathematically represented as a continuous range of
values representing
position and intensity.

Digital Image:

a digital image is restricted in both its spatial coordinates and in its allowed
intensities.


The field of
digital image processing
refers to processing digital images by means of a digital
computer. Note that a digital image is composed of a finite number of elements, each of
which has a particular location and value. These elements are referred to as picture
elements, image elements, pels, and pixels. Pixel is the term most widely used to d
enote the
elements of a digital image



Fundamentals

A digital image is composed of

pixels

which can be thought of as small dots on the screen. A
digital image is an instruction of how to color each pixel. We will see in detail later on how
this is done in

practice. A typical size of an image is 512
-
by
-
512 pixels. Later on in the
course you will see that it is convenient to let the dimensions of the image to be a power of 2.
For example, 2
9
=512. In the general case we say that an image is of size

m
-
by
-
n

if
it is
composed of

m

pixels in the vertical direction and

n

pixels in the horizontal direction.

Let us say that we have an image on the format 512
-
by
-
1024 pixels. This means that the data
for the image must contain information about 524288 pixels, which req
uires a lot of memory!
Hence,

compressing

images is essential for efficient image processing. You will later on see
how Fourier analysis and Wavelet analysis can help us to compress an image significantly.
There are also a few "computer scientific" tricks
(for example entropy coding) to reduce the
amount of data required to store an image.

Image formats supported by Matlab

The following image formats are supported by Matlab:



BMP



HDF



JPEG



PCX



TIFF



XWB

Most images you find on the Internet are JPEG
-
images whic
h is the name for one of the most
widely used compression standards for images. If you have stored an image you can usually
see from the suffix what format it is stored in. For example, an image named

myimage.jpg

is
stored in the JPEG format and we will se
e later on that we can load an image of this format
into Matlab.

Working formats in Matlab

If an image is stored as a JPEG
-
image on your disc we first read it into Matlab. However, in
order to start working with an image, for example perform a wavelet
transform on the image,
we must convert it into a different format. This section explains four common formats.

Intensity image (gray scale image)

This is the equivalent to a "gray scale image" and this is the image we will mostly work with
in this course.
It represents an image as a matrix where every element has a value
corresponding to how bright/dark the pixel at the corresponding position should be colored.
There are two ways to represent the number that represents the brightness of the pixel:
The

doubl
e

class (or data type). This assigns a floating number ("a number with decimals")
between 0 and 1 to each pixel. The value 0 corresponds to black and the value 1 corresponds
to white. The other class is called

uint8

which assigns an integer between 0 and 2
55 to
represent the brightness of a pixel. The value 0 corresponds to black and 255 to white. The
class

uint8

only requires roughly 1/8 of the storage compared to the class

double. On the
other hand, many mathematical functions can only be applied to thedo
uble

class. We will see
later how to convert between

double

and

uint8.

Binary image

This image format also stores an image as a matrix but can only color a pixel black or white
(and nothing in between). It assigns a 0 for black and a 1 for white.

Indexed i
mage

This is a practical way of representing color images. (In this course we will mostly work with
gray scale images but once you have learned how to work with a gray scale image you will
also know the principle how to work with color images.) An indexed
image stores an image
as two matrices. . e first matrix has the same size as the image and one number for each pixel.
The second matrix is called the

color map

and its size may be different from the image. The
numbers in the first matrix is an instruction
of what number to use in the color map matrix.

RGB image

This is another format for color images. It represents an image with three matrices of sizes
matching the image format. Each matrix corresponds to one of the colors red, green or blue
and gives an in
struction of how much of each of these colors a certain pixel should use.

Multiframe image

In some applications we want to study a sequence of images. This is very common in
biological and medical imaging where you might study a sequence of slices of a cel
l. For
these cases, the multiframe format is a convenient way of working with a sequence of
images. In case you choose to work with biological imaging later on in this course, you may
use this format.

How to convert between different formats

The following
table shows how to convert between the different formats given above.

All
these commands require the Image processing tool box!

Image format conversion

(Within the parenthesis you type the name of the image you wish to convert.)

Operation:

Matlab
command:

Convert between intensity/indexed/RGB format to binary format.

dither()

Convert between intensity format to indexed format.

gray2ind()

Convert between indexed format to intensity format.

ind2gray()

Convert between indexed format to RGB format.

ind2rgb()

Convert a regular matrix to intensity format by scaling.

mat2gray()

Convert between RGB format to intensity format.

rgb2gray()

Convert between RGB format to indexed format.

rgb2ind()

The command

mat2gray

is useful if you have a matrix
representing an image but the values
representing the gray scale range between, let's say, 0 and 1000. The
command

mat2gray

automatically re scales all entries so that they fall within 0 and 255 (if
you use the

uint8

class) or 0 and 1 (if you use the

doubl
e

class).

How to convert between

double

and

uint8

When you store an image, you should store it as a

uint8

image since this requires far less
memory than

double. When you are processing an image (that is performing mathematical
operations on an image) you s
hould convert it into a

double. Converting back and forth
between these classes is easy.

I=im2double(I);

converts an image named

I

from

uint8

to

double.

I=im2uint8(I);

converts an image named

I

from

double

to

uint8.

How to read files

When you encounter an
image you want to work with, it is usually in form of a file (for
example, if you down load an image from the web, it is usually stored as a JPEG
-
file). Once
we are done processing an image, we may want to write it back to a JPEG
-
file so that we can,
for e
xample, post the processed image on the web. This is done using
the

imread

and

imwrite

commands.
These commands require the Image processing tool box!

Reading and writing image files

Operation:

Matlab
command:

Read an image.


(Within the parenthesis you
type the name of the image file you wish to
read.


Put the file name within single quotes ' '.)

imread()

Write an image to a file.


(As the first argument within the parenthesis you type the name of the image
you have worked with.


As a second argument wi
thin the parenthesis you type the name of the file
imwrite( , )

and format that you want to write the image to.


Put the file name within single quotes ' '.)

Make sure to use semi
-
colon ; after these commands, otherwise you will get LOTS OF
number
scrolling on you screen... The commands

imread

and

imwrite

support the formats
given in the section "Image formats supported by Matlab" above.

Loading and saving variables in Matlab

This section explains how to load and save variables in Matlab. Once you h
ave read a file,
you probably convert it into an intensity image (a matrix) and work with this matrix. Once
you are done you may want to save the matrix representing the image in order to continue to
work with this matrix at another time. This is easily do
ne using the commands

save

and

load.
Note thatsave

and

load

are commonly used Matlab commands, and works independently of
what tool boxes that are installed.

Loading and saving variables

Operation:

Matlab command:

Save the variable

X

.

save X

Load the
variable

X

.

load X

Examples

In the first example we will down load an image from the web, read it into Matlab,
investigate its format and save the matrix representing the image.

Example 1.

Down load the following image (by clicking on the image using the

right mouse button) and
save the file as

cell1.jpg.

This is an
image of a cell
taken by an
electron
microscope at
the
Department of
Molecular,
Cellular and
Developmenta
l Biology at
CU.


Now open Matlab and make sure you are in the same directory as your

stored file. (You can
check what files your directory contains by typing

ls

at the Matlab prompt. You change
directory using the command

cd.) Now type in the following commands and see what each
command does. (Of course, you do not have to type in the com
ments given in the code after
the%

signs.)


I=imread('cell1.jpg'); % Load the image file and store it as the variable I.


whos % Type "whos" in order to find out the size and class of all stored variables.


save I % Save the variable I.


ls % List the file
s in your directory.


% There should now be a file named "I.mat" in you directory


% containing your variable I.


Note that all variables that you save in Matlab usually get the suffix

.mat.

Next we will see that we can display an image using the
command

imshow. This command
requires the image processing tool box. Commands for displaying images will be explained in
more detail in the section "How to display images in Matlab" below.


clear % Clear Matlab's memory.


load I % Load the variable I that
we saved above.


whos % Check that it was indeed loaded.


imshow(I) % Display the image


I=im2double(I); % Convert the variable into double.


whos % Check that the variable indeed was converted into double


% The next procedure cuts out the upper left corn
er of the image


% and stores the reduced image as Ired.


for i=1:256

for j=1:256

Ired(i,j)=I(i,j);

end

end


whos % Check what variables you now have stored.


imshow(Ired) % Display the reduced image.


Example 2

Go to the

CU home page

and down load the image of campus with the Rockies in the
background. Save the image as

pic
-
home.jpg

Next, do the following in Matlab. (Make sure you are in the same directory as your image
file).


clear


A=imread('pic
-
home.jpg');


whos


imshow(A)


Note that when you typed

whos

it probably said that the size was

300x504x3. This means that
the image was loaded as an RGB image (see the section "RGB image above"). However, in
this course we will mostly work
with gray scale images, so let us convert it into a gray scale
(or "intensity") image.


A=rgb2gray(A); % Convert to gray scale


whos


imshow(A)


Now the size indicates that our image is nothing else than a regular matrix.

Note: In other cases when you dow
n load a color image and type

whos

you might see that
there is one matrix corresponding to the image size and one matrix called

map

stored in
Matlab. In that case, you have loaded an indexed image (see section above). In order to
convert the indexed image
into an intensity (gray scale) image, use the

ind2gray

command
described in the section "How to convert between different formats" above.

How to display an image in Matlab

Here are a couple of basic Matlab commands (do not require any tool box) for display
ing an
image.

Displaying an image given on matrix form

Operation:

Matlab command:

Display an image represented as the matrix

X.

imagesc(X)

Adjust the brightness. s is a parameter such that


-
1<s<0 gives a darker image, 0<s<1 gives a brighter image.

brighten(s)

Change the colors to gray.

colormap(gray)

Sometimes your image may not be displayed in gray scale even though you might have
converted it into a gray scale image. You can then use the command

colormap(gray)

to
"force" Matlab to use a gray
scale when displaying an image.

If you are using Matlab with an Image processing tool box installed, I recommend you to use
the command

imshow

to display an image.

Displaying an image given on matrix form (with image processing tool box)

Operation:

Matlab command:

Display an image represented as the matrix

X.

imshow(X)

Zoom in (using the left and right mouse button).

zoom on

Turn off the zoom function.

zoom off




Analysis



Objective of Project



In this Project we are using an
analog image and than converted into the digital image and
than proceed by matlab tool

Requirement Gathering

In our project we are using the following matlab tools for digitalizing and processing an
image

List of the Matlab tools are given blow

1.

M
-
Files

2.

Operators

3.

Flow Control

4.

Code Optimization

5.

InteractiveRepresentation and Description

6.

Some Additional MATLAB and IPT Functions Used


7.

Some Basic Utility M
-
Functions 433


x Contents


8.

Chain Codes

9.

Polygonal Approximations Using Minimum
-
Perimeter


Po
lygons

10.

Shape Numbers

11.

Descriptors 463


11.4.1 Function

12.

Statistical Moments

13.

Fourier Descriptors

14.

Object Recognition

15.

Working with Strings in MATLAB

16.

Distance Measures in MATLAB

17.

Computing

18.

Forming Pattern Vectors

19.

Recognition Based on Decision
-
Theoretic Methods

20.

Representation and Description

21.

Some Additional MATLAB and IPT Functions Used


22.

Some Basic Utility M
-
Functions 433


x Contents


23.

Chain Codes

24.

Polygonal Approximations Using Minimum
-
Perimeter


Polygons

25.

Shape Numbers

26.

Descriptors 463


11.4.1 Function

27.

Statistical Moments

28.

Fourier Descriptors

29.

Object Recognition

30.

Working with Strings in MATLAB

31.

Distance Measures in MATLAB

32.

Computing

33.

Forming Pattern Vectors

34.

Recognition Based on Decision
-
Theoretic Methods

35.

Representation and Description

36.

Some Additional MATLAB and IPT Functions Used


37.

Some Basic Utility M
-
Functions 433


x Contents


38.

Chain Codes

39.

Polygonal Approximations Using Minimum
-
Perimeter


Polygons

40.

Shape Numbers

41.

Descriptors 463


11.4.1 Function

42.

Statistical Moments

43.

Fourier Descriptors

44.

Object Recognition

45.

Working with Strings in MATLAB

46.

Distance Measures in MATLAB

47.

Computing

48.

Forming Pattern Vectors

49.

Recognition Based on Decision
-
Theoretic Methods

50.

Representation and Description

51.

Some Additional
MATLAB and IPT Functions Used


52.

Some Basic Utility M
-
Functions 433


x Contents


53.

Chain Codes

54.

Polygonal Approximations Using Minimum
-
Perimeter


Polygons

55.

Shape Numbers

56.

Descriptors 463


11.4.1 Function

57.

Statistical Moments

58.

Fourier Descriptors

59.

Object Recognition

60.

Working with Strings in MATLAB

61.

Distance Measures in MATLAB

62.

Computing

63.

Forming Pattern Vectors

64.

Recognition Based on Decision
-
Theoretic Methods


65.

2 Logarithmic and Contrast
-
Stretching Transformations

66.

Generating and Plotting Image Histo
grams

67.

Histogram Equalization

68.

Obtaining Frequency Domain Filters from Spatial Filters

69.

Spatial Filtering

70.

Linear Spatial Filtering

71.

Nonlinear Spatial Filtering

72.

Image Processing Toolbox Standard Spatial Filters

73.

Linear Spatial Filters

74.

Nonlinear Spatial F
ilters

75.

Freque

76.

Preview Computing and Visualizing the 2
-
D DFT in MATLAB

77.

An M
-
function for Filtering in the Frequency Domain

78.

Histogram Matching (Specification)

79.

Restoration in the Presence of Noise Only

Spatial Filtering

80.

High
-
Frequency Emphasis Filtering

81.

5 Image Restoration

82.

Model of the Image Degradation/Restoration Process

83.

Lowpass Frequency Domain Filters 129


4.5.3 Wireframe and Surface Plotting

84.

Modeling the Degradation Function

85.

Direct Inverse Filtering

86.

Constrained Least Squares (Regularized) Filtering

87.

Using the Lucy
-
Richardson


Algorithm

88.

Iterative Nonlinear Restoration

89.

10.4.1 Basic Formulation 407



90.

Segmentation Using the Watershed Transform

91.

-
Controlled Watershed Segmentation

92.

Summary 425



93.

Region Sp
litting and Merging

94.

Representation and Description

95.

Some Additional MATLAB and IPT Functions Used


96.

Some Basic Utility M
-
Functions 433


x Contents


97.

Chain Codes

98.

Polygonal Approximations Using Minimum
-
Perimeter


Polygons

99.

Representation and Description

100.

Som
e Additional MATLAB and IPT Functions Used


101.

Some Basic Utility M
-
Functions 433


x Contents


102.

Chain Codes

103.

Polygonal Approximations Using Minimum
-
Perimeter


Polygons

104.

Shape Numbers

105.

Descriptors 463


11.4.1 Function

106.

Statistical Moments

107.

Fourier Descriptors

108.

Representation and Description

109.

Some Additional MATLAB and IPT Functions Used


110.

Some Basic Utility M
-
Functions 433


x Contents


111.

Chain Codes

112.

Polygonal Approximations Using Minimum
-
Perimeter


Polygons

113.

Shape Numbers

114.

Descriptors 463


11.4.1 Function

115.

Statist
ical Moments

116.

Fourier Descriptors

117.

Object Recognition



Design and simulate signal processing systems


Signal Processing Blockset™ provides algorithms and tools for the design and simulation of
signal processing

systems. You can develop DSP algorithms for

speech and audio processing, radar tracking,
baseband

communications, and other applications. Most algorithms and tools are available as both
System objects (for use

in MATLAB®) and blocks (for use in Simulink®).

The blockset provides techniques for FFTs,

FIR and IIR digital filtering, spectral estimation,
statistical and linear

algebra computations, streaming, and multirate processing. It also includes signal generators,
interactive scopes,

spectrum analyzers, and other tools for visualizing signals and
simulation results.

You can use the blockset to develop and validate real
-
time signal processing systems. For
embedded system design

and rapid prototyping, the blockset supports fixed
-
point arithmetic, C
-
code generation, and
implementation on

embedded hard
ware.

Key Features



Simulation of streaming, frame
-
based, and multirate systems



System objects for use in MATLAB and blocks for use in Simulink



Algorithms for FFT and other transforms, spectral estimation, windowing, signal statistics,
and linear alge
bra



Design and realization architectures for FIR, IIR, multirate, and LMS and RMS adaptive
filters



Signal generators and I/O support for multimedia files and devices, including multichannel
audio



Fixed
-
point data type modeling and bit
-
true simulation



Support for automatic C
-
code generation

1


Software Requirement

OVERVIEW OF LANGUAGE USED

About J2EE & Microsoft Access

JAVA

Java is a small, simple, safe, object oriented, interpreted or dynamically optimized, byte
coded, architectural, garbage
collected, multithreaded programming language with a strongly
typed exception
-
handling for writing distributed and dynamically extensible programs.

Java is an object oriented programming language. Java is a high
-
level, third generation
language like C, FOR
TRAN, Small talk, Pearl and many others. You can use java to write
computer applications that crunch numbers, process words, play games, store data or do any
of the thousands of other things computer software can do.

Special programs called applets that ca
n be downloaded from the internet and played safely
within a web browser. Java a supports this application and the follow features make it one of
the best programming language.



It is simple and object oriented



It helps to create user friendly interfaces.



It is very dynamic.



It supports multithreading.



It is platform independent



It is highly secure and robust.



It supports internet programming

Java

is a programming language originally developed by Sun Microsystems and released in 1995 as a
core component of
Sun's Java platform. The language derives much of its syntax from C and C++ but
has a simpler object model and fewer low
-
level facilities. Java applications are typically compiled to
byte code which can run on any Java virtual machine (JVM) regardless of c
omputer architecture.

The original and reference implementation Java compilers, virtual machines, and class libraries were
developed by Sun from 1995. As of May 2007, in compliance with the specifications of the Java
Community Process, Sun made available m
ost of their Java technologies as free software under the
GNU General Public License. Others have also developed alternative implementations of these Sun
technologies, such as the GNU Compiler for Java and GNU Classpath.



The Java language was created by

James Gosling in June 1991 for use in a set top box
project. The language was initially called
Oak
, after an oak tree that stood outside Gosling's office
-

and also went by the name
Green

-

and ended up later being renamed to
Java
, from a list of random
w
ords. Gosling's goals were to implement a virtual machine and a language that had a familiar C/C++
style of notation.

Primary goals

There were five primary goals in the creation of the Java language:

1.

It should use the object
-
oriented programming
methodology.

2.

It should allow the same program to be executed on multiple operating systems.

3.

It should contain built
-
in support for using computer networks.

4.

It should be designed to execute code from remote sources securely.

5.

It should be easy to use by sele
cting what were considered the good parts of other object
-
oriented languages.


The
Java platform

is the name for a bundle of related programs, or platform, from Sun which allow
for developing and running programs written in the Java programming language. T
he platform is not
specific to any one processor or operating system, but rather an execution engine (called a virtual
machine) and a compiler with a set of standard libraries which are implemented for various
hardware and operating systems so that Java pr
ograms can run identically on all of them.

Different "editions" of the platform are available, including:



Java ME (Micro Edition): Specifies several different sets of libraries (known as profiles) for
devices which are sufficiently limited that supplying
the full set of Java libraries would take
up unacceptably large amounts of storage.



Java SE (Standard Edition): For general purpose use on desktop PCs, servers and similar
devices.



Java EE (Enterprise Edition): Java SE plus various APIs useful for multi
-
ti
er client
-
server
enterprise applications.





The Java Platform consists of several programs, each of which provides a distinct
portion of its overall capabilities. For example, the Java compiler, which converts Java source code
in
to Java bytecode (an intermediate language for the Java Virtual Machine (JVM)), is provided as part
of the Java Development Kit (JDK). The sophisticated Java Runtime Environment (JRE),
complementing the JVM with a just
-
in
-
time (JIT) compiler, converts inte
rmediate bytecode into
native machine code on the fly. Also supplied are extensive libraries (pre
-
compiled into Java
bytecode) containing reusable code, as well as numerous ways for Java applications to be deployed,
including being embedded in a web page a
s an applet. There are several other components, some
available only in certain editions.



The essential components in the platform are the Java language compiler, the
libraries, and the runtime environment in which Java intermediate bytecode "executes" a
ccording to
the rules laid out in the virtual machine specification.




Java Virtual Machine



The heart of the Java Platform is the concept of a "virtual machine" that executes
Java bytecode programs. This bytecode is the same no matter what hardware or
operating
system the program is running under. There is a JIT compiler within the
Java Virtual
Machine
, or JVM. The JIT compiler translates the Java bytecode into native processor
instructions at run
-
time and caches the native code in memory during executi
on.




The use of bytecode as an intermediate language permits Java
programs to run on any platform that has a virtual machine available. The use of a JIT
compiler means that Ja
va applications, after a short delay during loading and once they have
"warmed up" by being all or mostly JIT
-
compiled, tend to run about as fast as native
programs. Since JRE version 1.2, Sun's JVM implementation has included a just
-
in
-
time
compiler inste
ad of an interpreter.





Although Java programs are Platform Independent, the code of the
Java Virtual Machine (JVM) that execute these programs are not. Every Operating System
has its own JVM.


Class libraries



In most modern operating systems, a large body of reusable code is provided
to simplify the programmer's job. This code is typically provided as a set of dynamically
loadable libraries that applications can call at runtime. Because the Java Platform is not

dependent on any specific operating system, applications cannot rely on any of the existing
libraries. Instead, the Java Platform provides a comprehensive set of standard class libraries,
containing much of the same reusable functions commonly found in mo
dern operating
systems.






The Java class libraries serve three purposes within the Java Platform. Like
other standard code libraries, they provide the programmer a well
-
known set of functions to
perform common tasks, such as
maintaining lists of items or performing complex string
parsing. In addition, the class libraries provide an abstract interface to tasks that would
normally depend heavily on the hardware and operating system. Tasks such as network
access and file access a
re often heavily dependent on the native capabilities of the platform.
The Java java.net and java.io libraries implement the required native code internally, then
provide a standard interface for the Java applications to perform those tasks. Finally, when
some underlying platform does not support all of the features a Java application expects, the
class libraries can either emulate those features using whatever is available, or at least
provide a consistent way to check for the presence of a specific featur
e.

Platform independence

One characteristic, platform independence, means that programs written in the Java language must
run similarly on any supported hardware/operating
-
system platform. One should be able to write a
program once, compile it once, and ru
n it anywhere.

This is achieved by most Java compilers by compiling the Java language code
halfway

(to Java
bytecode)


simplified machine instructions specific to the Java platform. The code is then run on a
virtual machine (VM), a program written in nati
ve code on the host hardware that interprets and
executes generic Java bytecode. (In some JVM versions, bytecode can also be compiled to native
code, either before or during program execution, resulting in faster execution.) Further,
standardized libraries

are provided to allow access to features of the host machines (such as
graphics, threading and networking) in unified ways. Note that, although there is an explicit
compiling stage, at some point, the Java bytecode is interpreted or converted to native ma
chine
code by the JIT compiler.


The first implementations of the language used an interpreted virtual machine to achieve portability.
These implementations produced programs that ran more slowly than programs compiled to native
executables, for instance
written in C or C++, so the language suffered a reputation for poor
performance. More recent JVM implementations produce programs that run significantly faster than
before, using multiple techniques.


One technique, known as
just
-
in
-
time compilation

(JIT),

translates the Java bytecode into native code
at the time that the program is run, which results in a program that executes faster than interpreted
code but also incurs compilation overhead during execution. More sophisticated VMs use
dynamic
recompilatio
n
, in which the VM can analyze the behavior of the running program and selectively
recompile and optimize critical parts of the program. Dynamic recompilation can achieve
optimizations superior to static compilation because the dynamic compiler can base op
timizations
on knowledge about the runtime environment and the set of loaded classes, and can identify the
hot
spots

(parts of the program, often inner loops, that take up the most execution time). JIT
compilation and dynamic recompilation allow Java progr
ams to take advantage of the speed of
native code without losing portability.


Another technique, commonly known as
static compilation
, is to compile directly into native code
like a more traditional compiler. Static Java compilers, such as GCJ, translate
the Java language code
to native object code, removing the intermediate bytecode stage. This achieves good performance
compared to interpretation, but at the expense of portability; the output of these compilers can only
be run on a single architecture. So
me see avoiding the VM in this manner as defeating the point of
developing in Java; however it can be useful to provide both a generic bytecode version, as well as
an optimised native code version of an application.




Automatic memory management


One of t
he ideas behind Java's automatic memory management model is that programmers be
spared the burden of having to perform manual memory management. In some languages the
programmer allocates memory for the creation of objects stored on the heap and the respon
sibility
of later deal locating that memory also resides with the programmer. If the programmer forgets to
deallocate memory or writes code that fails to do so, a memory leak occurs and the program can
consume an arbitrarily large amount of memory. Additio
nally, if the program attempts to deallocate
the region of memory more than once, the result is undefined and the program may become
unstable and may crash. Finally, in non garbage collected environments, there is a certain degree of
overhead and complexit
y of user
-
code to track and finalize allocations. Often developers may box
themselves into certain designs to provide reasonable assurances that memory leaks will not occur.


In Java, this potential problem is avoided by automatic garbage collection. The p
rogrammer
determines when objects are created, and the Java runtime is responsible for managing the object's
lifecycle. The program or other objects can reference an object by holding a reference to it (which,
from a low
-
level point of view, is its address

on the heap). When no references to an object remain,
the Java garbage collector automatically deletes the unreachable object, freeing memory and
preventing a memory leak. Memory leaks may still occur if a programmer's code holds a reference to
an object
that is no longer needed

in other words, they can still occur but at higher conceptual
levels.

The use of garbage collection in a language can also affect programming paradigms. If, for example,
the developer assumes that the cost of memory allocation/reco
llection is low, they may choose to
more freely construct objects instead of pre
-
initializing, holding and reusing them. With the small
cost of potential performance penalties (inner
-
loop construction of large/complex objects), this
facilitates thread
-
isol
ation (no need to synchronize as different threads work on different object
instances) and data
-
hiding. The use of transient immutable value
-
objects minimizes side
-
effect
programming.

Comparing Java and C++, it is possible in C++ to implement similar funct
ionality (for example, a
memory management model for specific classes can be designed in C++ to improve speed and lower
memory fragmentation considerably), with the possible cost of adding comparable runtime
overhead to that of Java's garbage collector, an
d of added development time and application
complexity if one favors manual implementation over using an existing third
-
party library. In Java,
garbage collection is built
-
in and virtually invisible to the developer. That is, developers may have no
notion
of when garbage collection will take place as it may not necessarily correlate with any actions
being explicitly performed by the code they write. Depending on intended application, this can be
beneficial or disadvantageous: the programmer is freed from pe
rforming low
-
level tasks, but at the
same time loses the option of writing lower level code. Additionally, the garbage collection capability
demands some attention to tuning the JVM, as large heaps will cause apparently random stalls in
performance.

Java d
oes not support pointer arithmetic as is supported in, for example, C++. This is because the
garbage collector may relocate referenced objects, invalidating such pointers. Another reason that
Java forbids this is that type safety and security can no longer

be guaranteed if arbitrary
manipulation of pointers is allowed.


Performance



Java's performance has improved substantially since the early versions, and
performance of JIT compilers relative to native compilers has in some tests been shown to
be quite
similar. The performance of the compilers does not necessarily indicate the performance of the
compiled code; only careful testing can reveal the true performance issues in any system.


Java Runtime Environment




The Java Runtime Environment, or
JRE
, is the software required to run any
application deployed on the Java Platform. End
-
users commonly use a JRE in software packages and
Web browser plugins. Sun also distributes a superset of the JRE called the Java 2 SDK (more
commonly known as the JDK)
, which includes development tools such as the Java compiler, Javadoc,
Jar and debugger.


One of the unique advantages of the concept of a runtime engine is that errors (exceptions) should
not 'crash' the system. Moreover, in runtime engine environments
such as Java there exist tools that
attach to the runtime engine and every time that an exception of interest occurs they record
debugging information that existed in memory at the time the exception was thrown (stack and
heap values). These Automated Exce
ption Handling tools provide 'root
-
cause' information for
exceptions in Java programs that run in production, testing or development environments.



TECHNOLOGY SPECIFICATIONS



Java Platform, Enterprise Edition (Java EE) builds on the solid foundation of
Java Platform, Standard
Edition (Java SE) and is the industry standard for implementing enterprise
-
class service
-
oriented
architecture (SOA) and next
-
generation web applications.

Java Platform, Enterprise Edition (Java EE)
is a set of coordinated technolog
ies that significantly reduces the cost and complexity of developing,
deploying, and managing multitier, server
-
centric applications. Building on the Java Platform,
Standard Edition (Java SE), Java EE adds the capabilities that provide a complete, stable,
secure, and
fast Java platform for the enterprise.



Java 2 Enterprise Edition (J2EE) technology is becoming a pervasive platform for the development
of Internet
-
based, transactional business applications. It provides a robust development platform
upon wh
ich to build flexible, reusable components and applications. It is a powerful standard that is
well
-
suited for Internet
-
based applications because it provides many of the underlying services such
as HTTP request processing (Java Servlet API), transaction m
anagement (Enterprise JavaBeans), and
messaging (Java Message Service), just to name a few. However, J2EE is also a complex and changing
standard that leaves the technologist with many design decisions and performance considerations.
Each component service

adds a level of overhead to the application processing that must be
considered. Additionally, there are a number of common business logic functions, such as error
handling, that must be designed and de developed for each component and application. An
appl
ication development effort using J2EE should give careful consideration to the services provided
by the platform and how application components can best utilize them. There are a number of best
practices one should consider in order to be highly effective
in building J2EE components and
integrating them into applications. These practices include evaluating and selecting the right set of
software components and services to do the job. This is no different than in other professions; a
carpenter or a steelwork
er both use an architecture plan to build things, although the tools they use
to do so are quite different. A scalable, modular architecture built upon J2EE will likely comprise a
selection of the appropriate set of J2EE services combined with a custom fou
ndation of common
business logic functions.


OVERVIEW OF J2EE


Today more and more developments want to write distributed transactional applications for the
enterprise and leverage the speed, security and reliability of server side technology. J2EE is a
pl
atform independent, java centric environment from sun for developing, building and deploying
web based enterprise application online. The J2EE platform consists of a set of services, API’s and
protocols that provide functionality for developing multitiered

web based application.


At the client side tier, J2EE supports pure HTML as well as java applets or applications. It relies on JSP
and Servlet codes to create HTML or other formatted data for the client. EJB provide another layer
where the platform’s logi
c is stored. An EJB server provides functions such as threading,
concurrency, security and memory management. To reduce costs and fast
-
track enterprise
application design and development, the java2 platform, Enterprise edition (J2EE) technology
provides a
component
-
based approach to the design, development, assembly and distributed
application model, the ability to reuse components, integrated Extensible Markup Language (XML)
based data interchange, a unified security model, and flexible transaction control
.




DISTRIBUTED MULTI TIERED APPLICATIONS


The J2EE platform uses a multi tiered distributed application model. Application logic is
divided into components according to function, and the various application components that
make up a J2EE application
are installed on different machines depending on the tier in the multi
tiered J2EE environment to which the application component belongs. The figure shown below
shows two multi tiered j2EE applications divided into the tiers described in the following lis
t. The
J2EE application parts shown in Figure



Client
-
tier components run on the client machine.



Web
-
tier components run on the J2EE server.



Business
-
tier components run on the J2EE server. Enterprise

information system (EIS)
-
tier software runs the EIS server.




















Database

Application Client

Dynamic HTML
Pages

JSP Pages

Enterprise
Beans

Enterprise
Beans

Database

J2EE Application1

J2EE Application2

Client tier

Web Tier

Business
Tier

EIS
Tier

Client

Machine

J2EE

Server

Machine

Database

Server



J2EE COMPONENTS



J2EE applications are made up of components. A J2EE component is a self
-
contained
functional software unit that is assembled into a J2EE application with its related classes and files
and that following J2EE components: Application clients and applets

are components that run on
the client.




Java Servlet and Java Server Pages (JSP) technology components are Web components
that run on the server.



Enterprise Java Beans (EJB) components are business components that run on the server.

J2EE components are wr
itten in the java programming language and are compiled in the same
way as any program in the language. The difference between J2EE components and standard
java classes is that J2EE components are assembled into a J2EE application. Verified to be well
form
ed and in compliance with managed by the J2EE server.


J2EE CONTAINERS



Normally, thin
-
client multi tiered applications are hard to write because they involve many
lines of intricate code to handle transaction and state management, multithreading, res
ource
pooling, and other complex low
-
level details. The component
-
based and platform
-
independent
J2EE architecture makes J2EE applications easy to write because business logic is organized into
reusable components. In addition, the J2EE server provides und
erlying services in the form of a
container for every component type. Because you do not have to develop these services
yourself, you are free to concentrate on solving the business problem at hand.

Containers provide the runtime support for J2EE applicati
on components.

Containers provide a federated view of the underlying J2EE APIs to the application components.
J2EE application components never interact directly with other J2EE application components.
They use the protocols and methods of the container fo
r interacting with each other and with
platform services. Interposing a container between the application components and the J2EE
services allows the container to transparently inject the services defined by the components
deployment descriptors, such as d
eclarative transaction management, security checks, resource
pooling, and state management. A typical J2EE product will provide a container for each
application component type: application client container, applet container, web component
container, and en
terprise bean container.


Figure: J2EE Server and Containers











J2EE SERVER



It is a runtime portion of a J2EE product. A J2EE server provides EJB and Web containers. The
component
-
based and platform
-
independent J2EE architecture makes J2EE applications easy to
write bec
ause business logic is organized into reusable components and the J2EE server provides
underlying services in the form of a container for every component type.

CONTAINERS AND SERVICES



Components are installed in their containers during deployment and

are the interface
between a component and the low
-
level platform
-
specific functionality that supports the
component. Before a web, enterprise bean, or application client component can be executed, it
must be assembled onto a J2EE application and deployed
into its container. The assembly
process involves specifying container settings for each component in the J2EE application and for
the J2EE application itself. Container settings customize the underlying support provided by the
J2EE Server, which include s
ervices such as security, transaction management, Java Naming and
Directory Interface (JNDI) lookups, and remote connectivity. Here are some of the highlights:


Browser

Application
Client

Application
client container

J2EE Server

Servlet

JSP Page

Web Container

Enterprise
Bean

EJB Container

Enterprise
Bean

Database

Client Machine



The J2EE security model lets you configure a web component or enterprise bean so
system
resources are accessed only by authorized users.



The J2EE transaction model lets you specify relationships among methods that make up a
single transaction so all methods in one transaction are treated as a single unit.



JNDI lookup services provide a unifie
d interface to multiple naming and directory
services in the enterprise so application components can access naming and directory
services.



The J2EE remote connectivity model manages low
-
level communications between clients
and enterprise beans. After an e
nterprise bean is created, a client invokes methods on it as
if it were in the same virtual machine.









J2EE PLATFORM ROLES



The J2EE platform also defines a number of distinct roles that are performed during the
application development and deployment life cycle:




The product provider designs and offers the J2EE platform, APIs, and other features that are
defined in the J2E
E specification for purchase.



The tool provider offers tools that are used for the development and packaging of
application components as part of the J2EE specifications.



The application component provider creates Web components, enterprise beans, applet
s, or
application clients to use in J2EE applications.



The application assembler takes a set of components that are developed by component
providers and assembles them in the form of an enterprise archive (EAR) file.



The deployer is responsible for deploying an enterprise application into a specific
operational environment that corresponds to a J2EE platform product.



The system administrator is responsible for the operational environment in which the
application runs.




Product providers and tool providers have a product focus. Application component providers
and application assemblers focus on the application. Deployers and system administrators focus
on providing the J2EE application with platform
-
specific artif
acts, and on the platform run time.



These roles help identify the tasks and people involved. Understanding this separation of
roles is important because it helps to determine the approach when developing and deploying
J2EE applications.


J2EE BENEFIT
S



The J2EE specification provides customers a standard which can be used to ensure investment
protection when purchasing or developing applications. Comprehensive, independent Compatibility
Test Suites ensure vendor compliance with J2EE



Digital ima
ge processing focuses on two major tasks:



Improvement of pictorial information for human interpretation.



Processing of image data for storage, transmission and representation for autonomous
machine perception



Application Areas of Image Processing

1)

Television

2)

Signal Processing

3)

Satellite Image Processing

4)

Medical Image Processing

5)

Robot Control

6)

Visual Communications

7)

LawEnforcement


CONCLUSION:

Digital image processing has become a vast domain of modern signal technologies. Its
applications pass far beyond simple aesthetical considerations, and they include medical
imagery, television and multimedia signals, security, portable digital

devices, video compression,
and even digital movies. We have been flying over some elementary notions in image processing
but there is yet a lot more to explore.

Pattern recognition is the research area that studies the operation and design of systems th
at
recognize patterns in data. It encloses subdisciplines like discriminant analysis, feature
extraction, error estimation, cluster analysis, grammatical inference and parsing. Important
application areas are image analysis, character recognition, speech a
nalysis, man and machine
diagnostics, person identification and industrial inspection.

References:



Digital Image Processing 2nd Edition Rafael C. Gonzalez Richard E. Woods .



Duda, Heart: Pattern Classification and Scene Analysis. J. Wiley & Sons, New
York, 1982.


(2nd edition

2000).