.: Click here to download :.

We propose a biometric face recognition system based on local features. Informative feature locations in the face image are located by Gabor filters, which gives us an automatic system that is not dependent on accurate detection of facial features. The feature locations are typically located at positions with high information content (such as facial features), and at each of these positions we extract a feature vector consisting of Gabor coefficients.

Index Terms: face, recognition, Gabor filters, Gabor filtering, local features, Gabor coefficients, face matching, face recognition, face verification, feature vector.

		Figure 1. Facial image
A simple and effective source code for Face Recognition Based on Local Features. All tests were performed on AT&T database.
	Demo code (protected P-files) available for performance evaluation. Matlab Image Processing Toolbox is required.
Release	Date		Major features
1.0	2005.12.27		Face recognition based on local features User-friendly GUI Features localization by Gabor filters Facial features detection Demo code (protected P-files) available for performance evaluation
We recommend to check the secure connection to PayPal, in order to avoid any fraud. This donation has to be considered an encouragement to improve the code itself.
	Face Recognition Based on Local Features – Release 1.0 – Click here for your donation. In order to obtain the source code you have to pay a little sum of money: 49 EUROS (less than 68,6 U.S. Dollars).
Once you have done this, please email us luigi.rosa@tiscali.it As soon as possible (in a few days) you will receive our new release of Face Recognition Based on Local Features. Alternatively, you can bestow using our banking coordinates: Name : Luigi Rosa Address : Via Centrale 35 67042 L’Aquila Italy Bank name: Poste Italiane Bank address: Viale Europa 190 00144 Roma Italy IBAN (International Bank Account Number) : IT-50-V-07601-03600-000058177916 BIC (Bank Identifier Code) : BPPIITRRXXX

The authors have no relationship or partnership with The Mathworks. All the code provided is written in Matlab language (M-files and/or M-functions), with no dll or other protected parts of code (P-files or executables). The code was developed with Matlab 14 SP1. Matlab Image Processing Toolbox is required. The code provided has to be considered “as is” and it is without any kind of warranty. The authors deny any kind of warranty concerning the code as well as any kind of responsibility for problems and damages which may be caused by the use of the code itself including all parts of the source code.

Contents

• Intro
• Code Aster
• ELMER
• Calculix
• More

This post shows a few interesting (and free) solutions structural engineers may find useful.

The common structural softwares for FEM analysis like Ansys, Abaqus, Nastran,etc.. have a license cost from 20′000 up to more than 100′000. If you are not a worker inside a great company or if you are not rich, you can not afford that.

Today on the web there are several free solutions, some of them have great potential, almost like commercial utilities. They are just a little harder to use, they are not the kind of user friendly softwares.

A complete list of the packages can be found here:  http://en.wikipedia.org/wiki/List_of_finite_element_software_packages

A first attempt to link all fem free utilities into a single operating system has been made by J, Cugnoni with his Caelinux. Caelinux is an ubuntu linux version that contains many free fem utilities. Unfortunately the current version is the old ubuntu 9 and it can gives drivers issues with modern machines. Anyway all the packages in Caelinux can be installed on most linux platforms.

I report here my review about the 3 softwares that I consider  a good trade-off between usability/perfomances and capabilities.

www.code-aster.org/

Code_Aster is an Open Source software package for Civil and Structural Engineering finite element analysis and numeric simulation in structural mechanics originally developed as an in-house application by the French company EDF. It was released as free software under the terms of the GNU General Public License, in October 2001.

Code aster can be compiled both on windows and linux, but since it can be integrated with the cad utility SALOME, it is better to use it on linux. A complete integrated package called SAlOME-MECA can be downloaded here: http://www.code-aster.org/V2/spip.php?article303

Code Aster is suitable for very complicated termo-mechanical analysis: it can take into account plasticity, non linear geometry, material state exchange, cracking and creep.

Unfortunately it take some time to learn how to use code aster. The solver takes as main input a python script that defines the kind of analysis , boundary conditions, time steps etc. To write this file is necessary a basic knowledge of FEM algorithms. A few samples for typical analysis are available on the web. The python library to write the input file is enormous and most of the doc is in french, this can be painful for someone. Two main utilities to simplify the Code_Aster input process are available: EFICAS that helps writing the input file and ASTK a job manager server.

http://www.csc.fi/english/pages/elmer

Elmer is an open source multiphysical simulation software developed by CSC. Elmer development was started 1995 in collaboration with Finnish Universities, research institutes and industry.

Elmer includes physical models of fluid dynamics, structural mechanics, electromagnetics, heat transfer and acoustics, for example. These are described by partial differential equations which Elmer solves by the Finite Element Method (FEM)

Among the three elmer is simplest to use. A nice GUI guides the user trough all the fem model construction. It also has a mesh package even if it doesn’t allow for many editings. With elmer is just so easy to realize multiphisics anaisys. It also has a good built-in material library that turn out to be very useful. An interactive post-processing tools allows to visualize results.

http://www.calculix.de/

CalculiX is a package designed to solve field problems. The method used is the finite element method.

With CalculiX Finite Element Models can be build, calculated and post-processed. The pre- and post-processor is an interactive 3D-tool using the openGL API. The solver is able to do linear and non-linear calculations. Static, dynamic and thermal solutions are available. Both programs can be used independently. Because the solver makes use of the abaqus input format it is possible to use commercial pre-processors as well. In turn the pre-processor is able to write mesh related data for nastran, abaqus, ansys, code-aster and for the free-cfd codes duns, ISAAC and OpenFOAM. A vda CAD interface is available. The program is designed to run on Unix platforms like Linux and Irix computers but also on MS-Windows.

The CalculiX package was developed by a team of enthusiasts in their raw spare time. They are employees of MTU Munich, an Aero Engine manufacturer in Germany which granted the publication.

Calculix is made by two console applications: CCX which handles the computation and CGX which handles the graphical operations. Calculix offers steady and dynamics structural and fluid analysis and has one main peculiarity: it has the same Abaqus input file syntax.

Do you use others utilities that should be included in the above list? just tell us in the comments.

.: Click here to download :.

Recognizing human gender plays an important role in many human computer interaction (HCI) areas. For example, search engines need an image filter to determine the gender of people in images from the Internet; demographic research can use gender information extracted from images to count the number of men and women entering a shopping mall or movie theater; a “smart building”might use gender for surveillance and control of access to certain areas. Besides these kinds of broad applications, gender recognition itself is an important research topic in both psychology and computer vision.

In psychology studies for HCI, the main focus is about how humans discriminate between males and females and what kind of features are more discriminative. A successful gender classification approach can boost the performance of many other applications including face recognition and smart human-computer interfaces. Despite its importance, it has received relatively little attention in the literature.

