FIELD OF THE INVENTION:
This invention relates to human machine interface or interaction (HMI)/keyboards/keypads. In particular, the invention relates to a dimension multiplier (DM) keypad system for entering multi-dimensional data and method thereof.
BACKGROUND OF THE INVENTION:
The use of key boards for entering text is today the most common way for humans to generate content and interact with machines. Speech and video processing are slowly making inroads into the human machine interface or interaction (HMI) world - but key boards continue to dominate HMIasof2014.
Entering text using the roman alphabet is a fairly easy proposition. With just 26 letters, 10 digits and a few punctuation marks, it is easy to create a key board that can be used to efficiently input text.
Human language has traditionally evolved along 2 dimensions - the sounds humans can produce and hear (phonetic) - and the pictures that humans can see and draw Hieroplyphics).
However, many languages of the world - especially all of the Indian languages make use of phonetic alphabets. These languages use alphabets (akshara's) that use a single phonetic character to represent each phoneme or unit of sound that a human can produce.
The human vocal system is essentially a 4 dimensional musical instrument - 3 spatial and 1 temporal. In other words, human text can be seen as a 4-dimensional data.
Existing text entry systems depend on a 1-dimensional organization of alphabetic characters (aksharas) laid out on a 2-dimensional key pad in a matrix organization. Even counting a sequence of characters (words and sentences) as a third dimension, the keypads still fall short of efficiently entering 4-dimensional data.
Existing keypads use special keys on the key pad to change the characters laid out on the keypad to bring up additional character sets.
Roman alphabet allows multiple alpabetic characters to be used for entering phonemes. This allows the existing simple 2-dimensional key pads to be used for entering sequences of phonemes, words and sentences.

This puts a limit on the speed at which characters can be entered using 2-d keypads.
This also makes the use of existing 2-drmensional keypads extremely difficult, un-natural and ineffective for entering Indian language text.
OBJECTS OF THE INVENTION:
The principle object of the present invention is to provide a dimension multiplier (DM) keypad system for entering multi-dimensional data and method thereof in order to solve the above mentioned problems of the art.
Another object of the invention is to allow cursive writing through the use of a rover key of the DM keypad.
Yet another object is to allow phonetic data to be input for any human language.
Another object of the invention is to create physical keypads or virtual keypads operated through gesture, eye movement or by touch using a touch sensitive screen.
A further object of the invention is to develop human machine interface or interaction (HMI) systems that can be used to enter complex multi-dimensional data of all types including music, numbers, dates and locations in addition to human text.
A still another object of the invention is to develop highly accessible keypads operated with just 2 fingers for speech generation systems that can aid people with speaking disabilities.
Another object of the invention is to develop navigation systems for navigating multi-dimensional virtual worlds and for controlling real and virtual vehicles.
SUMMARY OF THE INVENTION:
Before the present methods, apparatuses and hardware enablement are described, it is to be understood that this invention is not limited to the particular methodologies, and apparatuses described, as these may vary. It is also to be understood that the terminology used in the description is for the purpose of describing the particular versions or embodiments only, and is not intended to limit the scope of the present invention which will be limited only by the appended claims.
The present invention provides a dimension multiplier (DM) keypad system for entering multi-dimensional data and method thereof to solve the problems mentioned in the art.

According to one embodiment of the invention, a Dimension Multiplier (DM) keypad system is provided for entering multi-dimensional data, said system comprising: at least one input device adapted to receive an input from a user; at least one keypad coupled to said input device, and adapted to: receive said input from said input device; display, via at least one text area of said keypad, said received input and/or a suitable audio output for voicing a sound; send said displayed input and/or said suitable audio output to at least one input processor; wherein said input processor coupled to said input device and said keypad, and adapted to: process said received input and/or said suitable audio output; transform said processed input and/or said suitable audio output into events; send, said events to at least one Controller; wherein said Controller coupled to said input processor, and adapted to: receive said events; process said events to fetch an output from at least one fonttable or at least one phoneme table; and display and/or say, via at least one display screen or at least one speaker of said DM keypad system, said output.
According to another embodiment, a method is provided for entering multi-dimensional data in a Dimension Multiplier (DM) keypad system, said method comprising the steps of: receiving, via at least one input device, an input from a user; displaying, via at least one text area of at least one keypad, said received input and/or a suitable audio output for voicing a sound; processing, via at least one input processor, said displayed input and/or said suitable audio output; transforming, via said input processor, said processed input and/or said suitable audio output into events; processing, via at least one Controller, said events to fetch an output from at least one fonttable or at least one phoneme table; and displaying and/or saying, via at least one display screen or at least one speaker of said DM keypad system, said output.
According to another embodiment, a computer system is provided for entering multi-dimensional data, said system comprising: a processor; a memory for storing program instructions; a display screen; at least one input device adapted to receive an input from a user; at least one keypad coupled to both said input device and memory, and adapted to: receive said input from said input device; display, via at least one text area of said keypad, said received input and/or a suitable audio output for voicing a sound; send said displayed input and/or a suitable audio output to said processor; wherein said processor coupled to said memory, said keypad and said display screen, and adapted to: process said received input and/or said suitable audio output; transform said processed input and/or said suitable audio output into events; process said events to fetch an output from at least one fonttable or at least one phoneme table; and display and/or say, via said display screen or at least one speaker, said output.
According to another embodiment, a non-transitory computer readable medium is provided for entering multi-dimensional data, including program instructions executable by a computer for: receiving an input from a user; displaying said received input and/or a suitable audio output for voicing a sound; processing said displayed input and/or a suitable audio output; transforming said processed input and/or a suitable audio output into events; processing said events to fetch

an output from at least one fonttable or at least one phoneme table; and displaying and/or saying said output.
BRIEF DESCRIPTION OF THE DRAWINGS:
The following summary of preferred embodiments is better understood when read in conjunction with the appended drawings. For the purpose of illustrating the invention, there is shown in the drawings example constructions of the invention; however, the invention is not limited to the specific methods, apparatuses and systems disclosed. In the drawings:
Figure 1 shows dimension multiplier (DM) keypad system according to one exemplary embodiment of the invention.
Figure 2 shows the functional block diagram of the DM keypad system as shown in Figure 1.
Figure 3 illustrates the virtual dimension multiplier (DM) keypad as shown in Figure 1.
Figure 4 illustrates the block diagram indicating as to how the 4-dimesional input value is derived.
DETAILED DESCRIPTION OF THE INVENTION:
Reference throughout this specification to 'one embodiment', 'one exemplary embodiment', 'another embodiment' or similar language means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the present invention. Thus, appearances of the phrases 'one embodiment', 'one exemplary embodiment', 'another embodiment' or similar language throughout this specification may, but do not necessarily, all refer to the same embodiment.
Reference to a non-transitory computer readable medium may take any form capable of generating a signal, causing a signal to be generated, or causing execution of a program of machine-readable instructions on a digital processing apparatus. A non-transitory computer readable medium may be embodied by a transmission line, a compact disk, digital-video disk, a magnetic tape, a Bernoulli drive, a magnetic disk, a punch card, flash memory, integrated circuits, or other digital processing apparatus memory device.
Furthermore, the described features, structures, or characteristics of the invention may be combined in any suitable manner in one or more embodiments. In the following description, numerous specific details are provided, such as example of programming, program code and computer program product to provide a thorough understanding of embodiments of the invention. One skilled in the relevant art will recognize, however, that the invention may be practiced without one or more of the specific details, or with other methods, components,

materials, and so forth. In other instances, well-known structures, materials, or operations are not shown or described in detail to avoid obscuring aspects of the invention.
The present invention will be described with respect to particular embodiments and with reference to certain drawings but the invention is not limited thereto but only by the Claims. Any reference signs in the Claims shall not be construed as limiting the scope. The drawings described are only schematic and are non-hinting. In the drawings, the size of scope of the elements may be exaggerated and not drawn on scale for illustrative purposes. Where the term "comprising" is used in the present description and Claims, it does not exclude other elements or steps. Where an indefinite or definite article is used when referring to a singular noun e.g. "a" or "an", "the", this includes a plural of that noun unless something else is specifically stated.
Definitions:
A static key can be called as tactile key (TK) which can be slightly movable (tilted) using two
fingers of the user in the display of keypad
A movable key can be called as roving key (RK) which can movable (i.e. stretched, shrunken, rotated and/or tilted) using two fingers of the user in the display of keypad.
A deleted key (DK) which can movable (i.e. stretched, shrunken, rotated and/or tilted) using two fingers of the user in the display of keypad.
The present invention solves the limited dimensions of inputs that existing keypads by an innovative mechanism. In order to solve the above mentioned problems of the art, the present invention proposes a dimension multiplier (DM) keypad system for entering multi-dimensional data and method thereof.
Figure 1 shows dimension multiplier (DM) keypad system (100) according to one exemplary embodiment of the invention. The (DM) keypad system (100) comprises of an input device (108a, 108b), a dimension multiplier (DM) Key Board/keypad (102), an input processor (104), a dimension multiplier (DM) Controller (106), display screen, and a speaker (not shown in figure) etc. The DM keypad (102) comprises of a touch screen display, control software, value visualization map (font file), fonttable, phoneme table and a keypad layout file or database, etc.
According to another aspect, the DM keypad (102) can be program instructions which are implemented in the touch screen display only. The functions of said component of the DM keypad system are shown in Figure 2.
The control software comprises of initialization part and control part;

As initialization, the program loads the set of roving keys and tactile keys from the layout file, their visualization' map from the value visualization map file and displays the keys on the screen using standard graphics API (application programming interface) and transfers control to the control method. The data is also stored in an lkey_layout_array and value_visualization_map.
The virtual DM Keypad (102), as shown in Figure 3, displays 1 or more roving keys (RKi) and 1 or more tactile keys (TKU, TKi2, ...TK2n). In addition, the DM Keypad (102) displays a delete key (DK) (not shown in Figure). Both the roving keys (RKi) and the tactile keys (TKn, TKi2, ...TK2n) may support entering of 1 or more dimensions of data values. The data comprises of letter, text, music, numbers, date, and/or location based on the requirements.
In case the user wants to enter text using the DM keypad (102) then 'vowels' can be assigned to rover key and 'consonants' can be assigned to tactile key based on the requirements. To enter data, the user picks a roving key (RKi), stretches and tilts as required and pushes it to contact a tactile key (TKn, TK!2, ...TK2n) using necessary force to alter the value of the tactile key. The input can be displayed in a text area of said DM keypad (102).
According to one aspect, the tactile keys (TKn, TKi2, ...TK2n) can be slightly movable to change the dimension of the input received. The dimensionality of data (akshara) actually entered is a product of the movable key dimension and the static key dimension.
Example:
The user can pick the rover key, operating the key with index and thumb fingers stretch it (1-dimension), and tilt it (2-dimension) to form the 'ee' and contact the 'ka' key (3-dimension) to generate 'ki'. The output 'ki' is displayed in the text area of said DM keypad (102). In case the entered data is wrong/incorrect, then said data can be erased using the delete key (DK) by way of shrinking, rotating and/or tilting using two fingers of the user.
According to another aspect, the user can operate the rover key with index and middle fingers based on the requirements.
According to another aspect, the tactile key represents multiple a sets of values corresponding to various zones that combine with the value from a roving key to create composite values. When a roving key pushes the tactile key, it changes its value step by step starting with the first of the set of values it represents based on the zone and ending with the last one. It then creates a composite value representing the intended input value from the user.
According to another aspect, reference to the zones on tactile keys that allow characters to be composed from multiple characters such as "Chintha" "ntha" = "n + tha" "tra" = "ta + ra".

Similarly, in case user wants to enter date then the month and year to be assigned to tactile keys and day can be assigned to rover key based on the requirements.
The below functions explain as to how the tactile key value changes:
Pseudocode:
// SpaceX=40 SpaceY=20 Tilt=5 StartCode='Ka' U='DM'
enum DMMZ {dmmz_east, dmmz_west, dmmz__north, dmmz_south };
class TactileKey {
long SpaceX, SpaceY, Tilt, StartCode, EndCode;
long SizeX, SizeY;
long rvalue;
DMIEvent in;
DMMZ mz;
DMCode CurCode, CurShow;
DMCode v3;
DMOutput *op;
initialize^, y, sx, sy, t, code, DMOutput *p) {
SpaceX = x; SpaceY = y;
SizeX = sx; SizeY = sy;
Tilt = t;
StartCode = CurCode = code;
EndCode = code + Tilt;
in = dm_none;
op = p;
show(); }
// Used by CW to locate objects at a point boolean locate(long x, long y) {
if ( (y >= SpaceY && y < SpaceY + SizeY) && (x >= SpaceX && x < SpaceX + SizeX)) { return true;
}
return false;
}
// On DMEvent: Event e, Rover Value rvalue show() {
if (CurShow) { op->erase(SpaceX, SpaceY, CurShow); }
CurShow = CurCode;

