Patent Description:
The following references represent prior art relevant to the present invention. <CIT> and <CIT> pertain to gesture recognition based on timing profiles. However, they do not address the interpretation of gestures in cases of ambiguous input, particularly when dealing with continuous input gestures involving a sequence of static touches.

The present disclosure describes techniques and systems directed to determining an intended input from detected gesture positions. The described techniques and systems detect positions with a gesture made relative to a user interface, associate a timing profile to the detected positions, and determine, from the detected positions and the associated timing profile, an intended input to the user interface.

The dependent claims define further advantageous embodiments. Embodiments of the invention are also described below with reference to <FIG>. Instances of the term "example" appearing in this specification other than in relation to <FIG> and its corresponding passages should be interpreted as merely describing related examples.

This document describes details of one or more aspects of determining an intended input to a user interface from detected gesture positions. The use of the same reference numbers in different instances in the description and the figures may indicate like elements:.

The present disclosure describes techniques and systems for determining an intended input to a user interface from detected gesture inputs. While features and concepts of the described systems and methods for determining an intended input to a user interface from detected gesture positions can be implemented in any number of different environments, systems, devices, and/or various configurations, aspects are described in the context of the following example devices, systems, and configurations.

A user interface of a computing device often includes a position-detection mechanism to detect positions of a gesture and provide an input to the computing device. Various factors can negatively affect the position-detection mechanism's ability to determine a user's intended input, such as a resolution of a display of the computing device, biomechanics of a user's finger, and gauge capabilities of the position-detection mechanism, as well as others. Because of this failure, the computing device may perform a function that was not intended by a user, or perform an intended function but in a way not intended by the user.

As an example, consider an instance where a user is scrolling his finger along a progress bar displayed on a touchscreen, where the progress bar corresponds to a timeline of a video available through a video-player application. The user may stop scrolling his finger at an intended position along the progress bar that highlights a time marker corresponding to a segment of the video he would like to watch. However, when the user lifts his finger from the touchscreen, he may unintentionally roll or slide his finger such that the position-detection mechanism detects the user's finger disengaging from the touchscreen at a position that is other than one intended by the user. In such an instance, the position-detection mechanism may associate the other, non-intended position to the input of the user and, rather than causing the video application to queue the segment of the video that the user desires to watch, queue a different segment of the video.

This document describes techniques and systems that are designed to improve the computing device's ability to determine the intended input from detected gesture positions. The described techniques and systems include a computing device having a position-detection manager. The position-detection manager causes the computing device to determine the intended input of a gesture by (i) associating a timing profile to detected positions of the gesture and/or (ii) associating a context surrounding the computing device to the gesture.

<FIG> illustrates an example operating environment <NUM> in which various aspects of determining an intended input to a user interface from detected gesture inputs are implemented. The operating environment <NUM> includes a computing device <NUM>, nonlimiting examples of which include a smartphone <NUM>, a wearable device <NUM>, a tablet <NUM>, a computer <NUM>, and a home-automation control <NUM>.

The computing device <NUM> includes one or more processors(s) <NUM> with logic capabilities. The processor <NUM> may be a single-core processor or a multiple-core processor composed of a variety of materials, such as silicon, polysilicon, high-K dielectric, copper, and so on. The processor <NUM>, furthermore and in general, includes clocking mechanisms for performing timing operations.

The computing device <NUM> also includes one or more sensor(s) <NUM>, such as a GPS sensor, a proximity sensor, an accelerometer, a radar sensor, a radio-frequency identification (RFID) sensor, a near-field communication (NFC) sensor, or the like. The one or more sensors(s) <NUM> may be used to sense conditions surrounding the computing device <NUM>, including an identity of a user of the computing device.