We have developed a system for facial gender recognition that is capable to extract from image most informative features using an approach based on genetic algorithms.

The code has been tested with Stanford Medical Student Face Database achieving an excellent recognition rate of 93.60% (200 female images and 200 male images, 90% used for training and 10% used for testing, hence there are 360 training images and 40 test images in total randomly selected and no overlap exists between the training and test images).

Index Terms: Matlab, source, code, gender, recognition, male, female, genetic, algorithm, algorithms, GA.

		Figure 1. Facial image
A simple and effective source code for Gender Recognition Based on Genetic Algorithms.
	Demo code (protected P-files) available for performance evaluation. Matlab Image Processing Toolbox is required.
Release	Date		Major features
1.0	2010.05.18		Gender recognition using genetic algorithms High recognition rate Fast and optimized implementation Easy and intuitive GUI Demo code (protected P-files) available for performance evaluation
We recommend to check the secure connection to PayPal, in order to avoid any fraud. This donation has to be considered an encouragement to improve the code itself.
	Gender Recognition Based on Genetic Algorithms – Click here for your donation. In order to obtain the source code you have to pay a little sum of money: 200 EUROS (less than 280 U.S. Dollars).
Once you have done this, please email us luigi.rosa@tiscali.it As soon as possible (in a few days) you will receive our new release of Gender Recognition Based on Genetic Algorithms. Alternatively, you can bestow using our banking coordinates: Name : Luigi Rosa Address : Via Centrale 35 67042 L’Aquila Italy Bank name: Poste Italiane Bank address: Viale Europa 190 00144 Roma Italy IBAN (International Bank Account Number) : IT-50-V-07601-03600-000058177916 BIC (Bank Identifier Code) : BPPIITRRXXX

The authors have no relationship or partnership with The Mathworks. All the code provided is written in Matlab language (M-files and/or M-functions), with no dll or other protected parts of code (P-files or executables). The code was developed with Matlab 2006a. Matlab Image Processing Toolbox is required. The code provided has to be considered “as is” and it is without any kind of warranty. The authors deny any kind of warranty concerning the code as well as any kind of responsibility for problems and damages which may be caused by the use of the code itself including all parts of the source code.

by Matt Dunham

Intro

Matlab code is very flexible, particularly with respect to its dynamic typing, however, this can also lead to enormous headaches when it comes time to debug a crashing program. You may have overwritten or misspelled an important variable without knowing it, or inadvertently expanded the size of your matrix, and Matlab will happily continue executing without warning until your program grinds to a halt. Trying to discover the original problem that started dozens of lines before or in another function is not always easy.

In this section, we describe a number of tools and techniques that can help as well as ways to assess the speed of your code and find potential bottlenecks. We finish by discussing a few stylistic points and best practices that can make your code more readable and less prone to bugs in the first place.

dbstop, dbquit, dbclear, dbstep, dbstep nlines, dbstep in, dbstep out, dbcont, dbstatus, keyboard, workspace, tic, toc, profile on, profile off, profile viewer

Matlab automatically checks for certain problems and suggests fixes as you edit your m-files. The problem code is underlined in red much like word processors underline misspelled words. It is worthwhile paying attention to these as they can often point out problems before you run your code and frequently suggest ways to speed up execution. The suggestions appear when you hover your mouse over the underlined text, and you can quickly find these spots by looking for the red markers to the right of the document. The warnings and errors M-lint warns you about can be set under File->Preferences->M-lint.

In newer versions of Matlab, you can generate a full M-lint html report by going to Tools->Save and Show M-lint Report. You can also bring up a file dependency report or compare two versions of a file from the Tools drop down menu.

If your program is crashing or displaying cryptic warnings, it is very useful to have it automatically halt execution right at the point where it ran into trouble. Select Debug –> Stop if Errors/Warnings to turn this on.

Break points can be set at any line in the document that executes code by pressing just right of the line number. A small circle will appear and will turn red when the file is saved.

These can be temporarily disabled by right clicking on them and selecting disable. To clear them all, type dbclear all or press the equivalent tool bar button.

You can set a condition on the breakpoints so that it is only triggered if a variable takes on a certain value, by right clicking on the variable and selecting ‘Set/Modify Condition’.

Once your code has stopped at a breakpoint, you can step one line at a time, continue on until the next break point, or exit debug mode completely using the tool bar buttons at the top of the editor.

The step in and step out buttons, let you enter into, or leave a function called at the current line.

There are function equivalents to these commands if you prefer, namely dbstep, dbstep nlines, dbstep in, dbstep out, dbcont, and dbquit. The dbstop() function can be used to set breakpoints and the dbstatus() function displays all of the breakpoints currently set. You can save these into a variable as in s = dbstatus(), clear the breakpoints and then reset them at a later point with dbstop(s).

When you are in debug mode, the command window prompt will look slightly different: it will have a k in front.

The keyboard() function can also be used to stop execution of a program, temporarily relinquishing control back to the command window. Simply add the line keyboard anywhere in your file to stop at that point. To return execution, type return.

Once execution has stopped because of a break point or keyboard() command, you can inspect the current values of the variables in the workspace window. Type workspace at the command prompt if it is not already open. If your program contains or calls multiple functions, you can move among the variable stacks from the top of this window, (next to where it says Stack:). This is particularly useful if your program stopped in a third party function and you want to return to your function’s stack to see what went wrong. You can also view the base workspace from here.

You can also execute commands at the command prompt while execution has stopped, and assign new values to existing variables.

Each m-file has one or more run configurations associated with it as seen in the image below. These can be used to setup tests for your function by specifying test input values and other validation code. You can reach this window by selecting Debug –> Run Configuration for yourfile.m–> Edit Run Configuration…. Add new configurations with the + button and edit the code to execute on the right. These can then be run from the Debug drop down menu or from the run button in the editor.

We have already seen the tic() and toc() functions, which can be used to time how long your code takes to run. Simply run tic() before your code and toc() after. Matlab, however, has a much more powerful framework, called profiling, which gives you a detailed report about how long was spent executing each subfunction. You can use this report to find bottlenecks that you might be able to improve.

You can turn on profiling with the profile on command and turn it off again with profile off. Once profiling is on, execute your code, and then type profile viewer to see the report.

The report shows a breakdown of all the functions called from your function, the number of times they were called, and the total time spent executing them. Self-time, denoted by a dark blue band, is the the time spent within a function not including how long was spent in functions called from here. This is really the statistic you should pay attention to.

There is a lot of Matlab code floating around and too much of it is totally unreadable. It does not have to be this way. Readable code is easier to use, maintain, debug, and extend, and can often serve to communicate your ideas, particularly when they are mathematical in nature. What makes one piece of code more readable than another is somewhat subjective, but there are fairly uncontentious and straightforward heuristics we can nevertheless employ. We describe a few here. Many of these suggestions are from Richard Johnson’s Matlab Programming Style Guidelines available here.