op->display(SpaceX, SpaceY, CurCode); }
void tilt() {
Cu'rCode.t++;
if (CurCode.t >= EndCode) CurCode.t = StartCode;
show(); }
// A tactile key may have multiplier zones on all sides
// This is a simple implementation that allows 2 zones void setjmz (long x , long y) {
if (x >= SpaceX && x < SpaceX + SizeZ/2)
mz = dm_hold; else
mz = dm_select; }
void in (DMEvent e, long r, long x, long y) {
rvalue = r;
set_mz(x,y);
if(e==dm_push){ tilt();} }
// Generates Value DMCode valueO {
■II Return the Dimension Multiplied Value
v3.mz = mz;
v3.r = rvalue;
v3.t = CurCode.t;
return v3; }
};
According to another aspect, the roving key represents a set of values based on its size (stretched or shrunk) and its tilt (rotation value). When a roving key touches a tactile key it helps the user input a combined value based on the value of the roving key and the value of the static key. The roving key moves across the screen under the control of the user, dynamically displays itself in various stages of stretch (shrink) and rotation.
The below functions explain as to how the roving key value changes:

Pseudocode:
class RovingKey {
long SpaceX, SpaceY, max_stretch, max_rotate;
long MaxX, MaxY, MinX, MinY;
long SizeX, SizeY;
long StartCode;
long rotate_value;
long stretch_value;
long rover_value;
DMOutput *op;
pixmap rover_faces[];
int nfaces;
struct { long x, long y } pointer[2];
DMTrack track_east[2], track_west[2];
long ShowX, ShowY, ShowValue;
EW
initialize^, y, sx, sy, ewr, nsr, c, p, rf_name, xmin, ymin, xmax, ymax) {
SpaceX = x;
SpaceY = y;
SizeX = sx;
SizeY = sy;
StartCode = c;
max_stretch = ewr;
maxjrotate = nsr;
rotate_value = 0;
stretch_value = 0;
MinX = xmin;
MinY = ymin;
MaxX - xmax;
MaxY = ymax;
track_east = track_west = dmt_none;
system.load(rover_faces, nfaces, rfjiame);
ShowX = ShowY - ShowValue = 0;
rover_value = 0;
updateO; }

