First of all, thank you for all comments and emails we received regarding project bamby. I think an apology from our side is due at this point. We both have been very busy working on our Master Thesis Projects. Hence there was little to no blogging done.

As project bamby was part of our research at the university our main interest was to build a proof of concept code regarding our Registration and Decoding algorithms. That’s why we are currently putting no more effort into this project. Nevertheless we have quite a few cool ideas regarding the barcode detection and decodingthat might find their way into an implementation at a later point.

So what’s planned to be covered inside the lemqi blog anyways you might ask ? Easy answer: “Whatever comes to be interesting in the world of computer science.”  We plan to blog about our current research and work projects.

Currently Joachim is working on a project regarding device tracking and might give some insights into software engineering techniques or more specific problems in this field.

I am currently working on texture classification within medical images. I plan to blog about methods that are used within this field (like specific statistical classifiers, texture operators, image metrics and of course wavelets :)).

Nevertheless this blog is not planned to be of entirely technical format. We might also blog about funny stories happening in our work or just mention our thoughts about certain facts in the field of computer science.

Next thing I plan, is a blog entry about the very popular and powerful Local Binary Pattern operator that is used extensively for feature extraction in texture classification problems.

So long!

As we are quite confident with the recognition rate, we’re doing some refactoring and optimization now. Because of the raw processing power modern GPU’s offer, we’re experimenting with HLSL Shaders for image processing.

The first tests showed a significant performance boost compared to similar things done on cpu.
Altough we’re just evaluating this method, we think that we can improve recognition performance dramatically.

Below a screenshot of a sobel filter implemented in a Pixel Shader applied to a 6 megapixel image:

to get a little impression on the recognition quality of our barcode library (called Project Bamby) we decided to compare the recognition rate of several publicly available commercial and non-commercial barcode recognition tools/libraries.

For evaluation we’ve chosen 30 different sample images with variable recognition difficulty and tested wheter the different components are able to locate and decode the barcode.
These images can be viewed by clicking on the image number on the left side of the table below.

To save space we denote the different components with letters from A to K whereas

• A = Project Bamby (this Project)
• B = Next Step’s Indigo Barcode Reader
• C = DTK Barcode Reader
• D = ImagesInfo Barcode Reader
• E = EYM Barcode Reader
• F = Tasman Barcode Reader
• G = BarcodeVision Barcode reader
• H = Softek Barcode Reader
• I = Aspose Barcode Reader
• J = Atalasoft DotImage Barcode Reader Demo

Image	A	B	C	D	E	F	G	H	I	J
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

And finally a small chart that shows an overall recognition rate comparison including false positives.

The results may be a little bit biased towards Project Bamby as some of the pictures we used to compare are the same used while developing. Therefore this library may have a little advantage (although we cannot imagine very different images that may not be recognized).

Thresholding is one of the vital steps in many preprocessing scenarios. The idea is to distinguish between foreground and background pixels to extract information. The big problem is to decide a threshold for each pixel without losing information or introducing noise. We have tested a couple of thresholding methods for our project within the spatial domain. We tested thresholding algorithms that were proposed within the domain of character recognition.

Local Thresholding

Local Threshdolding is a class of thresholding algorithms that calculate a single threshold for every pixel within an image. The advantage is that uneven illumination can be handled better than within a global thresholding algorithm. The idea is that a certain pixel threshold is calculated in respect of the pixel statistics surrounding the pixel of interest.  The boundary is usually called a local window.

One problem when using local thresholding is to find a good size for this local window. It should span 1-2 characters within OCR applications to be efficient. This is not so easy with barcode recognition. As we do not know (and do not want) the scaling of the image, and hence the barcode size, we can not guarantee that the local window spans foreground and background pixels. Because the pixel thresholds are calculated in respect of the statistics of surrounding pixels, light barcode pixels might be classified as background pixels if the local windows is too small (covering only foreground (barcode) pixels). This results in a hole within the barcode line, which certainly is not wanted.

Global Thresholding

Global thresholding algorithms calculate a common thresholding value for every pixel within the image. Uneven illumination can introduce noise and false pixel classifications. Images of bad quality (through glare or blur) introduce some unwanted effects as well. So global binarization algorithms do not seem to be a very good idea on the first impression (related to barcode localization). But what if we use the binarization to classify between edge and none edge pixels? This of course involves some way of edge detection (like using the sobel operator). Or course the edge detection operator might be fooled by glare. But it will only detect the edges of the glarred spot and introduce a much smaller error. The thresholding then does not classify between foreground or background pixels, but between edge and non edge pixels.

Summary

Local thresholding can handle bad quality images better than Global thresholding but it’s tough to decide a good local window size. If the window is too small barcode pixels might get lost, if the window is too big the algorithm speed decreases as well as the threshold qualities. A good tradeoff is to use global thresholding on a preprocessed images to classify between edge and non-edge pixels.

Local Binarization on grayalue Image

Local Binarization on grayvalue Image

Global Binarization on Edge Image

… Barcodes everywhere.

Sorry about the long gap since the last post, summer break and a new very interesseting research project took some of the spare time. I hope i will be able to give some more info about the Robot Kinematics as well as some Java3D Gotchas (and annoying library issues) soon

As mentioned before, our current (almost done) research project is about Barcode Localization and Decoding. We developed a very stable localization method using classical image processing methods as well as applied statistics. Our decoding uses a very robust method for line classification using paramterizable non-linear membership functions.

We plan to improve to optimize the code further and run a study comparing the effectiveness of public available barcode recognition software. Later we will cover some topics of interest relating to the development of this methods.

A few Screenshots of the current version:

Here is a video preview of Project Sputnik, a research project facing with 3D robot simulation and inverse kinematics in Java. An article covering more details will be available soon.

#define t typedef
main( void )
{extern puts;t char *a;t a*b;t b*c;t c*d;t int(*q)(const a);t int
i;q n;t char o;i f;a z;b y;c x;d w;d v;o e;
f^=f;n=(q)&puts;z=&e;*z=f;*(z+--f)=0x64;*(z+--f)=*(z+f+1)+0x8;
*(z+--f)=*(z+f+1)+0x6;*(z+--f)=*(z+f+1)-0x3;
*(z+--f)=*(z+f+1)+0x8;*(z+--f)=*(z+f+1)-87;
*(z+--f)=*(z+f+1)+0xc;*(z+--f)=*(z+f+1)+0x43;
*(z+--f)=*(z+f+1)-0x3;*(z+--f)=*(z+f+1)+0x0;
*(z+--f)=*(z+f+1)-0x7;*(z+--f)=*(z+f+1)+0x3;
z=((&e)+f);y=&z;x=(c)*y;w=&x;v=(d)*w;n((a)v);
}

The first “test” version of the new LemQi Blog is online. There are still a lotof design issues to make.

This post ist actually just a test of the management system of this blog engine.

Have a lot of fun!