Matlab Style Guidelines

Taking the time to organize and layout your m-file well, can help you find bugs later and jump to the code you are looking for much faster.

Use indentation to denote scope, indenting the code in function bodies, and further indenting the code within loops, switch statements, try/catch blocks as well as nested functions.

Include spaces around operators like ||, &&, ==, etc and consider breaking long commands into multiple lines by using ellipses, (…). Keep lines to less than say 80 characters long and be consistent throughout.

Align variables and values by equal signs and commas to show parallel structure.

plot(Xequal,f(Xequal), ‘o’ ,’MarkerFaceColor’ , ‘g’…

,’MarkerEdgeColor’ , ‘k’…

,’LineWidth’       ,  2 …

,’MarkerSize’      , 10);

Matlab programmers seem to love packing as much into a single line of code as possible. When you can not think of an informative name for a temporary variable, passing values from one function directly to another via composition is not a bad approach. It is certainly better than having variables with names like temp1 and temp2 floating around. However, this approach can be taken to extremes too. If you find yourself squinting at a line of your own code, trying to decipher its purpose for more than a few seconds, consider breaking it into multiple commands.

The easiest way to make your program more readable is to document it well, however, this is no substitute for well written code, which should ’speak’ for itself. If you find yourself commenting many lines of code, consider adding greater structure, by writing subfunctions for instance. Subfunctions with well chosen names self document their behavior and help to abstract the details.

Assume programmers reading your code want to know how it actually works and will not be satisfied by assurances in the comments. Make it as easy as possible for them, (and yourself) to verify the correctness of your program.

Comments should be written directly below function headers as this is where the Matlab help functions look in calls to help() and doc(): lookfor() searches only the first line of comments in a function, and so this should be particulary concise and informative. The same applies to class definitions.

It is very important to describe the inputs and outputs to your function as well as any expectations or preconditions. Does your function work with unstandardized data, or missing values? What can the user of your function expect as output so long as the preconditions are met?

Provide examples of all of the important ways in which your function can be called. If you have 6 optional parameters, you do not have to show all 6 factorial possibilities, but include enough, (say 6), so that the user can reasonably extrapolate as to what a particular combination will do. Consider writing a separate function or script to demonstrate certain functionality in context. Separate advanced or infrequently used options and comment on these below the rest. When in doubt, follow the style of built in Matlab functions.

Consider using process_options() written by Mark Paskin, when a function takes many inputs. This allows users to call your function with the inputs specified in any order they like, preceded by a string name as in the following. myfunc(‘niterations’,3,’maxdepth’,5,’verbose,’true)

We describe _process_options in more depth here.

process_options

It should go without saying that variable names should be meaningful and informative; part of this, however, is a matter of convention. Here are some suggestions.

• Short, single letter variables should only be used in one of three cases: where the structure of the algorithm is important, as in a mathematical derivation; for local temporary variables such as loop indices; or when well defined conventions exist. In all of these cases, document their meaning through comments.
• Use lower case variable names when there is only one word, or when one of two words is very short as in isvalid, otherwise use camelCase.
• Capitalize constant variables whose values will not change.
• Prefix variables denoting a number of elements with the letter n as in nvalues for the number of values.
• Suffix variables storing indices with NDX as in dataNDX
• Prefix logical functions with is as in isfinite().
• Use i,j,k for loop variables.
• Do not use any magic numbers, i.e. constant values appearing out of nowhere. Rather, assign these values to variables with descriptive names and use these instead.
• Be consistent with pluralization for non-scalar data, i.e. pick one of value(j) or values(j) and use that convention throughout.
• Resuse variables names only when the data is related and even then, with caution. It can be very confusing when a variable you have been tracing through a program suddenly changes role.

See the section on Functions for more suggestions.

Functions

AccelerEyes is pleased to inform you that Jacket version 1.4 is now
available for download on our website.  We have placed a convenient
download button on the left side of our homepage, so feel free to try
the latest release.  Your website account has been reset so that you
can trial the new release.  The release includes full support for
NVIDIAs new FERMI architecture, a major upgrade to our compiler
technology and many new functions have been added to our function
library.  Please contact support@accelereyes.com with any issues or
questions.

You can learn about what is included in Jacket 1.4 at:
http://cts.vresp.com/c/?Accelereyes/a05d5704ce/1f38f23d82/0a5b15fc46/utm_campaign=Jacket%20for%20MATLAB%201%2E4%20is%20now%20available%21&utm_content={URIENCODE%5Bemail_address%5D}&utm_medium=Email&utm_source=VerticalResponse&utm_term=Text%20Version%20-%20Link%201

We are confident that this release of Jacket will allow a whole new
collection of applications to benefit from GPU computing and look
forward to working with you to make that a reality.

.: Click here to download :.

Speaker recognition or voice recognition is the task of recognizing people from their voices. Such systems extract features from speech, model them and use them to recognize the person from his/her voice. Speaker recognition has a history dating back some four decades, where the output of several analog filters was averaged over time for matching. Speaker recognition uses the acoustic features of speech that have been found to differ between individuals. These acoustic patterns reflect both anatomy (e.g., size and shape of the throat and mouth) and learned behavioral patterns (e.g., voice pitch, speaking style). This incorporation of learned patterns into the voice templates (the latter called “voiceprints”) has earned speaker recognition its classification as a “behavioral biometric.”

Speaker recognition systems employ three styles of spoken input: text-dependent, text-prompted and text-independent. Most speaker verification applications use text-dependent input, which involves selection and enrollment of one or more voice passwords. Text-prompted input is used whenever there is concern of imposters. The various technologies used to process and store voiceprints includes hidden Markov models, pattern matching algorithms, neural networks, matrix representation and decision trees. Some systems also use “anti-speaker” techniques, such as cohort models, and world models. Ambient noise levels can impede both collection of the initial and subsequent voice samples. Performance degradation can result from changes in behavioral attributes of the voice and from enrollment using one telephone and verification on another telephone. Voice changes due to aging also need to be addressed by recognition systems.

Many companies market speaker recognition engines, often as part of large voice processing, control and switching systems. Capture of the biometric is seen as non-invasive. The technology needs little additional hardware by using existing microphones and voice-transmission technology allowing recognition over long distances via ordinary telephones (wire line or wireless). Multi-layered networks are capable of performing just about any linear or nonlinear computation, and can approximate any reasonable function arbitrarily well. Such networks overcome the problems associated with the perceptron and linear networks. However, while the network being trained may be theoretically capable of performing correctly, back propagation and its variations may not always find a solution. There are many types of neural networks for various applications multilayered perceptrons (MLPs) are feedforward networks and universal approximators. They are the simplest and therefore most commonly used neural network architectures.