// Returns rover value value() {
rover_value = StartCode + rotate_value * stretch_value;
return rover_value;
}
// Pseudo code for various rover operations show() {
// Compute Value
value();
if (ShowValue) system.erase( ShovvX, ShowY, rover_faces[show_value])
system.display (SpaceX, SpaceY, rover_faces[value]);
ShowX = SpaceX;
ShowY = SpaceY;
ShowValue = roverjvalue;
}
// Rotate Dimension (NS Movement) rotate_counter() {
rotate_value—;
if (rotate_value < 0) rotate_value = 0;
// Update Pointer
} rotate_clock() {
rotate_value++;
if (rotate_value >= maxjrotate) rotate_value = max_rotate - 1;
}
// Stretch Dimension (EW Movement) stretch() {
stretch_value++;
if (stretch_value >= max_stretch) stretch_value = max_stretch-l;
}
shrink() {
stretch_value--;
if (stretch_value < 0) stretch_value = 0; }
// Move across the key pad move(long dx, long dy) {
SpaceX += dx; SpaceY += dy;

if (SpaceX >= MaxX) SpaceX = MaxX-1; if (SpaceX < MinX) SpaceX = MinX; if(SpaceY >= MaxY) SpaceY = MaxY-1; if (SpaceY < MinY) SpaceY = MinY; }
// Rover is in a bounding box of SizeX x SizeY boolean locate(long x, long y) {
if ((x >= SpaceX && x < SpaceX + SizeX) &&
(y >= SpaceY && y < SpaceY + SizeY)) return true;
return false; } .
// Decide if a point within RoverKey bounding box is on the east east(long x, long y) {
if (x >= StartX && x < StartX + SizeX/2) return true;
return false; }
west(long x, long y) {
if (x > StartX + SizeX/2 && x < StartX + SizeX) return true;
}
void in (touchpoint tp, DMTrack t[2], bool moving, dx, dy) {
if (moving) move (dx, dy);
if (east(tp.x, tp.y)) track_east = t;
if (west(tp.x,tp.y)) track_west = t; }
// Here is a view of the Rover
// O NPTR
// y
// WxxxyxxE
// y
// SPTR
// 0 is origin (SpaceX, SpaceY) void update_pointer()
{
pointer[0].x = SpaceX + SizeX/2; pointer [0].y = SpaceY;
pointer[l].x = SpaceX + SizeX/2;

pointer[l].y = SpaceY + SizeY; }
void update()
{
if (track_east[0] = dmt_east && track_west[0] == dmt_west)
stretch(); if (track_east[0] = dmt_west && track_west[0] = dmt_east)
shrink(): if (track_east[l] == dmt_north && track_west[l] = dmt_south)
rotate_counter(); if (track_east[l] == dmt_south && track_west[l] = dmt_north)
rotate_clock(); update_pointer(); show(); } }
According to another aspect, the DM key pad (102) can be used to enter multi-dimensional values for various applications such as entering 3D inputs, language characters, month-date-year inputs and database value selections. The user operating the rover key with his gestures or his fingers (example the thumb and index fingers) can simultaneously -
• turn the rover key to select value r in a set of values R,
• stretch and shrink the rover key for selecting a value s in a set of values S
• and touch or push against one of the multiplier zones mz from a set of zones MZ for a static tactile key thereby selecting a value t in a set of values T.
The rover key can then be moved to touch another tactile key to select a different input. Finally, the input can be displayed in the text area of said DM keypad (102). In case the entered data is wrong/incorrect, then said data can be erased using the delete key (DK) by way of shrinking, rotating and/or tilting using two fingers of the user.
When operating with fingers, this operation can be done cursively without the need for lifting and stroking the key pad with ones fingers thereby reducing stress caused due to typing and allowing for faster input of cursive text or other values.
For millennia, humans had the ability to write using a cursive style of writing that supported rapid entry of data onto a paper. This DM keypad (102) also allows cursive writing through the use of a roving key (RKi).

