- A little piece of theory

Search for "Equality" on that page - The application,
executable & source

Search for "exp" to find the Fuzzy Equality

(**deprecated**& standard Fuzzy Logic instead) - The accompanying
picture data

(16 bit colors, unpolished)

- Make a subdirectory & go in there
- Unzip MARGRIET (e.g. with pkunzip)
- Unzip PLAATJES (e.g. with pkunzip)
- Run Project1 (executable)
- Load 2 nearly equal pictures
- Process and watch reddish colors

All source code has been included as well, for the serious programmer.

CopyRight (still?) Notice:

Pictures were taken from a more than 30 years old Dutch magazine for
women, called 'de Margriet'.

Oh yeah, besides the *Fuzzy Equal*, a second method of processing called
*Fuzzy Logic* has been included.

The latter is even more impressive.
It employs its own version of a **Fuzzy Equality**, which is
visualized by a second executable, called 'Project2'.

- A little piece of theory
- The application,
executable & source

Accompanying B&W pictures included. - Treatise about Conic Sections

and accompanying source - More about Conic Sections

- Make a subdirectory & go in there
- Unzip KROMMING (e.g. with pkunzip)
- Run Project1 (executable)
- Just Try. Hints provided

It does no harm to consult some additional theory, such as about transformations & variances and Best Fit Ellipses.

The program has been extended with best fit conic sections according my contributions to the 'sci.math' thread called Least squares fitting. It seems that the code is fool proof, because the only case where it

Best Fit Straight Lines require techniques which are a bit deviant from the above:

- A little piece of theory
- The application, executable & source

A cloud of points is defined by clicking on the image with the left mouse button.

A Best Fit Straight Line may be drawn by clicking on the image with the right mouse button.

It is determined, actually, whether they have the same shape, apart from a ROTATION. The gist of the method is as follows.

Assume there exists a non-singular (=

- The application,
executables & source

Accompanying B&W pictures included.

- Make a subdirectory & go in there
- Unzip KRACHTEN (e.g. with pkunzip)
- Run Project2 (executable)
- File → Open 1
- File → Open 2
- Process → Electrical / Gaussian

End of quote.

Gradually, attention has shifted to a far more simple - and much more mathematical - problem. There do exist Computer Algebra Systems, like for example my favorite Maple. But why, oh why, are computers unable to recognize elementary geometries ? Starting with, for example, straight lines ?

Part of my dream has become true now, with the successful implementation of theory and practice, with the following project.

- A little piece of theory
- The application, executable & source
- Many ZIPped data files

(i.e. Euclidian Geometry pictures) - Step by step explanation of the
algorithm

(with a serious bottleneck to be reported)

- Make a subdirectory & go in there
- Unzip ALDERS (e.g. with pkunzip)
- Run Project1 (executable)
- File → Open
- Process → Calculations
- Process → Click on Pic (or do just that)
- until enough is enough

Warning: some of the pictures may take (too) much time to accomplish, due to the serious bottleneck still present. And pictures like this one cannot be processed at all.

And, oh no, I couldn't believe that the so-called Hough Transform has
been a solution to my problems for some time. Claims, claims ... all over the
Pattern
Recognition place. But where is the code I that can download and execute?
Well, after publishing on
UseNet it appeared to be just there (but the link is broken now) !
There is an executable in the ZIP, called 'hough_transform.exe'.
Oh Lord, please help me to keep my big mouth shut until I know what I'm talking
about :-( But it has been fun, nevertheless ... ) The original reference is:
P.V.C. Hough, Machine Analysis of Bubble Chamber Pictures, International
Conference on High Energy Accelerators and Instrumentation, CERN, 1959.

But,
why oh why, has this technology not sunk down into Score Recognition Software ?
Anyway, the Hough Transform has been implemented now - together with the
above
- as a separate project (guess what: 'Project2', while 'Project1' implements
my own algorithm). There is an essential difference between the two approaches:

- Hough: let de data vote for - a priori - discrete models of straight lines
- HdB: let the data speak for themselves & find the models from the data

There is a comprehensive summary of relevant P(attern) R(ecognition) stuff at Richard A. Messner's web page.

Other IMO relevant writeups are 'Circle Detection Using Hough Transforms Documentation'

and 'A short introduction to the Radon and Hough transforms and how they relate to each other'.