Index Terms: Matlab, speaker recognition, speaker verification, speaker matching, neural networks, feature extraction, ann, artificial neural networks, nn.

		Figure 1. Speech signal
A simple and effective source code for Speaker Identification based on Neural Networks.
	Demo code (protected P-files) available for performance evaluation. Matlab Signal Processing Toolbox and Matlab Neural Network Toolbox are required.
Release	Date		Major features
1.1	2006.07.12		Minor bug fixed
1.0	2006.06.14		Speaker recognition based on Neural Networks High recognition rate Text-independent Fully customizable Easy c/c++ implementation Sampling frequency-independent Easy and intuitive GUI Demo code (protected P-files) available for performance evaluation
We recommend to check the secure connection to PayPal, in order to avoid any fraud. This donation has to be considered an encouragement to improve the code itself.
	Speaker Recognition System Based on ANN – Release 1.0 – Click here for your donation. In order to obtain the source code you have to pay a little sum of money: 150 EUROS (less than 210 U.S. Dollars).
Once you have done this, please email us luigi.rosa@tiscali.it As soon as possible (in a few days) you will receive our new release of Speaker Recognition System Based on ANN. Alternatively, you can bestow using our banking coordinates: Name : Luigi Rosa Address : Via Centrale 35 67042 L’Aquila Italy Bank name: Poste Italiane Bank address: Viale Europa 190 00144 Roma Italy IBAN (International Bank Account Number) : IT-50-V-07601-03600-000058177916 BIC (Bank Identifier Code) : BPPIITRRXXX

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

The authors have no relationship or partnership with The Mathworks. All the code provided is written in Matlab language (M-files and/or M-functions), with no dll or other protected parts of code (P-files or executables). The code was developed with Matlab 14 SP1. Matlab Signal Processing Toolbox and Matlab Neural Network Toolbox are required. The code provided has to be considered “as is” and it is without any kind of warranty. The authors deny any kind of warranty concerning the code as well as any kind of responsibility for problems and damages which may be caused by the use of the code itself including all parts of the source code.

For most of the Numerical simulations Unstructured Mesh are very common. Especially for Finite Element methods triangular  meshes they offer the best trade-off between flexibility  and precision of calculus. Today I am going to write about unstructured Mesh generation in MATLAB.

by Darren Engwirda

MESH2D is a toolbox of 2D meshing routines that allows for the automatic generation of unstructured triangular meshes for general 2D geometry.

An iterative algorithm is used that attempts to optimise the mesh topology/vertex position to achieve high quality triangulations.

In addition to the fully automatic settings, MESH2D allows the user to specify sizing information, allowing for varying levels of mesh resolution within the domain.

MESH2D includes a large set of demos/benchmarks. Please see the following:

• meshdemo – runs a standard set of demos.
• mesh_collection – a collection of user contributed geometries.
• facedemo – examples of geometry with connected faces.

It has one disavantage, due to the use of the qhull.mex routine (delaunay triangulator), despite of the slower standard matlab delaunay, it is only windows compatible.

Download Now

Matlab PDE toolbox

Another solution is to use  (and buy) the matlab MATLAB PDE Toolbox.

The PDE toolbox is designed to solve two-dimensional linear partial differential equations by finite element methods, but it also offers some simple CAD and mesh generation feature. By typing on the MATLAB command window:

pdetool

You will access the drawing tools which are pretty simple. It is possible to draw simple geometric primitives and combine them with boolean operations. After finished the 2D geometry by pressing the mesh command, you will realize unstructered mesh generation that can be used to solve pdes, but also to export on the workspace.

Triangle.m is a MATLAB graphical user interface for creating 2D models and generating finite element triangulation grids. Grid generation is accomplished by an external call to the C-code Triangle.c, written by Jonathan Shewchuk at UC Berkeley. The features included in the MATLAB interface were created with the intent to handle 2D geophysical modeling applications. However, the generality of the interface should allow for multidisciplinary usage.

Triangle.m home page

DistMesh

DistMesh is a simple MATLAB code for generation of unstructured triangular and tetrahedral meshes. It was developed by Per-Olof Persson and Gilbert Strang in the Department of Mathematics at MIT.

More infos can be found at the DistMesh Home page.

.: Click here to download :.

Having an easier life by the help of developing technologies forces people is more complicated technological structure. In today’s world, security is more important than ever. Dazziling developments in technology arouse interest of scientists about human and human behaviors and at the same time, give an opportunity to people to apply their thoughts. Today, for security needs, detailed researches are organized to set up the most reliable system. Iris Recognition Security System is one of the most reliable leading technologies that most people are related. Iris recognition technology combines computer vision, pattern recognition, statistical inference, and optics. Its purpose is real-time, high confidence recognition of a person’s identity by mathematical analysis of the random patterns that are visible within the iris of an eye from some distance. Because the iris is a protected internal organ whose random texture is stable throughout life, it can serve as a kind of living passport or a living password that one need not remember but can always present. Because the randomness of iris patterns has very high dimensionality, recognition decisions are made with confidence levels high enough to support rapid and reliable exhaustive searches through national-sized databases.

Artificial Neural Networks (ANNs) are programs designed to simulate the way a simple biological nervous system is believed to operate. They are based on simulated nerve cells or neurons, which are joined together in a variety of ways to form networks. These networks have the capacity to learn, memorize and create relationships amongst data. ANN is an information-processing paradigm, implemented in hardware or software that is modeled after the biological processes of the brain. An ANN is made up of a collection of highly interconnected nodes, called neurons or processing elements. A node receives weighted inputs from other nodes, sums these inputs, and propagates this sum through a function to other nodes. This process is analogous to the actions of a biological neuron. An ANN learns by example. In a biological brain, learning is accomplished as the strengths of the connections between nodes are adjusted. This is true for ANN’s also, as these strengths are captured by the weights between the nodes. ANN’s most important advantage is that they can be used to solve problems of considerable complexity; problems that do not have an algorithmic solution or for which such a solution is too complex to be found. Because of their abstraction from the brain, ANNs are good at solving problems that humans are good at solving but which computers are not. Pattern recognition and classification are examples of problems that are well suited for ANN application.

Index Terms: Matlab, source, code, iris, recognition, segmentation, detection, verification, matching, ann, nn, neural, network, networks.

		Figure 1. Neural network example
A simple and effective source code for Personal Iris Recognition Using Neural Network.
	Demo code (protected P-files) available for performance evaluation. Matlab Image Processing Toolbox, Matlab Neural Network Toolbox and Matlab Signal Processing Toolbox are required.