The dimension multiplier thereby allows a value v formed from r, s, mz, t to be selected in a single operation as shown in Figure 4. Including the rows of tactile keys as another 2 dimensions and multiple rover keys as yet another dimension, the DM key pad allows 7 dimensional data to be entered with ease in each operation and 8 dimensional values entered using cursive data entry. According to one aspect, the entered data can be displayed in text area of the DM keypad (102). The delete key (DK) can be used to erase the wrong data entered in the said area.
The above said keypad can also be used for continuous data input and incremental data input such as for operating a vehicle in 2D or controlling a flight in 3D using signed values. Allowing for operation with just movement of eyes, gestures or touch - the versatile invention allows for accessibility.
According to one aspect of the invention, the input of the DM keypad (102) can be any one from the group comprising of touch input, phonetic data, gesture input, eye movement, and/or combinations thereof. The input can be received from the input device. According to one aspect, the input device can be microphone, camera, touch screen and/or touch pad. According to one exemplary aspect, input device can be touch screen or touch pad. The touch screen or touch pad input that sends touch points as X,Y co-ordinates. The user can enter data using said touch screen or touch pad. The below functions explain as to how the operating environment to receive touch inputs from the touch screen or touch pad.
Pseudocode:
struct touch__point { bool valid; long x, long y; } class TSInput {
touch_point current [2], prev[2];
long response_time; // Milli seconds
initialize() { current = prev = {0}; response_time = 100; }
run() {
long x, y; while (1) {
touch_screen_detect_touch(current[0]); touch_screen_next_touch(current[l]); sleep (wait_period); prev = current; } }
};
According to another aspect, the input device can be camera (108a, 108b). It is an optional device to the DM keypad system (100) of the present invention. The input device uses the inherent capabilities of the operating environment to return the gesture inputs as events to the

input processor (104). The below functions explain as to how the operating environment to return the gesture inputs as events from the camera.
Pseudo Code:
enum DM_event { dm_none, drnjilt, dm_stretch, dm_touch, dm_move,
dmjpush, dm_mode }; enum DMjxack { dmt_eyes, dmt_fingers } ; class Gesturelnput { initialize () {
// Request system to track hand and fingers gesture_kernel_initialize(dmt_fingers, dmt_pointer);
}
DM_event get_event(long &x, long &y) {
DM_event r = getsture_kernel_get_event(long &x, long &y);
return r;
} }
According to another aspect, the input device can be microphone. The input device receives the audio input when the user speaks and sends the same to the DM keypad (102). The DM keypad (102) receives, process said input to display as a suitable audio output for voicing a sound. Finally, the DM key pad (102) sends the same to the input processor (104).
The control method comprises of event generation and event processing.
The input processor (104) receives at least one input, process and coverts the same to generate input events. According to one aspect, input processor (104) comprises of any one of the followings such as processor, microprocessor, and controller etc. According to another aspect, the input processor (104) receives the touch input using the touch sensitive screen, gesture input, eye movement using at least one camera (108a, 108b), and then processes and converts them to input events.
According to one exemplary aspect, the input received by the input processor (104) is only touch input by the user. The input processor (104) transforms the X,Y inputs to events.

