Phenomenological Theories!

Using Geometry Differentiation for Hand-Written Character Segmentation

2009-05-31T08:59:00Z

Intro.:

The most important part of a Persian OCR is the segmentation process. Because of contiguous characters of Persian scripts the segmentation process is not easy and this will become more difficult when we're talking about hand-written words because there are vast kinds of a hand-written word in Persian script!

Note: As mentioned above, this algorithm targets Persian OCR systems because these systems has no reliable algorithm for this purpose, and this is why there is no Persian OCR system which recognizes hand-written words with high accuracy. But I've decided to share this algorithm here, because it may give you some idea for some other purposes.

The Idea:

The idea is so simple; this algorithm tries to do one of the stages of recognition process of a human brain. When you see a word, your brain first tries to match the whole word against its database, if nothing found, tries to segment characters based on its trained data against the word shape, and …

So, the questions are how brain stores shapes and how brain matches shapes against its data?

A1: Based on your language, the brain tries to store some principals while is under training; for sample, in English, the principal component that brain uses to segment characters is the space between characters and/or the connection between matched shapes for contiguous words(which this is done after recognition).

The principal in the Persian language is differences of ascends and descends in shapes. How this is understood is simple, because when a character lacks these principals, it cannot be recognized by human. Although, in this situation, it will be recognized if and only if we see some other characters around that character (guessing).

A2: As I mentioned above, the matching is done based on differences of ascends and descends in shapes. But one important thing is, in this stage we don't really have to focus on the "dot" and "kashida" (some Persian characters include these special components like "ب" and "ک") although the brain may or may not do the focus but in this algorithm we will ignore them.

The Algorithm:

Stage 1: generate a multi-level horizontal histogram of the whole word's image. This histogram will help us to separate dots and kashidas.

Stage 2: generate vertical histogram of the image, this will help us to find the image baseline and combining this to multi-level histogram will be used to make decision on ignoring some under/above baseline pixels.

Stage 3: convert all of the remaining pixels to curves, for sample the following part of the image can be converted to Sinh(x^2).

Stage 4: get the first differentiation on x. for the above sample, the differentiation will be 2xCosh(x^2).

Stage 5: solve the 2xCosh(x^2) = 0 equation. So the logical point (0, 0), is the reference point of the curve.

Stage 6: add this reference point to the list and store the x and y difference of the point n and point n-1;

Stage 7: calculate the average of the x and y differences of reference points.

Stage 8:

for (int i = 0; i < refpoints->Count; i++)

for (int j = i+1; j < refpoints->Count; j++)

if (refpoints[i].X - refpoints[j].X > segHorAvg ||

(Math::Abs(refpoints[i].Y - refpoints[j].Y) > segVerAvg && refpoints[i].X - refpoints[j].X > 2)) {

if (i == 0 && !beg) {

slices->Add(refpoints[i]);

beg = true;

}

if (!IsDescendingAscending(rp, i, j))

slices->Add(refpoints[j]);

else

continue;

i=j;

break;

}

Real-World Results:

In the following images the green line is the image's baseline, red points are calculated reference points and blue lines are slices of the image.

(you can see that how the dots are ignored)

94 miliseconds. (Debug mode)

93 miliseconds. (Debug mode)

Author: Mehran Toosi

XBAP 3D Image Viewer (Part 2)

2008-04-18T00:42:00Z

Part 2 – The Application :

All the information in the previous post was some basic knowledge of WPF 3D for better understanding the application.

Part 1: http://weblogs.asp.net/mehrantoosi/archive/2008/04/15/xbap-3d-image-viewer-basic-3d.aspx

NOTE : This tutorial is produced for beginners.

Let's start…

Start the visual studio 2008 and create a WPF browser application named 3DImageViewer.

Now you have a new page named Page1, rename the file and class name to Viewer. Don't forget the App.xaml.

Split the default grid to 2 columns and 2 rows

Ok, now it's time to remember what we said in the first part, what we needs now, is Viewport3D, so create your Viewport by typing it's name.

The number 2 was the camera, create a perspective camera as the viewport's camera.

Set your camera properties :

Here, I have a camera which is positioned in 0,0,50 (x,y,z), is looking to point 0,0,-1 with 45 degree of horizontal viewing range.

I've limited my camera's projection between 100 and .1. and finally the up direction is 0,1,0.

you can change these settings as desired…

so let's go to the next step, the Geometry.

Create a ModelVisual3D object

In the content of the ModelVisual3D create a GeometryModel3D object, now we should set the Geometry property.

Create a MeshGeometry3D object :

We've a very simple object, our object is plane, a rectangle which has two sides. Remember that you're 50 unit far away from the object (your camera position).

If the center of the rectangle is 0,0,0 so our positions can be :

-100,75,0 100,75,0 100,-75,0 -100,-75,0