Release	Date		Major features
1.0	2008.12.15		Iris recognition based on neural networks Fast and accurate iris segmentation Customizable code Matching module Easy and intuitive GUI High speed iris matching Demo code (protected P-files) available for performance evaluation
We recommend to check the secure connection to PayPal, in order to avoid any fraud. This donation has to be considered an encouragement to improve the code itself.
	Personal Iris Recognition Using Neural Network – Click here for your donation. In order to obtain the source code you have to pay a little sum of money: 250 EUROS (less than 350 U.S. Dollars).
Once you have done this, please email us luigi.rosa@tiscali.it As soon as possible (in a few days) you will receive our new release of Personal Iris Recognition Using Neural Network. Alternatively, you can bestow using our banking coordinates: Name : Luigi Rosa Address : Via Centrale 35 67042 L’Aquila Italy Bank name: Poste Italiane Bank address: Viale Europa 190 00144 Roma Italy IBAN (International Bank Account Number) : IT-50-V-07601-03600-000058177916 BIC (Bank Identifier Code) : BPPIITRRXXX

The authors have no relationship or partnership with The Mathworks. All the code provided is written in Matlab language (M-files and/or M-functions), with no dll or other protected parts of code (P-files or executables). The code was developed with Matlab 2006a. Matlab Image Processing Toolbox, Matlab Neural Network Toolbox and Matlab Signal Processing Toolbox are required. The code provided has to be considered “as is” and it is without any kind of warranty. The authors deny any kind of warranty concerning the code as well as any kind of responsibility for problems and damages which may be caused by the use of the code itself including all parts of the source code.

by Matt Dunham

In this section, we examine strings and string operations as well as two very important Matlab data structures: cell arrays, and structs. We also examine various set-theoretic operations and end with a comprehensive example.

• Useful Functions
• Character Arrays
• Formatting Strings
• Cell Arrays
• String Matching
• Set Operations
• Structs
• Example

Strings in Matlab are actually character matrices, which can be manipulated in very similar ways to numeric matrices.

A = ' This is Test String #1! '
B = A(1:5)              % extract the first 5 characters
C = [A ; A]             % concatenate vertically
D = repmat('@!',2,5)    % replicate char arrays, just like numeric ones
E = 'z':-1:'a'          % create the matrices just like numeric ones.
check = ischar(A)       % is it a char array?
F = isletter(A(1:6))    % which characters are letters? - returns a logical array
G = isspace(A(1:6))     % which characters are spaces? - returns a logical array
H = upper(A)            % convert to upper case
I = lower(A)            % convert to lower case
J = strtrim(A)          % trim leading and trailing blank spaces.
K = deblank(A)          % trim trailing blank spaces only.

A =
 This is Test String #1!
B =
 This
C =
 This is Test String #1!
 This is Test String #1!
D =
@!@!@!@!@!
@!@!@!@!@!
E =
zyxwvutsrqponmlkjihgfedcba
check =
     1
F =
     0     1     1     1     1     0
G =
     1     0     0     0     0     1
H =
 THIS IS TEST STRING #1!
I =
 this is test string #1!
J =
This is Test String #1!
K =
 This is Test String #1!

The isstrprop() function can be used much like the isletter() or isspace() functions, allowing you to test which characters in a matrix belong to one of several different categories. Type doc isstrprop for the full list.

str = ' a1!'
A = isstrprop(str,'punct')       % punctuation
B = isstrprop(str,'alphanum')    % alpha or numeric characters
C = isstrprop(str,'digit')       % decimal digits
D = isstrprop('3A','xdigit')     % valid hexadecimal digits

str =
 a1!
A =
     0     0     0     1
B =
     0     1     1     0
C =
     0     0     1     0
D =
     1     1

The char() and abs() functions convert from integers to the ascii equivalents and vice versa.

A = char(65)
B = abs('B')
C = abs('abcdefg')

A =
A
B =
    66
C =
    97    98    99   100   101   102   103

We can convert from string representations of hexadecimal or binary numbers to decimal numbers and back using the dec2hex() , hex2dec() , dec2bin(), and bin2dec() functions. The num2xxx and xxx2num functions operate on signed numbers.

A = dec2hex(211)
B = hex2dec('D3')
C = dec2bin(211)
D = bin2dec('11010011')

A =
D3
B =
   211
C =
11010011
D =
   211

We can also use the num2str() and mat2str() functions to generate string representations of numeric matrices. Or, parse a number from a string with str2num()

A = num2str([1:5;1:5]) %Takes an optional formatting string - see Formatting Strings section
B = mat2str([1:5;1:5])
C = str2num('44')

A =
1  2  3  4  5
1  2  3  4  5
B =
[1 2 3 4 5;1 2 3 4 5]
C =
    44

If the size of the strings match, we can concatenate vertically and horizontally just like numeric matrices. If not, we can either use the blanks() function to pad with blanks or the strcat() and strvcat() functions to concatenate, adding blanks for us.

C = strvcat('hello','this','is','a','test') %concatenate vertically

C =
hello
this
is
a
test

D = sortrows(C)                             % sort the rows alphabetically

D =
a
hello
is
test
this

E = strjust(C)                              % justify the char array

E =
hello
 this
   is
    a
 test

The sprintf() and fprintf() functions can be used to format strings for output: sprintf() returns a string, while fprintf() directly displays the string, or writes it to a file, depending on the mode.

We pass these functions a string that includes place holders, (denoted by % signs) which will be replaced by corresponding values listed after the string. These place holders define how these values will be formatted. We use %s for a string, %d for a decimal digit, and %05.2f to indicate that we want a floating point number with 5 characters in total, two digits after the decimal point, and padded with zeros if necessary. There are many formatting options; Type doc sprintf for the full list. We can use escape characters like \n for a new line and \t for a tab. The examples will make this clearer.

fprintf('\n %s won the %s medal in the %s \n for his time of %05.2f seconds.\n',...
         'Kosuke Kitajima','gold','100m breaststroke',60.08);
str = sprintf('%07.4f',pi) % display pi to 4 decimals, 7 chars in total, padded with zeros.
str = sprintf('%x',999)    % display number in hexadecimal

 Kosuke Kitajima won the gold medal in the 100m breaststroke
 for his time of 60.08 seconds.
str =
03.1416
str =
3e7

In addition to matrices, Matlab supports another very general and powerful data structure, the cell array. Cell arrays can hold any type of Matlab object or structure including numeric matrices of different sizes, character arrays, other cells, as well as structs and objects, which we will see later. In fact, the same cell array can hold elements of different types. Cell arrays are frequently used to store strings, (i.e. char arrays of different sizes), which is why we discuss them here. Much of what was said about indexing matrices also applies to cells with one or two important differences.