Example: dm_event_generation:
touch_points: all touch points are detected by the input processer (104) and maintained in 2 arrays curJ:ouch_points and prev_touchjpoints
the gen_dm_input method is invoked by the input processer (104) to generate dm_input events. The below functions explain as to how the input processor (104) generates touch events:
Pseudo Code:
enum DMIEvent { dm_none,
dm_touch, dm_move, dm_push, dm_mode }; enum DMOEvent { dm_none, dm_rotate_clock, dm_rotate_anti, dm_stretch, dm_shrink,
dm_code }; enum DMTrack { dmtjione, dmt_east, dmt_west, dmt_north, dmt_south }; class DMInput {
TSInputtsl;
Connected World cw; // Set of objects indexed by their location in n dimensions
DMIEvent dmi[2];
DMOEvent OEvent[2];
DMCode OCode[2];
// Initialize and connect to TSInput initialize(TSInput &itsl, Connected World &icw)
{ tsl = itsl; cw = icw; dmi = dmo = {dm_none}; dc = { 0 } ;} DMjxack track0(int p)
{
// Given 2 points that are close to each other judge the direction of movement
if (cur[p].x > prev[p].x) return dmt_east;
if (cur[p].x < prev[p].x) return dmt_west;
return dmt_none;
}
DMjrack trackl(int p)
{
// Given 2 points that are close to each other judge the direction of movement if (cur[p].y > prev[p].x) return dmt_south; if (cur[p].y < prev[p].y) reutnr dmt_north; return dmtjnone;
}
DM_event process_input()

t
DMTrack t[2][2] = { dmt_none }; RoverKey *rk[2] = 0; intdx[2] = {0},dy[2] = {0}; bool move[2] = {false};
// For each touch point, process the touch point for (int tp = 0; tp < 2; tp++) { // For touch point 1 if (ts 1 .current[tp] .valid) {
t[tp][0] =track0(tp); t[tp][l]= track l(tp);
rkftp] =
cw.locate("RoverKey", tsl.current[tp].x, tsl.current[tp].y);
if (tsl.prev[tp].valid) {
dx[tp] = tsl .current[tp].x - tsl .prev[tp].x; dy [tp] = ts 1 -current[tp] .y — tsl .prev[tp] .y; if (dx[tp] || dy[tp]) move[tp] = true;
}
if (rk[tp]) rk[tp]->in(tsl.current[tp], move[tp], t[tp],
dx[tp], dy[tp]);
}
}
// For each rover key, check if the pointer hits a tactile key for (int tp = 0; tp < 2; tp++) { if(rk[tp]){
int ptrjndex = 0;
rk[tp]->update();
// Check north pointer
TactileKey *tk = cw->locate("TactileKey",
rk[tp]->pointer[0].x, rk[tp]->pointer[0].y); // Else check south pointer if(tk=0){
tk = cw->locate("TactileKey",
rk[tp]->pointer[l].x, rk[tp]->pointer[l].y); ptr_index=l;
}
if (dmi[tp] = dm_touch)
dmi[tp] = dm_push; else
dmi[tp] = dm__touch; if(tk){

tk->in(dmi[tp],
rk[tp]->value,
rk[tp]->pointer[ptr_index] .x, rk[tp]->pointer[ptr_in dex] .y);
OEvent[tp] = dm_code;
OCode[tp] = tk->value;
} } else {
dmi[tp] = dm_none; OEvent[tp] = dm_none; OCode[tp] = 0;
} } void run() {
while (1) {
process_input(); sleep(wait_period);
} }
};
According to one aspect, the input processor (104) receives the suitable audio output from the Keypad (102), processes the suitable audio output, and transforms said output into events. Finally, the input processor (102) sends the same to dimension multiplier (DM) Controller (106) of said DM keypad system for further processing.
According to another aspect, the input processor (104) receives gesture inputs as events from said input device comprises at least one camera and the touch input from the input device comprises of the touch screen and/or touch pad. Then the input processor (104) processes said touch input, transforms said processed touch input into touch events, combines both said gesture events and touch events, and sends the combined events to a dimension multiplier (DM) Controller (106) of said DM keypad system for further processing. According to one aspect, the input event can be any one from the group comprising of tilt, stretch, shrunk, rotate, and/or combinations thereof.
According to one aspect, the DM Controller (106) receives and processes the input events to fetch an output from at least one fonttable.
According to one aspect, the fonttable consists of an array of images that have either a fixed or variable size described using either pixel maps or vector maps (series of lines). Based on a selected character code, the font table returns the pixel stream of the selected character in a known manner.