The computing device <NUM> also includes a computer-readable storage media (CRM) <NUM> that includes executable instructions of a position-detection manager <NUM>. The computer-readable storage media described herein excludes propagating signals. The CRM <NUM> may include any suitable memory or storage device such as random-access memory (RAM), static RAM (SRAM), dynamic RAM (DRAM), non-volatile RAM (NVRAM), read-only memory (ROM), or Flash memory useable to store the executable instructions of the position-detection manager <NUM>. The position-detection manager <NUM> may include drivers for managing position-detection mechanisms, machine-learning algorithms, and a buffer for storing data. The computing device <NUM> also includes a user interface <NUM> that includes a display <NUM> and a position-detection mechanism <NUM>.

The position-detection manager <NUM> (e.g., the processor <NUM> executing the instructions of the position detection-manager <NUM>) directs the computing device <NUM> to perform a series of operations to determine an intended input by a user of the computing device <NUM>. The operations may include (i) detecting, through the position-detection mechanism <NUM>, positions associated with a gesture that is made by the user of the computing device <NUM> relative to the user interface <NUM>, (ii) associating, to the positions detected relative to the user interface <NUM>, a timing profile and/or a context, (iii) determining, using the detected positions and the associated timing profile and/or context, an intended input by the user, and (iv) performing an operation corresponding to the intended input.

The combination of the display and the position-detection mechanism <NUM> enable a user to provide an input to the user interface through gesturing. Such an input may include the user performing a gesture to scroll, select, zoom, edit, or tap features presented by the display <NUM>. Such features may be associated with an application executing on the device or an application that is executing remotely (e.g., a cloud-based application). Examples include a progress bar (e.g., a progress indicator associated with a media application), a control input (e.g., an alarm control of a home-alarm system), a link such as a uniform resource locator (e.g., a URL), and a selectable drop-down menu item.