We can create a cell array by using the cell() command

A = cell(2,4)               % create a 2-by-4 cell array
check = iscell(A)           % really a cell?

A =
     []     []     []     []
     []     []     []     []
check =
     1

or by enclosing an object or objects in curly braces

B = {[1,2,3],'hello',{1};[3;5],'yes',{'no'}}   % add a bunch of objects to a cell array

B =
    [1x3 double]    'hello'    {1x1 cell}
    [2x1 double]    'yes'      {1x1 cell}

A 2-by-4 cell array is in fact made up of 8, 1-by-1 cell arrays, (simply called cells), which store the data. There are two ways to index into, (and assign into) a cell array: using () braces and using {} braces. Using the () braces, we access or assign cells. Using the the {} braces we access or assign the data within those cells.

C = B(1,2)      % Returns a cell holding the string 'hello'
D = B{1,2}      % Returns the string itself.
E = B(:,1)      % Returns a cell array holding the first column

C =
    'hello'
D =
hello
E =
    [1x3 double]
    [2x1 double]

If we extract the data from more than one cell at once using the curly bracket indexing, Matlab returns each element one at a time much like a function that returns multiple values. We can assign each of these to new variables or perhaps pass them directly to a function expecting that many parameters.

[F,G] = B{:,1}

F =
     1     2     3
G =
     3
     5

When assigning data, we must be careful what kind of brackets we use.

B(1,1) = {'test'}   % must pass it a cell as we are using () brackets
B{1,1} = 'test'     % same effect as line before.
B{1,2} = {'test'}   % careful, this adds a cell to the cell at (1,2), (nesting cells)
H = B{1,2}{1}       % to then extract it, we have to index twice.

B =
    'test'          'hello'    {1x1 cell}
    [2x1 double]    'yes'      {1x1 cell}
B =
    'test'          'hello'    {1x1 cell}
    [2x1 double]    'yes'      {1x1 cell}
B =
    'test'          {1x1 cell}    {1x1 cell}
    [2x1 double]    'yes'         {1x1 cell}
H =
test

We can transpose,reshape,replicate, concatenate, and delete cell arrays just like matrices

I = B'                           % transpose
J = reshape(B,1,6)               % reshape
K = [repmat(C,1,3);B]            % replicate and concatenate
K(end,:) = []                    % delete

I =
    'test'        [2x1 double]
    {1x1 cell}    'yes'
    {1x1 cell}    {1x1 cell  }
J =
    'test'    [2x1 double]    {1x1 cell}    'yes'    {1x1 cell}    {1x1 cell}
K =
    'hello'         'hello'       'hello'
    'test'          {1x1 cell}    {1x1 cell}
    [2x1 double]    'yes'         {1x1 cell}
K =
    'hello'    'hello'       'hello'
    'test'     {1x1 cell}    {1x1 cell}

Suppose we store numeric matrices of different sizes in a cell array.

A = {[1,2,3],[4,5],[6],[7,8,9,10]}

A =
    [1x3 double]    [1x2 double]    [6]    [1x4 double]

We can concatenate the entries themselves by first extracting all of the elements using the colon operator and then passing the results to the concatenation operator [].

B = [A{:}]

B =
     1     2     3     4     5     6     7     8     9    10

We can also use the num2cell() , mat2cell() ,and cell2mat() functions to convert between matrices and cell arrays.

A = num2cell(1:5)                     % convert [1,2,3,4,5] to {[1],[2],[3],[4],[5]}
B = mat2cell(ones(4,8),[2,2],[3,3,2]) % partition matrix ones(4,8) into 6 cells
C = cell2mat(B)                       % inverse operation, (group together)

A =
    [1]    [2]    [3]    [4]    [5]
B =
    [2x3 double]    [2x3 double]    [2x2 double]
    [2x3 double]    [2x3 double]    [2x2 double]
C =
     1     1     1     1     1     1     1     1
     1     1     1     1     1     1     1     1
     1     1     1     1     1     1     1     1
     1     1     1     1     1     1     1     1

We can convert from a character matrix to a cell array of strings, where each string is taken to be a row of the matrix, using the cellstr() command, and back again using the char() command.

A = strvcat('cell','array','example')   % make a char array
B = cellstr(A)                          % convert to a cell array of strings
check = iscellstr(B)                    % check that its a cell array of strings
C = char(B)                             % convert back to a char array

A =
cell
array
example
B =
    'cell'
    'array'
    'example'
check =
     1
C =
cell
array
example

The cellfun() function can be very useful when we want to apply a function to the data inside every cell. We make use of function handles here. Read the section on functions if you are unfamiliar.

A = {'This, ', 'a ', 'test ', 'message, ', 'contains ', '3 ','punctuation ' ,'marks!'}
f = @(str)str(isstrprop(str,'alphanum')); % function to remove non-alphanumeric chars
B = cellfun(f,A,'uniformOutput',false)    % apply function to A, don't expect same-sized output

A =
  Columns 1 through 6
    'This, '    'a '    'test '    'message, '    'contains '    '3 '
  Columns 7 through 8
    'punctuation '    'marks!'
B =
  Columns 1 through 7
    'This'    'a'    'test'    'message'    'contains'    '3'    'punctuation'
  Column 8
    'marks'

There are several functions we can use to compare strings.

A = 'testString';
test1 = strcmp(A,'testString');       % compare two strings
test2 = strcmpi(A,'TESTstring');      % compare two strings but ignore case
test3 = strncmp(A,'testFoo',4);       % compare only the first 4 chars of two strings
test4 = strncmpi(A,'TEST',4);         % same as above, but ignore case.
result = test1 && test2 && test3 && test4

result =
     1

We can find the occurrences of one substring inside another using the strfind() function, or search for all strings, (stored as rows in a matrix or cells in a cell array) that begin with a certain string, using the strmatch() function. We can also grab the first token in a char array delimited by spaces using the strtok() command, (the delimiter it uses can be changed).

str = 'actgcgctgacgctgatacacgggagctgacgactgaggacgagc'
A = strfind(str,'ctga')

str =
actgcgctgacgctgatacacgggagctgacgactgaggacgagc
A =
     7    13    27    34

str2 = {'foobar','bar','barfoo','foofoo'}
B = strmatch('foo',str2)

str2 =
    'foobar'    'bar'    'barfoo'    'foofoo'
B =
     1
     4

[token, remaining] = strtok('this is a test')

token =
this
remaining =
 is a test

Matlab also supports search and replace operations using regular expressions. Type doc regexp for numerous examples and useful functions.

We can treat matrices and cell arrays as sets or multisets and perform various set operations with the functions union() , intersect() , setdiff() , setxor() , and ismember() .