The below functions explain as-to hew the fonttabie returns the pixel stream:
Pseudo Code:
// Assumes Fixed Width BitMap Characters class FontTable {
wchar code_base;
wchar max__code;
struct font_face {
long charjheight, char_width; longpixmap [char_height][char_width];
};
font_face font_table [max_code];
// May be initialized from ROM instead of a file name initialize (font_map_file_name, font_nchars, font_code_base) { code_base = font_code_base; max_code = font_max_code; load font_table from file to font_table; }
pixmap combine2 (wchar vowel, wchar consonant)
{
II Combine font pixmap for 2 characters to get font for resulting character
// in a system specific manner
if (! consonant) return font_table[vowel - code_base];
if (! vowel) return font_table[consonant - code_base];
// Combine the letters to create a composite letter
// Example Ka + E = Ki in a system specific manner
return combine_pixmap( font_table[vowel], font_table[consonant] );
}
pixmap co'mbine4 (wchar vowel [2], wchar consonant[2])
{
// Combine font pixmap for 2 characters to get font for resulting character
// in a system specific manner
if (! consonant) return font_table[vowel - code_base];
if (! vowel) return font_table[consonant - code_base];
// Combine the letters to create a composite letter
// Example Ka + E = Ki in a system specific manner
return combine_pixmap( font_table[vowel[0]],

font_table [eonsonant[0] ], font_tabie[vowel[l]], font_table[consonant[l]] );
} pixmap.get_code( DMCode code[])
{
wcharvowel[2]. consonent[2];
vowel[0] = code[0].r; consonant[0] = code[0].t;
if (code[0].mz == dm_select) {
return combine2(vowel[0], consonant[0]); else {
vowel[l] = code[l].r; consonant[l] - code[l].t; return combine4(vowel, consonant); } } }
According to another aspect, the DM Controller (106) receives events from the DM input receiver (104) whenever user uses the rover key touches or pushes a tactile key. The event information includes the selected character code value. The value selected is used by the DM Controller. (106) for fetching the pixmap from the FontTable and display it using the display screen of said DM keypad system (100) for visual feedback to the user. According to one aspect, DM Controller (106) comprises of any one of the folio wings such as processor, microprocessor, and controller etc.
Example:
dmeventprocessing:
each dm_input_event is processed by DM Controller (106) as follows: dmtilt:
the selected movable key is tilted along the selected axis using tilt_key method

dmextend:
the selected movable key is extended along the selected movable key axis using extend_key method
dmmultiply:
if mk.hold is set,
the movable key accumulated value mk.accumulated-value is multiplied with mk.extend-value.tiIt-value and static-key.extend value, saved to mk.current-value and the resulting value is shown back to the user using display_value method
ELSE
the movable key value mk.extend-value.tilt-value is multiplied with static-key.extend value, saved to mk.current-value and resulting value is shown back to user using display_value method;
dmpersist:
the movable key value mk.extend-value.tilt-value is multiplied with static-key.extend value and the resulting value is shown back to the user using display_value method.
dm_hoId:
the movable key value mk.hold is set and mk.accumulated-value is set to mk.current-value.
dm_move:
the selected movable key is moved to its new location using move_key method.
The below functions also explain as to how the DM Controller (106) processing the input:
Pseudo Code:
enum DMMode { dmm_hold, dmm_select};
struct DMCode { long r; long t; DMMode mz;
};

class DMKeyPad
{
DMInput *di; DMOutput *do;
long SpaceX, SpaceY, SizeX, SizeY, ViewX, ViewY;
void initialize^, y, sx, sy, vx, vy, DMInput *dp, DMOutput *op) {
SpaceX = x; SpaceY = y; SizeX = sz; SizeY = sy; ViewX = vx; ViewY = vy; di = dp; do = op;
}
// Accept dm_code events and display them in the view area void run() {
while (1) {
DMCodecc[2][2],
DMCode nc = 0;
for (int e = 0; e < 2; e++) {
if ( di->OEVent[0] = dm_code) { nc = di->OCode[0]; if (cc[e] [0] .mz == dmm_hold) {
cc[e][l] = new_code;
display (vx, vy, cc[e], false); } else if (new_code.mz == dm_hold) {
cc[e][0] = new_code; } else {
cc[e][0] = new_code;
display (vx, vy, cc[e], false);
} }
}
sleep (waitjperiod);
} } }

The below functions also explain as to how the DM Controller (106) displays the output using Fonttable as visuals (font faces in case of characters) on the screen at the requested x and y co-ordinates.
Pseudocode:
class DMOutput {
FontTable *fp;
long SpaceX, SpaceY, SizeX, SizeY;
void initialize^, y, sx, sy, FontManager *p) {
SpaceX = x; SpaceY = y; SizeX = sz; SizeY = sy;
fp = p; }
int xoff =10, yoff -10;// Configurable
// Erase from display screen void erase(long x, long y, DMCode c[], bool shift) { display(x, y, c, shift);
} '
// Show on display screen
void display(long x, long y, DMCode code[], bool shift) {
long pixmap[] = fp->get_code(code); if (shift) {
system_xor_pixmap(x + xoff, y + yoff, pixmap); } else {
system_xorjpixmap(x, y, pixmap);
.}
}
};
According to one aspect, the DM Controller (106) receives and processes the input events to fetch an output from at least one phoneme table. Finally, the DM controller says the output in the speaker.
According to another aspect, the output can be letter, text, music, numbers, date, and/or location based on the requirements.
According to one aspect, the behavior of the DM keypad (102) can be understood as the aggregate of the parallel operation of the elements of the DM keypad (102) either realized as a

parallel electronic hardware system, a mechanical key pad system or quasi-parallel software system.
All the elements of the same type have identical behavior, for example - all roving keys share identical although configurable behavior. Elements with identical behavior are declared using the component statement that uses the same model element (or type) in the listing in Annexure-1 below:
. Annexure-1
#DM Key Pad System Model using System Description Language
# Dhvani System Model
## A phonetic keypad - Dhvani
# Pseudo Code Representing System Architecture
system Dhvani Universe='DM'
model FontTable font_table.so model TSInput touchjscreen.so model DMInput input_events.so model DMKeyPad DM.so model DMOutput display_controller.so model TactileKey tactile_key.so model RoverKey rover_key.so model DhvaniHMI Skin, so
# Create Dhvani HMI (Implicitly mapped to all components below) DhvaniHMI hmi U=*DM'
# Dhvani Hindi Keypad
component FontTable dhvani_font fontmap=classic_hindi.fm
# Touch screen input device of size 140 x 140 pixels
component TSInput tsl SpaceX=l SpaceY=l SizeX=140 SizeY=140 U='DM'
# Dhvani Controller (Key Pad)
component DMKeyPad phoneticjkeypad SpaceX=l SpaceY-1 SizeX=140.SizeY=140 ViewX=0 ViewY-0 U='DM'
# InputEvents'
component DMInput input_events component DMOuptut output_controller