we've a 200 x 150 rectangle.

Set the triangle indices :

Our first indices is 0 1 2 (counter-clock wise), the second one is 3 0 2, why?

Remember the right hand rule, if you add the indices like 2 3 0, your thumb is pointing out (clock wise).

It's done, the object is ready, but how the texture should be mapped to our object, we've to set the TextureCoordinates property.

As we said in the first part, the TextureCoordinates is the mapping between our texture in 2-D and our object in 3-D;

This will allows the system to know how our object should be covered by the texture.

So the texture coordinates is 0,0 1,0 1,1 0,1

Next step is the Texture, the GeometryModel3D has a property named Material, this property allows us to set the front material of the object. There's also another property named BackMaterial which we can set the back material of the object.

In the material content, create a DiffuseMaterial object. The DiffuseMaterial has a property named Brush which you can use it to draw the texture with any type of brush.

Here we'll use ImageBrush to draw the image.

In the above image you can see that I used the scale transform to flip the image horizontally.

Do the same with the BackMaterial but without transformation…

Now if you close the open tags you'll see a dark rectangle in your designer, as we said in the first part, the lights in 3D programming do what the lights do in the real world, they makes surfaces visible.

After closing the ModelVisual3D tag, create another ModelVisual3D and in create an AmbientLight object in the content.

It's done, now your object is visible…

We need some controls for rotating, scaling and moving the object… so we need some transformation that allows us to do what we need.

For the Transform property of your GeometryModel3D, create a Transform3DGroup like the image below.

Ok now drop a button into the controls area like the image below.

Now go to the code behind and in the button1_Click create a double animation for rotating the object, like this :

Don't forget using System.Windows.Media.Animation and System.Windows.Media.Media3D.

Now run the application and click the rotate button, the object rotates and you'll see the back material.

Rotating the object by Mouse :

For moving the object by the Mouse, first you need to wrap the Vieport3D in a container(like grid) with background property set to transparent which allows to capture the events of the mouse event if it's not on the object.

Wrap the viewport in a grid, name it grd, create a handler for mousedown and mouseup, set the background property to transparent and set the focusable to true.

Create a global double variable named x;

In grd_mouseUpDown, handle the MouseMove event of the grid.

Create a method named rotationCheck, this method will check the Angle of the rotation to see if it's bigger than 360.

In the MouseMove event just change the Angle property of the rotation.

Now you can rotate the object by grabbing it by mouse.

Download the sample from here : http://weblogs.asp.net/blogs/mehrantoosi/WPF/3DImageViewer.zip

~~Coming Up :~~ -->> [CANCELED]

~~Part 3 (Scaling and Moving)~~

~~Part 4 (Integrating with a Silverlight Application)~~

XBAP 3D Image Viewer (Basic 3D)

2008-04-15T02:12:00Z

"The WPF 3-D implementation allows developers to draw, transform, and animate 3-D graphics in both markup and procedural code, using the same capabilities afforded by the platform to 2-D graphics. Developers can combine 2-D and 3-D graphics to create rich controls, provide complex illustrations of data, or enhance the user experience of an application's interface." – MSDN

Here, we're going to use the WPF 3-D to write a very simple application.

Suppose that you've written a secretariat system in which user can add the image of letters which comes from outside of the organization via fax or …, after archiving them (if the letter is two sided), every time the user wants to see this letter, you can only show one side of the letter at a time, but it would be cool if we could view this letter as a 3-D image! Isn't?

WPF is here!

Part 1 – The Basic Knowledge Of WPF 3-D Programming :

When you want to create 3-D graphics content in WPF, you'll need:

Viewport3D
Camera
Geometry
Texture
Lighting

Viewport3D :

3-D graphics content in WPF is encapsulated in an element named Viewport3D that can participate in the two-dimensional element structure. The graphics system treats Viewport3D as a two-dimensional visual element like many others in WPF.
Camera :

The WPF supports 3 types of cameras and projections :
- Matrix Camera: specifies the view and projection transforms as Matrix3D objects
- Orthographic Camera: describes a viewing box whose sides are parallel
- Perspective Camera: provides vanishing-point perspective
Here we'll talk about perspective camera; This projection camera has some properties :
- Field of view : this property allows you to set the horizontal field of view by degree.
- Far/Near plane distance : this allows you to limit the range of projection.
- Position : you'll set the position of the camera in 3-D space by this property
- Look direction : setting a point in 3-D space which specifies where the camera is looking.(a straight line from the position of the camera to the looking direction)
- Up direction : this property allows you to tell to the camera where is the up!
The following figure shows a camera in 3-D space.
Geometry :

To build a 3-D scene you need some objects to view, which they are defined by mesh primitives.

What is the mesh?

A triangle mesh or unstructured grid is a collection of vertices, edges and faces that defines the shape of a polyhedral object in 3D computer graphics.