set1 = 1:2:9
set2 = 1:4
int = intersect(set1,set2)
uni = union(set1,set2)
dif = setdiff(set1,set2)
xor = setxor(set1,set2)
check = ismember(3,set1)

set1 =
     1     3     5     7     9
set2 =
     1     2     3     4
int =
     1     3
uni =
     1     2     3     4     5     7     9
dif =
     5     7     9
xor =
     2     4     5     7     9
check =
     1

set3 = {'alpha','beta','gamma'}
set4 = {'delta','beta','epsilon'}
intc = intersect(set3,set4)
check2 = ismember('delta',set4)

set3 =
    'alpha'    'beta'    'gamma'
set4 =
    'delta'    'beta'    'epsilon'
intc =
    'beta'
check2 =
     1

If we are taking the set difference of integers, it can be much faster to use the custom mysetdiff() function, which uses logical indexing.

mysetdiff

Or, perform basic quantification over logical arrays using the all() and any() commands: all() returns true if all of the inputs are true; whereas, any() returns true if at least one input is true.

forall = all(isprime(1:2:7))
exists = any(isprime(1:2:7))

forall =
     0
exists =
     1

We can also extract the unique elements of a cell array or matrix using the unique() function.

A = ['bba';'bab';perms('aba');'aba']                          % perms() generates every permutation
[uniqueElems, firstIndices, perm] = unique(A,'rows');         % find unique rows of A
sorted = issorted(uniqueElems,'rows')                         % are they sorted? - yes!
check = isequal(A,uniqueElems(perm,:),A(firstIndices(perm),:))% note what each return var represents
uniqueNums = unique([1,2,1,1,2,3,4,4,5,3,2,1])                % numeric matrix
uniqueNames = {'Bob','Fred','Bob','Ed','Fred','Chris','Ed'}   % cell array

A =
bba
bab
aba
aab
baa
baa
aba
aab
aba
sorted =
     1
check =
     1
uniqueNums =
     1     2     3     4     5
uniqueNames =
    'Bob'    'Fred'    'Bob'    'Ed'    'Fred'    'Chris'    'Ed'

In addition to matrices and cell arrays, Matlab supports structured arrays or structs, which allow you to organize data and access it by name. For those familiar with other programming languages, structs are basically hashmaps with string keys, but depending on how they are used, they can also operate much like a simple database. Structs, like cell arrays, can store anything you throw at them. Conversely, you can store structs in cell arrays and even within matrices so long as the fieldnames of the structs are the same.

We can create a struct by using the struct() function, passing it fieldnames and data in alternating order.

S = struct('time',0:10,'distance',0:0.1:1,'height',1:0.1:2)
check = isstruct(S)             % really a struct?
names = fieldnames(S)           % list the fieldnames
check2 = isfield(S,'time')      % check that 'time' is really a fieldname
S = orderfields(S)              % order the fields alphabetically
S = rmfield(S,'height')         % remove a field

S =
        time: [0 1 2 3 4 5 6 7 8 9 10]
    distance: [1x11 double]
      height: [1x11 double]
check =
     1
names =
    'time'
    'distance'
    'height'
check2 =
     1
S =
    distance: [1x11 double]
      height: [1x11 double]
        time: [0 1 2 3 4 5 6 7 8 9 10]
S =
    distance: [1x11 double]
        time: [0 1 2 3 4 5 6 7 8 9 10]

Access the data using the . operator and the name of the field.

time = S.time

time =
     0     1     2     3     4     5     6     7     8     9    10

Alternatively, we can use a string for the name, which allows us to access fields dynamically at runtime, much like a map.

distance = S.('distance')

distance =
  Columns 1 through 7
         0    0.1000    0.2000    0.3000    0.4000    0.5000    0.6000
  Columns 8 through 11
    0.7000    0.8000    0.9000    1.0000

We can set set a new value for a field

S.time = 2*S.time

S =
    distance: [1x11 double]
        time: [0 2 4 6 8 10 12 14 16 18 20]

or add new fields and data on the fly

S.newField = 'foo'

S =
    distance: [1x11 double]
        time: [0 2 4 6 8 10 12 14 16 18 20]
    newField: 'foo'

When the names for the fields will be generated dynamically, (i.e. at runtime) it is often prudent to ensure that the string is a valid fieldname. Fieldnames must begin with a letter and can contain only letters, numbers and the underscore symbol. You can check that a string is valid with the isvarname() command and auto-generate a valid name from a source string with the genvarname() command.

test = isvarname('3alpha')
better = genvarname('3alpha')

test =
     0
better =
x3alpha

We can create an array of structs all having the same fieldnames, which allows us to build a kind of database of entries.

S = struct('Name',{},'ID',{},'Position',{});
S(1).Name = 'Greg'; S(1).ID = '123'; S(1).Position = 'Manager';
S(2).Name = 'Ed'  ; S(2).ID = '312'; S(2).Position = 'Clerk';
S(3).Name = 'Pete'; S(3).ID = '301'; S(3).Position = 'CEO';

We can then access an individual record, itself a struct,

EdsRecord = S(2)

EdsRecord =
        Name: 'Ed'
          ID: '312'
    Position: 'Clerk'

Or access data across all of the records at once.

[gID,eID,pID] = S.ID

gID =
123
eID =
312
pID =
301

We can concatenate the output from the above command

A = [S.ID]

A =
123312301

However, when dealing with structures, its often more useful to concatenate vertically. We can do this by using the vertcat() function, which is the same function called when you concatenate with semicolons as in [A ; B]. Since we cannot control how we get the data from the struct, we sometimes have to call vertcat explicitly.

B = vertcat(S.ID)

B =
123
312
301

We can create structs from cell arrays using the cell2struct() function and, (possibly multidimensional), cell arrays from structs using the struct2cell() function.

data = {1,2,3,4};
fieldNames = {'one','two','three','four'};
dim = 2;                                    %data for each fieldname is ordered along dim 2
S = cell2struct(data,fieldNames,dim)

S =
      one: 1
      two: 2
    three: 3
     four: 4

In the below example, we put many of the functions and constructs just discussed to work. We load Darwin’s on the Origin of Species into a cell array, convert to lower case, remove the punctuation and any non-alpha characters, and sort the words by how frequently they occur in the text.

Here is a link to the text. Place it somewhere on the Matlab path before running this code.

http://www.gutenberg.org/dirs/etext98/otoos11.txt