In one example instance, the user interface <NUM> is a touchscreen, where the position-detection mechanism <NUM> is integrated into the display <NUM>. In the instance of the user interface <NUM> being a touchscreen, the position-detection mechanism <NUM> may rely on a capacitive, resistive, reflective, or grid-interruption technologies to receive the input. In this example instance, the position-detection mechanism <NUM> (under the direction of the position-detection manager <NUM>) may detect positions that are associated with a gesture made by the user (e.g., positions of the user's finger or hand) relative to the user interface <NUM> (e.g., the touchscreen).

In another example instance of the user interface <NUM>, the position-detection mechanism <NUM> is separate from the display <NUM>. In this other example instance, the position-detection mechanism <NUM> includes an image sensor, a mouse, or a radar sensor, each of which may (under the direction of the position-detection manager <NUM>) detect the positions that are associated with the gesture and that correlate to movement or location of a cursor presented through the display <NUM>.

The computing device <NUM> also includes hardware that supports one more external interface(s) <NUM>, comprised of a wireless interface <NUM> and input/output (I/O) ports <NUM> for interfacing with other devices. Such other devices may include, for example, the position-detection mechanisms that are separate from the display (e.g., the image sensor, the mouse, or the radar sensor), Internet-of-Things (IoT) devices, and access points having Wi-Fi, 3rd Generation Partnership Project Long-Term Evolution (3GPP LTE), or Fifth Generation New Radio (<NUM> NR) wireless communication capabilities.

<FIG> illustrates example details <NUM> of a computing device having a touchscreen in accordance with one or more aspects. The computing device may be the computing device <NUM> of <FIG> and include one or more elements of <FIG>.

As illustrated in <FIG>, the computing device <NUM> is a tablet and the user interface (e.g., the user interface <NUM>) is a touchscreen that includes the display <NUM> with the position-detection mechanism <NUM> integrated into the display <NUM>. In this instance, the position-detection mechanism <NUM> that is integrated into the display <NUM> is an input mechanism to the user interface <NUM> that may use a capacitive, resistive, reflective, or grid-interruption technology.

The display <NUM> is presenting a music video that a media player application is playing (the media player application may be local to the computing device <NUM> or accessed through a cloud-based service provider). As illustrated, a hand <NUM> of the user is performing a gesture relative to the touchscreen, moving a cursor <NUM> along a progress bar <NUM> associated with the media player application.

As illustrated, the user is making a gesture where a finger of the hand <NUM> scrolls the cursor <NUM> along the progress bar <NUM> to locate an intended input (e.g., the intended input is to trigger playing the music video at time marker <NUM> and corresponding to the <NUM>:<NUM> of the music video). The gesture includes several touch positions, including an engage touch-position <NUM>, an intended touch-position <NUM> (corresponding to the intended input), and a disengage touch-position <NUM>. In some instances, as the user disengages his finger from the touchscreen at an end of the gesture, a biomechanical performance of the user may include the user "rolling" his finger and disengaging from the touchscreen at the disengage touch-position <NUM>. In other instances, as the user disengages his finger from the touchscreen, the biomechanical performance of the user may include the user's finger "sticking" to the touchscreen at the end of the gesture and introduce additional movement that results in the disengage touch-position <NUM>. In turn, and in such instances, the computing device <NUM> may provide the disengage touch-position <NUM> to the media player application and erroneously trigger playing of the music video at a time that does not correspond to that of the time marker <NUM> (e.g., the intended input by the user).

To prevent the erroneous triggering or the playing of the video, the position-detection manager <NUM> (e.g., the processor <NUM> executing the instructions of the position-detection manager <NUM>) can direct the computing device <NUM> perform a series of operations to determine the intended input by the user. In some instances, the series of operations, performed by elements of the computing device <NUM> (e.g., the position-detection mechanism <NUM> and the processor <NUM> executing the instructions of the position-detection manager <NUM>) can include detecting positions associated with the gesture (where the user makes the gesture relative to the touchscreen) and associating, to the positions associated with the gesture, a timing profile.

In the example of <FIG>, the timing profile includes a time period <NUM>, during which a portion of the gesture is static (e.g., stationary and without movement or very little movement) at the intended touch-position <NUM>. The position-detection manager <NUM> (e.g., the processor <NUM> executing the instructions of the position-detection manager <NUM>) may weight this the time period <NUM> during computations and determine that the time period <NUM> is indicative of the intended input.

After determining the intended input, the computing device <NUM> may perform an operation. In some instances, performing the operation may include the computing device <NUM> providing the determined, intended input to an application that is either local to the computing device <NUM> (e.g., stored in the CRM <NUM>) or accessed remotely by the computing device <NUM> (e.g., an application that is accessed through a cloud-based service provider or the like). Providing the intended input to the application may, in turn, launch the application, select a variable presented by the application, or terminate the application. In other instances, performing the operation may include performing a control function associated with the touchscreen, such as zooming a display of the touchscreen or changing a brightness of the touchscreen.

In the instance illustrated by <FIG>, the computing device <NUM> performs an operation that corresponds to providing the media player application the determined, intended input corresponding to the intended touch-position <NUM>. In response, the media player application presents the video at a time corresponding to the intended time marker <NUM>.

The computing device <NUM> may, in some instances, store the timing profile in a buffer that is part of the CRM <NUM>. The computing device <NUM> may then recall the stored, determined timing profile after detecting other positions associated with another gesture to determine another intended-touch location corresponding to another intended input.

In general, the position-detection mechanism <NUM> using the capacitive, resistive, reflective, or grid-interruption technology has an inherent gauge capability (e.g., repeatability and reproducibility) that can be associated with a detected position. In certain instances, the computing device <NUM> may use that capability in determining the intended input corresponding to the intended touch-position <NUM>. For example, if the inherent gauge capability is less precise than a variance in position that would affect a function selected through a gesture, the computing device <NUM> can select, as the likely intended input, an average of positions or select based on the time spent at a position nearest which of multiple positions that would affect the function. Context, as noted elsewhere herein, may also be used to determine the intended input.

<FIG> illustrates details of an example timing profile <NUM> in accordance with one or more aspects. The computing device <NUM> of <FIG> (e.g., the processor <NUM> executing the instructions of the position-detection manager <NUM>) may perform operations to manage the timing profile <NUM> in accordance with aspects of <FIG> and <FIG>.

As illustrated by <FIG>, the position-detection mechanism <NUM> of the computing device <NUM> uses a capacitive-sensing technology. An array of touch-cells <NUM> that is disposed over a surface of the display <NUM> includes electrodes of a transparent, conductive material, such as an indium tin oxide. As the user touches the array of touch-cells <NUM> with his finger, the position-detection manager <NUM> may use sensed differences in mutual capacitance across the array of touch-cells <NUM> to compute a touch position. The computing of the touch position may, for example, weight an average of the sensed differences in mutual capacitance, as well as implement one or offsets that may be necessary for a perceptual correction (e.g., the user may "perceive" he is touching the computing device <NUM> at one location, where in actuality, and due to angular positioning of the computing device relative to the user's viewpoint, he is touching the computing device <NUM> at another location that is offset from the perceived location).

As illustrated, the intended touch-position <NUM> corresponds to the time period <NUM>, whereas the disengage touch-position <NUM> (e.g., due to the user "rolling" his finger), corresponds to another time duration <NUM> that is less than that of the time period <NUM>. In addition to the time period <NUM> and the other time duration <NUM>, the computing device <NUM> may aggregate additional time durations to develop the timing profile <NUM>. As with this example instance, the computing device <NUM> determines, based on the timing profile <NUM>, that the intent of the user is to provide an input that corresponds with the intended touch-position <NUM>.

Although <FIG> illustrates time durations that correspond to static positions of the gesture, variations are possible. For example, a motion vector associated with a swipe or scrolling gesture (e.g., motion vectors that include components of direction, velocity, and/or acceleration and detected by the position-detection mechanism <NUM>) may disengage from the touchscreen prior to "arriving" at a desired icon or menu item that is displayed on the display <NUM>. In such an instance, and based on the motion vector, the computing device <NUM> (e.g., the processor <NUM> executing the code of the position-detection manager <NUM>) may determine that the intended input is that of selecting the desired icon or menu item.

In some instances, determining the intended input may include the computing device <NUM> (e.g., the processor <NUM> executing the instructions of the position-detection manager <NUM>) associating a context to the detected positions. Sensors of the computing device <NUM> (e.g., the sensors <NUM>) may detect a condition surrounding the device to provide a basis for the context. The computing device <NUM> may also use machine learning algorithms of the position-detection manager <NUM> (such as a neural network algorithm), in combination with data stored in the buffer of the position-detection manager <NUM> (e.g., previous timing profiles or contexts associated with detected positions), to associate the context to the detected positions. Contexts can include an identity of a user, a past behavior of the user, a location of the computing device <NUM>, or a time of day.

<FIG> illustrates details of an example context <NUM> in accordance with one or more aspects. The computing device <NUM> of <FIG> (e.g., the processor <NUM> executing the instructions of the position-detection manager <NUM>) may perform operations to determine the context using aspects of <FIG>. <FIG> illustrates the computing device <NUM> as a smartphone. In this instance, the user interface <NUM> of the computing device <NUM> is a touchscreen that is an input mechanism to the computing device <NUM>.

As illustrated by <FIG>, the user awakens at <NUM> AM with the intent of turning on his coffee pot. As the hand <NUM> of the user gestures to (e.g., touches) the user interface <NUM> of the computing device <NUM>, a gesture position (e.g., a touch-position of the user's finger touching a touchscreen of the computing device <NUM>) may be "between" icons that the display <NUM> of the computing device <NUM> is presenting. Based on context information <NUM> that includes a past behavior of the of the user (e.g., a tendency to turn on the coffee pot) at a time of day (e.g., at 5AM), the computing device <NUM> (e.g., the processor <NUM> executing the code of the position-detection manager <NUM>) may determine that the intent of the user (who is not fully awake) is to provide an input that that corresponds to selecting a home-automation icon to turn on the coffee pot, and not provide an input that corresponds to selecting a media-player icon that is proximate to the home-automation icon.

The sensors <NUM> of the computing device <NUM> may detect one or more conditions surrounding the computing device <NUM> and present the detected one or more conditions as context information <NUM> for use by the computing device <NUM>. These conditions include information about the user interface, the computing device, the user, peripherals, or activities being or to be performed by the any of these entities or applications running on them. Thus, the conditions may include a user interface being a touch or radar-based interface having differing precision and accuracy (and thus the context information <NUM> can indicate this differing precision and accuracy). Other conditions include the user having small, thin fingertips or heavy, wide fingertips (and thus the context information <NUM> can indicate a higher accuracy for the thin fingers). Furthermore, other conditions include peripherals that vary, such as an oven, speakers, or television, or applications, which can be indicated by the context information <NUM> indicating the same. In more detail, conditions may include a location of the computing device <NUM> (e.g., a GPS sensor may determine that the computing device is at a user's house), an identity of the user (e.g., an RFID sensor may identify the user), and a status of the computing device <NUM>, application running on the computing device <NUM>, or a peripheral (e.g., the coffee pot may communicate with the computing device <NUM> via an NFC sensor and indicate that is prepared with water, coffee, and available to activate).

In some instances, contexts may be determined and provided to the computing device <NUM> by other devices through the wireless interface <NUM> and input/output (I/O) ports <NUM>. Examples of the other devices include servers, cloud-based computing devices, or IoT devices.

The computing device <NUM> may also store the determined context in a buffer that is part of the CRM <NUM>. The computing device <NUM> may then recall the stored, determined context when detecting other positions associated with another gesture and determining another intended input.

Furthermore, and in general, associating contexts to positions detected relative to the touchscreen may use a machine-learning algorithm. The computing device <NUM> (e.g., the processor <NUM> executing instructions contained within the position-detection manager <NUM>) may effectuate one or more machine-learning algorithms that account for variables that include a past behavior of the user, past gestures, a location of the computing device, a time of day, an identity of the user, or an environment surrounding the computing device <NUM>. As an example, the machine-learning algorithm can adhere to a model that corresponds to a neural network, where the neural network includes an input layer to receive the contexts (e.g., the past behavior of the user, the past gestures, the location of the computing device, the time of day, the identity of the user, or the environment surrounding the computing device), hidden layers for exchanging information to train the model, and an output layer. Other examples of machine-learning algorithm models include a decision tree model and a reinforcement-learning model.

<FIG> illustrates example details <NUM> of a computing device and input mechanisms in accordance with one or more aspects. The computing device may be the computing device <NUM> of <FIG> and include one or more elements of <FIG>. The input mechanisms may be other than an input mechanism that is integrated as part of a touchscreen.

As illustrated in <FIG>, the computing device <NUM> is a tablet and the user interface (e.g., the user interface <NUM>) includes the display <NUM> and input mechanisms <NUM>-<NUM>. Similarly to <FIG>, the display <NUM> is presenting the music video that the media player application is playing. As illustrated, each of the input mechanisms <NUM>-<NUM>, in combination with a driver or other executable instructions contained within position-detection manager <NUM>, can be the position-detection mechanism <NUM> of the user interface <NUM> and control a position of the cursor <NUM>.

A first example of an input mechanism is an image sensor <NUM>. The image sensor <NUM> may be a charge-coupled device (CCD) or complimentary metal-oxide semiconductor (CMOS) image sensor. With this first, example input mechanism, and as opposed to a mechanism that senses a touch-position, the image sensor <NUM> may capture and provide, to the computing device <NUM>, images of a gesture made by the hand <NUM>. The position-detection manager <NUM>, in this first example instance, may include image recognition code or instructions that, upon execution by the processor <NUM>, can identify changes in a position of the hand <NUM> (e.g., a finger of the hand) relative to a background. This can include, in some instances, identifying changes that are associated with a two-dimensional (2D) position as well as a three-dimensional (3D) position.

A second example of an input mechanism is a touchpad <NUM>. The touchpad <NUM> may be included in a keyboard that is communicating with the computing device <NUM> through either the wireless interface <NUM> or the I/O ports <NUM>. The touchpad <NUM> may use a capacitive sensing technology or a conductive sensing technology. In some instances, the touchpad <NUM> may include a touchpad button or a touchpad joystick. The position-detection manager <NUM>, in this second example, may include code or instructions that, upon execution by the processor <NUM>, identify changes in a position of the hand <NUM> (e.g., a finger of the hand) relative to the touchpad or changes that might be associated with the touchpad button or the touchpad joystick.

A third example of an input mechanism is a mouse <NUM>. The mouse <NUM> may include a light-emitting diode (LED) coupled with a photocell to track a movement of the mouse <NUM> relative to a surface. The mouse <NUM> may communicate with the computing device <NUM> through either the wireless interface <NUM> or the I/O ports <NUM>. The mouse <NUM> may, in some instances, include a mouse-scrolling wheel and/or selection mechanisms. The position-detection manager <NUM>, in this third example, may include code or instructions that, upon execution by the processor <NUM>, identifies changes in a position of the mouse <NUM> that is under the guidance of the hand <NUM>.

A fourth example of an input mechanism is a radar sensor <NUM>. The radar sensor <NUM> may emit a radar field and receive reflections of the emitted radar field to determine changes in a position of the hand <NUM> (e.g., the finger of the hand <NUM>). Similarly to the image sensor <NUM>, the radar sensor <NUM> may identify changes that are associated with a two-dimensional (2D) position as well as a three-dimensional (3D) position.

In general, the example input mechanisms <NUM>-<NUM> each has an inherent gauge capability (e.g., repeatability and reproducibility) that can be associated with a detected position. In certain instances, the computing device may use this gauge capability when determining the intended input, as noted above.

Furthermore, and as noted with the touchscreen of <FIG>, the computing device <NUM> (e.g., the processor <NUM> executing the instructions of the position-detection manager <NUM>) can combine a context with positions received through one or more of the input mechanisms <NUM>-<NUM>.

Example methods <NUM> and <NUM> are described with reference to <FIG> and <FIG> in accordance with one or more aspects of determining an intended input to a user interface from detected gesture positions. Generally, any of the components, modules, methods, and operations described herein can be implemented using software, firmware, hardware (e.g., fixed logic circuitry), manual processing, or any combination thereof. Some operations of the example methods may be described in the general context of executable instructions stored on computer-readable storage memory that is local and/or remote to a computer processing system, and implementations can include software applications, programs, functions, and the like. Alternatively or in addition, any of the functionality described herein can be performed, at least in part, by one or more hardware logic components, such as, and without limitation, Field-programmable Gate Arrays (FPGAs), Application-specific Integrated Circuits (ASICs), Application-specific Standard Products (ASSPs), System-on-a-chip systems (SoCs), Complex Programmable Logic Devices (CPLDs), and the like.

<FIG> illustrates the current invention as method <NUM> performed by a computing device to determine an intended input to a user interface from detected gesture inputs. The computing device may be the computing device <NUM> of <FIG>, using elements of <FIG>.

At block <NUM>, the computing device detects positions associated with a gesture that is made by a user of the computing device, where the gesture is made relative to a touchscreen of the computing device.

At block <NUM>, the computing device associates, to the detected positions, a timing profile. In the current invention, associating the timing profile to the positions detected relative to the touchscreen identifies a static position associated with a portion of the gesture, where the static position corresponds to the gesture remaining stationary at one of the detected positions for a period of time.

In some instances, the period of time may be a predetermined period of time that is measured in seconds, such a predetermined period of time that ranges from <NUM> to <NUM> near an end of a gesture. The predetermined period of time may also correspond to a time that is immediately after the user first engaging (e.g., touching his finger to) or immediately prior to the user disengaging (e.g., lifting his finger from) the touchscreen. Thus, a static position can be set as one at which the user, for example, remained static at a time from <NUM> to <NUM> seconds (with <NUM> being when the user's fingered first engaged) when the user disengaged at <NUM> seconds. In the current invention, the period of time is a relative period of time, corresponding to the longest period of time in relation to multiple periods of time associated with multiple, static positions associated with other portions of the gesture. Thus, assume that a gesture lasts <NUM> total seconds, and the longest static positions are <NUM>, <NUM>, <NUM>, and <NUM> seconds. The longest period, and therefore the period having an assumed highest priority, would be the position at which the user's finger was static for <NUM> seconds.

Associating the timing profile to the positions detected relative to the touchscreen may include identifying motion vectors associated with the gesture. The motion vectors may include parameters corresponding to a velocity, a direction, or an acceleration of the gesture. In some instances, the timing profile can identify a weighted average of detected positions associated with a portion of a motion vector having a low relative-velocity (in comparison to other detected positions associated with another portion of the motion vector having a high relative-velocity) in lieu of identifying a static (e.g., stationary) position. Thus, a user's finger moving slowly, indicates a greater likelihood of the user's intention being to select the positions at or ending the slow-moving part of the gesture.

Associating the timing profile to the detected positions may include identifying a type of touch-position for the detected positions. For example, the type of touch-position may correspond to an engage touch-position, where the user touches his finger to the touchscreen, or to a disengage touch-position, where the user lifts his finger from the touchscreen. Other types of touch-positions include a "back-and-forth" touch-position detected over another period of time (e.g., indicating that the user may be trying to "zero in" on a selection) or detecting a "multiple touch" touch-position over another period of time (e.g., indicating reselections due to input errors, a level of interest from the user, and the like).

At block <NUM>, using the detected positions and the associated timing profile, the computing device determines an intended input by the user. In some instances, the determined, intended input may correspond to a position at which the user intends to disengage from the touchscreen. In other instances, the determined, intended input may correspond to a position at which the user intends to engage with the touchscreen, such as an icon or a menu item presented by a display of the touchscreen.

At block <NUM>, the computing device performs an operation corresponding to the determined, intended input. In some instances, performing the operation may include providing an input to an application that launches the application, selects a variable presented by the application, or terminates the application. In other instances, performing the operation may include performing a control function associated with the touchscreen, such as zooming a display of the touchscreen or changing a brightness of the display of the touchscreen.

<FIG> illustrates another example method <NUM> performed by a computing device to determine an intended input to a user interface from gesture positions. The computing device may be the computing device <NUM> of <FIG>, using elements of <FIG> and <FIG>.

At block <NUM>, the computing device associates, to the detected positions, a context. In some instances, associating the context to the positions detected relative to the touchscreen of the computing device may include one or more sensors of the computing device sensing a condition surrounding the computing device, such as an identity of the user or a location of the computing device.

At block <NUM>, using the detected positions and the associated context, the computing device determines an intended input by the user. Determining the intended input by the user may use a machine-learning algorithm executed by a processor of the computing device, where the machine-learning algorithm accounts for variables that include a past behavior of the user, a location of the computing device, or a time of day. In some instances, the machine-learning algorithm may adhere to a neural network model.

Claim 1:
A computing device (<NUM>) comprising:
a user interface (<NUM>) having a display (<NUM>);
a position-detection mechanism (<NUM>);
a processor (<NUM>); and
a computer-readable media (<NUM>) having executable instructions of a position-detection manager (<NUM>) that, when executed by the processor (<NUM>), direct the computing device (<NUM>) to:
detect, through the position-detection mechanism (<NUM>), respective positions (<NUM>, <NUM>, <NUM>) associated with multiple portions of a gesture, the gesture made by a user of the computing device (<NUM>) relative to the user interface (<NUM>), the multiple portions of the gesture comprising at least a first portion of the gesture and a subsequent second portion of the gesture;
associate, to the detected respective positions (<NUM>, <NUM>, <NUM>) of the gesture, a timing profile (<NUM>), the timing profile comprising:
a first duration of time during which the first portion of the gesture is static and remains stationary at a first touch-position; and
a second duration of time during which the subsequent second portion of the gesture is static and remains stationary at a second touch-position that is different than the first touch-position;
determine, using the associated timing profile (<NUM>) and in response to the first duration of time of the first portion of the gesture exceeding the second duration of time of the subsequent second portion of the gesture, that an intended input made by the user corresponds to the first touch-position of the first portion of the gesture; and
performing an operation corresponding to the determined, intended input.