# Touch Screen Input to events - Assumes-2 touch key pad-
map register input_events:InXO ts 1 :TouchX0
map register input_events:InYO tsl:TouchYO map register input_events:InXl tsl :TouchXl map register input_events:InYl tsl:TouchYl
# Events to DMKeyPad
map register phonetic_keypad:IEventXO input_events:OEventX0 map register phoneticJkeypad:IEventXl input_events:OEventXl
# Output controller to font table
map register output_controller:CurX dhvani_font:CurX map register output_controller:CurY dhvani_font:CurY map register output_controller:PixStream dhvani_font:PixStream
# Roving Vowel Key
component RovingKey Vowel Type-R' SpaceX^O SpaceY=20 sx=20sy = 20 xmax=120 ymax=60 xmin=0 ymin=20 StartCode='Aa'U-DM'
# Top-Row First key for Vowel, Space, Aggregate
component TactileKey MODE SpaceX=20 SpaceY=20 Tilt=3 StartCode='MODE' U='DM'
# Top-Row of Keys Model the Ka Cha Ta Tha Pa 5 x 5 Matrix of Phonemes component TactileKey KA SpaceX=40 SpaceY=20 Tilt=5 StartCode='Ka' U-DM' component TactileKey CHA SpaceX=60 SpaceY=20 Tilt=5 StartCode='CHA' U-DM' component TactileKey TA SpaceX=80 SpaceY=20 Tilt=5 StartCode='TA' U='DM' component TactileKey THA SpaceX=100 SpaceY=20 Tilt=5 StartCode='THA' U='DM' component TactileKey PA SpaceX=120 Space Y=20 Tilt=5 StartCode-'PA' U=*DM'
# Floor-Row of Keys Model Numbers (2 keys), Ya Ra La Va (1), Sa .. component TactileKey NumO SpaceX=20 SpaceY=80 Tilt=5 StartCode='0' U='DM' component TactileKey Num5 SpaceX=40 SpaceY=80 Tilt-5 StartCode='5' U='DM' component TactileKey YA SpaceX=60 SpaceY=80 Tilt=4 StartCode='YA' U='DM' component TactileKey SA SpaceX=80 SpaceY=80 Tilt=5 StartCode='SA' U='DM' component TactileKey PUNCT SpaceX=100 SpaceY=80 Tilt=5 StartCode^';' U='DM'
According to another embodiment, a computer system is provided for entering multi-dimensional data, said system comprising: a processor; a memory for storing program instructions; a display screen; at least one input device adapted to receive an input from a user; at least one keypad coupled to both said input device and memory, and adapted to: receive said input from said input device; display, via at least one text area of said keypad, said received input and/or a suitable audio output for voicing a sound; send said displayed input and/or a suitable

audio output to said processor; wherein said processor coupled to said memory, said keypad and said display screen, and adapted to: process said received input and/or said suitable audio output; transform said processed input and/or said suitable audio output into events; process said events to fetch an output from at least one fonttable or at least one phoneme table; and display and/or say, via said display screen or at least one speaker, said output.
According to another embodiment, a non-transitory computer readable medium is provided for entering multi-dimensional data, including program instructions executable by a computer for: receiving an input from a user; displaying said received input and/or a suitable audio output for voicing a sound; processing said displayed input and/or a suitable audio output; transforming said processed input and/or a suitable audio output into events; processing said events to fetch an output from at least one fonttable or at least one phoneme table; and displaying and/or saying said output.
The DM keypad (102) can be used to interact with any one from the group comprising of computer, laptop, personal digitial assistance (PDA), notebook, and mobile, etc. According to one embodiment, the DM kepypad (102) can be used to enter complex multi-dimensional data of all types including music, numbers, dates and locations in addition to human text. The present invention can also be used to develop highly accessible keypads operated with just 2 fingers for speech generation systems that can aid people with speaking disabilities.
It will be appreciated that the above description for clarity has described embodiments of the invention with reference to different functional units and processors. However, it will be apparent that any suitable distribution of functionality between different functional units or processors/computers may be used without detracting from the invention. For example, functionality illustrated to be performed by separate processors or controllers may be performed by the same processor or controllers. Hence, references to specific functional units are only to be seen as references to suitable means for providing the described functionality rather than indicative of a strict logical or physical structure or organization.
The invention can be implemented in any suitable form including hardware, software, firmware or any combination of these. The invention may optionally be implemented at least partly as computer software running on one or more data processors and/or digital signal processors. The elements and components of an embodiment of the invention may be physically, functionally and logically implemented in any suitable way. Indeed the functionality may be implemented in a single unit, in a plurality of units or as part of other functional units. As such, the invention may be implemented in a single unit or may be physically and functionally distributed between different units and processors.
Although the present invention has been, described in connection with some embodiments, it is not intended to be limited to the specific form set forth herein. Rather, the scope of the present invention is limited only by the accompanying claims. Additionally, although a feature may

appear to be described in connection with particular embodiments, one skilled in the art would recognize that various features of the described embodiments may be combined in accordance with the invention. In the claims, the term comprising does not exclude the presence of other elements or steps.
ADVANTAGES OF THE INVENTION:
The systems, and methods and of the proposed invention can be used for
1) Allowing cursive writing through the use of the dimension multiplier (DM) keypad system;
2) Allowing phonetic data to be input for any human language;
3) Developing human machine interface or interaction (HMI) systems that can be used to enter complex multi-dimensional data of all types including music, numbers, dates and locations in addition to human text;
4) Developing highly accessible keypads operated with just 2 fingers for speech generation systems that can aid people with speaking disabilities;
5) Navigating virtual or real worlds;
6) Driving vehicles; and
7) Developing games that support contextual input and learning.