if(exist('darwin.txt','file'))  % make sure the file exists
    tic                         % time how long this takes
    fid = fopen('darwin.txt');  % Open file
    text = textscan(fid,'%s');  % Grab every word and put it in a cell array
    fclose(fid);                % Close file

    %one big cell is returned, unwrap it and convert to lowercase
    text = lower(text{:});

   %delete any tokens that do not contain at least one alpha character
    noAlpha = cellfun(@(x)~any(x),isstrprop(text,'alpha'));
    text(noAlpha) = [];

  %remove punctuation and any non-alpha characters
    puncRemover = @(str)str(isstrprop(str,'alpha'));
    text = cellfun(puncRemover,text,'UniformOutput',false);

   %find the unique words and assign them numeric ids.
    [uniqueWords, numericIDs, wordOrder] = unique(text);

   %make sure the variables hold what we think they do.
    assert(isequal(text,uniqueWords(wordOrder),text(numericIDs(wordOrder))));

  %count how often each word occurs.
    counts = histc(wordOrder,1:numel(uniqueWords));

   %sort from most frequently occurring to least
    [frequency,order] = sort(counts,'descend');

   %list the words from most frequently occurring to least.
    sortedWords = uniqueWords(order);

  %create a cell array of the frequencies
    freqcell = num2cell(frequency);

  %create a structure from the words so that we can easily search for
    %the frequency of particular words. This is basically a hashmap.
    map = cell2struct(freqcell,sortedWords);

  %check a few words to make sure we didn't make a mistake
    testWord = {'origin','of','the','species','natural','selection'};
    test = true;
    for i=1:numel(testWord)
        test = test && sum(strcmp(testWord{i},text)) == map.(testWord{i});
    end
    assert(test);

  %create a formatted string array of the frequencies as percentages
    freqstring = num2str(100*frequency/sum(frequency),'%2.2f');

 %add percentage signs and convert to a cell array
    freqstring = cellstr([freqstring,repmat('%',size(frequency,1),1)]);

  %display the top 15 words with their percent frequencies.
    display([sortedWords(1:15),freqstring(1:15,:)]);
    toc

  'the'        '6.96%'
    'of'         '5.02%'
    'and'        '2.81%'
    'in'         '2.59%'
    'to'         '2.30%'
    'a'          '1.61%'
    'that'       '1.31%'
    'as'         '1.07%'
    'have'       '1.01%'
    'be'         '1.01%'
    'is'         '1.00%'
    'on'         '0.94%'
    'species'    '0.90%'
    'by'         '0.89%'
    'which'      '0.86%'
Elapsed time is 11.917106 seconds.

end
 
clear all;

.: Click here to download :.

The transport of images across communication paths is an expensive process. Image compression provides an option for reducing the number of bits in transmission. This in turn helps increase the volume of data transferred in a space of time, along with reducing the cost required. It has become increasingly important to most computer networks, as the volume of data traffic has begun to exceed their capacity for transmission. Traditional techniques that have already been identified for data compression include: Predictive coding, Transform coding and Vector Quantization. In brief, predictive coding refers to the decorrelation of similar neighbouring pixels within an image to remove redundancy. Following the removal of redundant data, a more compressed image or signal may be transmitted. Transform-based compression techniques have also been commonly employed. These techniques execute transformations on images to produce a set of coefficients. A subset of coefficients is chosen that allows good data representation (minimum distortion) while maintaining an adequate amount of compression for transmission. The results achieved with a transform-based technique is highly dependent on the choice of transformation used (cosine, wavelet, Karhunen-Loeve etc). Finally, vector quantization techniques require the development of an appropriate codebook to compress data. Usage of codebooks do not guarantee convergence and hence do not necessarily deliver infallible decoding accuracy. Also the process may be very slow for large codebooks as the process requires extensive searches through the entire codebook. Following the review of some of the traditional techniques for image compression, it is possible to discuss some of the more recent techniques that may be employed for data compression.

Artificial Neural Networks (ANNs) have been applied to many problems, and have demonstrated their superiority over traditional methods when dealing with noisy or incomplete data. One such application is for image compression. Neural networks seem to be well suited to this particular function, as they have the ability to preprocess input patterns to produce simpler patterns with fewer components. This compressed information (stored in a hidden layer) preserves the full information obtained from the external environment. Not only can ANN based techniques provide sufficient compression rates of the data in question, but security is easily maintained. This occurs because the compressed data that is sent along a communication line is encoded and does not resemble its original form. There have already been an exhaustive number of papers published applying ANNs to image compression. Many different training algorithms and architectures have been used. Some of the more notable in the literature are: nested training algorithms used with symmetrical multilayer neural networks, Self organising maps, for codebook generation, principal component analysis networks, backpropagation networks, and the adaptive principal component extraction algorithm. Apart from the existing technology on image compression represented by series of JPEG,MPEG and H.26x standards, new technology such as neural networks and genetic algorithms are being developed to explore the future of image coding. Successful applications of neural networks to vector quantization have now become well established, and other aspects of neural network involvement in this area are stepping up to play significant roles in assisting with those traditional technologies.

Index Terms: Matlab, source, code, neural networks, image compression, image processing, image reconstruction, codebook, quantization.

		Figure 1. Compressed image
A simple and effective source code for Image Compression With Neural Networks.
	Demo code (protected P-files) available for performance evaluation. Matlab Image Processing Toolbox, Matlab Communications Toolbox and Matlab Neural Network Toolbox are required.
Release	Date		Major features
1.0	2008.10.17		Image Compression With Neural Networks High compression rate Easy c/c++ implementation Demo code (protected P-files) available for performance evaluation
We recommend to check the secure connection to PayPal, in order to avoid any fraud. This donation has to be considered an encouragement to improve the code itself.
	Image Compression With Neural Networks – Click here for your donation. In order to obtain the source code you have to pay a little sum of money: 95 EUROS (less than 133 U.S. Dollars).
Once you have done this, please email us luigi.rosa@tiscali.it As soon as possible (in a few days) you will receive our new release of Image Compression With Neural Networks. Alternatively, you can bestow using our banking coordinates: Name : Luigi Rosa Address : Via Centrale 35 67042 L’Aquila Italy Bank name: Poste Italiane Bank address: Viale Europa 190 00144 Roma Italy IBAN (International Bank Account Number) : IT-50-V-07601-03600-000058177916 BIC (Bank Identifier Code) : BPPIITRRXXX

The authors have no relationship or partnership with The Mathworks. All the code provided is written in Matlab language (M-files and/or M-functions), with no dll or other protected parts of code (P-files or executables). The code was developed with Matlab 2006a. Matlab Image Processing Toolbox, Matlab Communications Toolbox and Matlab Neural Network Toolbox are required. The code provided has to be considered “as is” and it is without any kind of warranty. The authors deny any kind of warranty concerning the code as well as any kind of responsibility for problems and damages which may be caused by the use of the code itself including all parts of the source code.