A mesh is represented by :
- Positions : Collection of points in 3-D space
- Triangle indices : only positions have not the ability to define objects, which points makes which triangles? To answer this question you need to define these indices.
  
  In WPF the order in which you add mesh positions is important. You'll need the index of these positions when you're defining triangles. For example if you've four position {p0, p1, p2, p3} and you want to make a triangle from p0, p2 and p3, the index values will be 0,2 and 3.
  
  The order which you're adding the indices is important too. This will say which side of the plane of the triangle that is defined is visible.
  
  Suppose that you're looking at a surface of a triangle, if you add the indices clockwise, the side which you're looking on, will be invisible. You can use the right hand rule to remember this.
- Texture coordinates : after defining the object the system needs to know how cover your object by specified texture.
  
  The ith entry in the TextureCoordinates list corresponds to the ith entry in the Positions list.
  
  Example :
  
  Positions {-1,1,0 -1,-1,0 1,-1,0}
  
  TriangleIndices {0,1,2}
  
  TextureCoordinates {0,0 0,1 1,1}
  
  This means the 0,0 in 2-D space will be mapped to -1,1,0 in 3-D space and so on…
- Normals : this property isn't always necessary, a normal in WPF is used to know how the surface should be lit by a light source. The normal vector is computed by cross product of two vectors that make up the side of the triangle.
  
  For example, the normal vector of a triangle which is defined by A, B and C is computed by AB x AC, BC x BA or CB x CA.
Texture :

To define the characteristics of a model's surface, WPF uses the Material abstract class. The concrete subclasses of Material determine some of the appearance characteristics of the model's surface, and each also provides a Brush property to which you can pass a SolidColorBrush, TileBrush, or VisualBrush.
- DiffuseMaterial : specifies that the brush will be applied to the model as though that model were lit diffusely. Using DiffuseMaterial most resembles using brushes directly on 2-D models; model surfaces do not reflect light as though shiny.
- SpecularMaterial : specifies that the brush will be applied to the model as though the model's surface were hard or shiny, capable of reflecting highlights. You can set the degree to which the texture will suggest this reflective quality, or "shine," by specifying a value for the SpecularPower property.
- EmissiveMaterial : allows you to specify that the texture will be applied as though the model were emitting light equal to the color of the brush. This does not make the model a light; however, it will participate differently in shadowing than it would if textured with DiffuseMaterial or SpecularMaterial.
Lighting :

Lights in 3-D graphics do what lights do in the real world: they make surfaces visible. More to the point, lights determine what part of a scene will be included in the projection. Light objects in WPF create a variety of light and shadow effects and are modeled after the behavior of various real-world lights. You must include at least one light in your scene, or no models will be visible.

The following lights derive from the base class Light:
- AmbientLight : Provides ambient lighting that illuminates all objects uniformly regardless of their location or orientation.
- DirectionalLight : Illuminates like a distant light source. Directional lights have a Direction specified as a Vector3D, but no specified location.
- PointLightIlluminates : like a nearby light source. PointLights have a position and cast light from that position. Objects in the scene are illuminated depending on their position and distance with respect to the light. PointLightBase exposes a Range property, which determines a distance beyond which models will not be illuminated by the light. PointLight also exposes attenuation properties which determine how the light's intensity diminishes over distance. You can specify constant, linear, or quadratic interpolations for the light's attenuation.
- SpotLightInherits : from PointLight. Spotlights illuminate like PointLight and have both position and direction. They project light in a cone-shaped area set by InnerConeAngle and OuterConeAngle properties, specified in degrees.
Reference : http://msdn2.microsoft.com/en-us/library/ms747437.aspx

Coming Up : Part 2 – The Application

Silverlight's XamlWriter!

2008-03-03T03:17:00Z

Hi,

Oh god!, this is my first blog post and this is the second time that I write a complete post and then IE crashes :((

nowadays we hear the sounds of the people who is looking around for a Silverlight's XamlWriter, but there's nothing!

I'm one of the guys who is contributing in Silverlight's Forums (rambler.elf) and I see so many people requested it.

I've decide to create a XamlWriter, and after about 10 hours working it's here! (no no, it's not a ideal XamlWriter, but don't worry, it's not so bad :-) )

a sample Xaml which is created at runtime by XamlWriter :

Limitations :

WORKS WITH SILVERLIGHT 1.1 ALPHA
custom prefixes is not suported. for example : <uc:UserControl1 ... will be resolved to <UserControl1
due to silverlight's limitation for dependency properties, the ones that are not in the control's hirarechy except Canvas.Left, Canvas.Top, Canvas.ZIndex, Storyboard.TargetName and Storyboard.TargetProperty, are not supported.

Project :

please use the following link to download the project :

http://weblogs.asp.net/blogs/mehrantoosi/Silverlight/XAMLTools.zip

Thanks

-M