We Claim:
1. A Dimension Multiplier (DM) keypad system for entering multi-dimensional data, said system comprising:
at least one input device adapted to receive an input from a user; at least one keypad coupled to said input device, and adapted to:
receive said input from said input device;
display, via at least one text area of said keypad, said received input and/or a suitable audio output for voicing a sound;
send said displayed input and/or said suitable audio output to at least one input processor;
wherein said input processor coupled to said input device and said keypad, and adapted to:
process said received input and/or said suitable audio output;
transform said processed input and/or said suitable audio output into events;
send said events to at least one Controller; wherein said Controller coupled to said input processor, and adapted to:
receive said events;
process said events to fetch an output from at least one fonttable or at least one phoneme table; and
display and/or say, via at least one display screen or at least one speaker of said DM keypad system, said output.
2. The system, as claimed in claim 1, wherein said data comprises of letter, text, music, numbers, date, and/or location.
3. The system as claimed in claim 1, wherein said multi-dimension range from 2-dimensions to 8-dimensions.
4. The system as claimed in claim 1, wherein said input device comprises of microphone, camera, touch screen and/or touch pad.
5. The system as claimed in claim 1, wherein said input comprises of touch input, phonetic input, gesture input and/or eye movement.
6. The system as claimed in claim 1, wherein said keypad comprises of:
at least one roving key and at least one tactile key for receiving the touch input from said input device comprises of touch screen and/or touch pad; and
at least one delete key for erasing the wrong input data displayed in said text area of said keypad.
7. The system as claimed in claim 6, wherein said roving key and tactile key are enable to
enter multidimensional data by way of

a) rotating, stretching, shrinking and tilting said roving key;
b) pushing said roving key with said tactile key; and
c) tilting said tactile key
using at least two fingers of the user, wherein said fingers can be index and thumb fingers or index and middle fingers.
8. The system as claimed in claim 6, wherein said roving key represents a set of values based on its size, said size differs when it is stretched, shrunken, rotated and/or tilted.
9. The system as claimed in claim 6, wherein said tactile key represents multiple sets of values corresponding-to various zones that combine with the value from said roving key to create composite values.
10. The system as claimed in claim 6, wherein said roving key is enable to enter cursive data using at least two fingers of the user, wherein said fingers can be index and thumb fingers or index and middle fingers.
11. The system as claimed in claim 1, wherein said input processor is adapted to:
receive gesture inputs as events from said input device comprises of at least one camera;
receive the touch input from said input device comprises of the touch screen and/or touch pad;
process said touch input;
transform said processed touch input into touch events;
combine both said gesture events and touch events; and
send the combined events to said Controller of said DM keypad system.
12. The system as claimed in claim 1, wherein said fonttable comprises of an array of images,
said images have either a fixed or variable size described using either pixel maps or vector
maps.
13) The system as claimed in claim 1, wherein said output comprises of letter, text, music, numbers, date, and/or location.
14) A method of entering multi-dimensional data in a Dimension Multiplier (DM) keypad system, said method comprising the steps of:
receiving, via at least one input device, an input from a user;
displaying, via at least one text area of at least one keypad, said received input and/or a suitable audio output for voicing a sound;
processing, via at least one input processor, said displayed input and/or said suitable audio output;
transforming, via said input processor, said processed input and/or said suitable audio

output into events;
processing, via at least one Controller, said events to fetch an output from at least one fonttable or at least one phoneme table; and
displaying and/or saying, via at least one display screen or at least one speaker of said DM keypad system, said output.
15) The method as claimed in claim 14, wherein said input comprises of touch input, phonetic input, gesture input and/or eye movement.
16) The method as claimed in claim 15, wherein said touch input can be received, via at least one roving key and at least one tactile key of said keypad from said input device comprises of touch screen and/or touch pad, and the wrong input data displayed in said text area of said keypad can be erased using at least one delete key of said keypad.
17) The method as claimed in claim 16, wherein said roving key and tactile key are enable to enter multidimensional data by way of

a) rotating, stretching, shrinking and tilting said roving key;
b) pushing said roving key with said tactile key; and
c) tilting said tactile key
using at least two fingers of the user, wherein said fingers can be index and thumb fingers or index and middle fingers.
18) The method as claimed in claim 16, wherein said roving key represents a set of values based on its size, said size differs when it is stretched, shrunken, rotated and/or tilted.
19) The method as claimed in claim 16, wherein said tactile key represents multiple sets of values corresponding to various zones that combine with the value from said roving key to create composite values.
20) The method as claimed in claim 16, wherein said roving key is enable to enter cursive data using at least two fingers of the user, wherein said fingers can be index and thumb fingers or index and middle fingers.
21) The method as claimed in claim 14, comprising the steps of:
receiving, via said input processor, gesture inputs as events from said input device comprises of at least one camera;
receiving, via said input processor, the touch input from said input device comprises of the touch screen and/or touch pad;
. processing, via said input processor, said touch input;
transforming, via said input processor, said processed touch input into touch events;
combining, via said input processor, both said gesture events and touch events; and
sending, via said input processor, the combined events to said Controller of said DM

keypad system.
22) The method as claimed in claim 14, wherein said fonttable comprises of an array of images, said images have either a fixed or variable size described using either pixel maps or vector maps.