-----------------
GNU Loops Tracer:
GLT is a text input method for tactile surfaces. It is based on the possible
combinations of loops between central and perimetrical points. The input
method is deterministic (non predictive) and intended to be a comfortable
replacement of QWERTY virtual keyboards.
5
6 4
7 0 3
8 2
1
Fig. 1
Each number is a circle of radius R. The central point is 0 and the other
points are distributed in circle around it (the input circle). The radius of
the resulting circle is RR, measured from the center of the point 0 to the
center of the outer points. R and RR can be adjusted to different
convenience sizes (depending on hands and screen sizes and/or text input
speed vs precision).
The input circle of the Fig. 1 is generated over any surface in any place of
the surface around the finger that touches it.
+------------------------+ +------------------------+
| | | 5 |
| | | 6 4 |
| x | |7 0 3 |
| ^ | => | 8 2 |
| finger touch | | 1 |
| | | ^ |
| | | input circle |
+------------------------+ +------------------------+
+------------------------+ +------------------------+
| | | input circle |
| | | v |
| finger touch | | 5 |
| v | => | 6 4 |
| x | | 7 0 3 |
| | | 8 2 |
| | | 1 |
+------------------------+ +------------------------+
Fig. 2
The input circle is relative to the initial touch.
The traces are recognized when the hands moves over different circles. There
are stored as traces only different successive points. The central and
peripherial circles acts as surfaces that detects the pass of the finger.
After the first touch the input circle remains in the same position and the
finger moves relative to it.
The symbols are generated by different traces that connects the points from
the point 0 and back to 0 or releases the trace (nil). The traces can be
concatenated in the first case.
[0, 1, 2] [nil | 0] makes a short loop.
[0, 2, 1] [nil | 0] makes a short loops in opposite direction.
[0, 1, 2, 3] [nil | 0] makes a long loop.
[0, 3, 2, 1] [nil | 0] makes a long loop in opposite direction.
[0, 1, 2, 1] [nil | 0] makes a direction changing loop.
etc...
[0, 1] [nil | 0] makes a simple loop.
[0, 5] [nil | 0] makes a simple loop in opposite direction.
There are many possible traces. Simple and long loops are 16 each, 32 in
total, enough to the basic latin characters of many languages.
Direction changing loops adds a huge amount of possible trace adding 32
(counting the opposite direction) possibilities each, they can be used to
special characters and modifiers like enter, return, etc...
Simple loops are not really loops but the simplest possible trace (or very
thin ellipses), they could be used for the most important special characters
or modifiers (as the direction changing loops), there are only 8 simple
loops.
Despite the fact that this virtual input method is based on connection
virtual points, the resulting hand-made traces are not necessary straight
lines, due to the "physical" disposition and diameter of the central and
peripherial points the traces are just recognized between certain limits.
The ascii alphabet symbols are distributed in order following the this rules
starting by the [0, 1] line: short loops counterclockwise, short loops
opposite direction clockwise, long loops counterclockwise, long loops
opposite direction clockwise.
This method is not conceived as predictive nor based on the most frequent
letters by language, the disposition of the basic ascii symbols should be
always the same. The patterns aren't recognized by specialized trace search
algorithms but simply by the physical disposition of the input circle making
it easy to implement and consistent to use.
A very basic Android (and SuperCollider) application is given as a proof of
concept.
------
Notes:
There are related approaches to this input method, the most relevant is
8pen. Although this method was not conceived nor derived from that this
shares the hand-prone trace conception. Aside form that fact, I think the
trace building method differs substantially from the 8pen method and
understands the basic traces as equal (almost, in fact) to each other
differing just by its sense and direction. There is no privilege to most
frequent letters, they are all (almost) equal to trace (and distributed just
in order), that is the original principle.
This method was thought by me pondering many different possibilities and I
think it is fairly original, any omission is not intentional. Do not
hesitate in let me know if I'm wrong in something.
I publish this because I don't have the time-money-resources to develop it
and may be a good idea for a free text input method. Although, obviously, as
difficult to learn as the letters of the alphabet.
Think on the future (more than a project this is a theoretical proposition
right now), go ahead if you want to develop this idea (please as GNU, as
free as it is).
My best wishes.
--------
Copying:
The content of this writing is under Creative Commons Attribution 3.0 License.
Copyright of the example code (Loops.java) is GNU GPLv3.