RotoView Dynamic Response Algorithms
The RotoView Dynamic Response algorithms determine the speed or distance of view navigation in response to the tilt and movement of the hand held device. During the Dynamic Scroll mode, tilt changes control the speed of scrolling. During the Proportional Scroll mode, tilt changes are mapped directly onto the screen view position on the contents view.
The Dynamic Response algorithms exhibit the following features:
We refer to the relationship between the relative tilt (the measured current tilt minus the baseline tilt) and the resulting scrolling rate as the scrolling rate graph G. Fig. 1 illustrates an example of such graph that may be used during Dynamic Scroll mode.
The sensor data is taken as
a relative tilt, by subtracting the current sensor
tilt reading and the reference tilt baseline captured
at the start of scrolling. The blue
graph illustrates a simple linear scrolling rate graph.
This graph can be represented mathematically by
scrolling_rate = k* relative_tilt.
Therefore, as mentioned in item of 2 of the feature list above, the time response curve is a graph R(t) of the linear coeficients (k values) over time, providing the scrolling rate directly by
scrolling_rate(t) = R(t)* relative_tilt(t).
The red graph illustrates a more complex scrolling rate graph that includes several non-linear regions. In the first region, there are two threshold points between which the view navigation is halted. This is needed to eliminate normal hand shaking. The red curve also includes a clipping region, designed to eliminate abnormally large relative tilts. Such a clipping region may be useful when a special hand gestures (e.g. an up down shake) are used to activate the view navigation.
The scrolling rate is computed by
scrolling_rate = G * relative_tilt,
where the * operation is the mapping operation performed by the red graph. Therefore, as mentioned in item of 3 of the feature list above, the relative time response curve Rel_R(t) is a relative scaling factor that is used to multiply the resultant non-linear conversion, getting the actual scrolling rate by
scrolling_rate(t) = Rel_R(t) *G * Relative_tilt(t).
The scrolling rate graph G may be an actual graph stored in memory, or may be implemented by one or more mathematical functions. A minimal scrolling rate graph may be as simple as a single value, while a complex scrolling rate graph comprises multiple values. Different scrolling rate graphs may be used for each scrolling direction, and each application may select a different set of scrolling rate graphs that benefit each particular application. For example, a map browsing application (that must scroll in any direction) may use different scrolling rate graphs than a web browser application (that typically scrolls the screen vertically).
The scrolling rate graph G can also have non-linear sensitivities, based upon the magnitude of the sensor data as shown in Fig. 2. Here the scrolling rate graph G is symmetrically divided into three relative tilt regions between the the threshold region and the noise clipping region that were described in Fig. 1. A small relative tilt change in the first region beyond the threshold region causes larger scrolling speed changes compared to a similar tilt change at the next tilt region.
We should note that the term "non-linear" is used loosely here to indicate that the response to the sensor data is not necessarily approximated by a single line (like the blue line in Fig. 1). In many cases, the response graph may be approximated by multiple short "linear" regions, as shown in Fig.2.
The Dynamic Response algorithms illustrated in Fig. 2 can be also used for the Proportional Scroll mode, where the vertical axis of the graph refers to screen scrolling position instead of the screen scrolling speed (see, for example, our US patents 9,181,760 and 9,348,435).
The Dynamic Response algorithms allows the Dynamic Scroll mode to achieve fast scrolling with minimal rotations, to overcome the limitations of the Proportional Scroll mode. It achieves this goal with the RotoView time response graph that dynamically changes the response to the sensor data as the scrolling progresses.
This allows the scrolling to start very rapidly, in what we call the THROW gesture, so that the user can quickly bring the screen view to the general target area within the contents view. The THROW gesture is then automatically followed with a refined slow scrolling which we call the GLIDE gesture.
Fig. 3 illustrates the dynamic response along one of the axis as result of changing the relevant time response curve dynamically based on the duration of the scrolling action. The bottom graph (green) shows the raw sensor data over time, representing two consequent side-to-side tilts of the hand held device. The top graph (red) shows the view navigation rate by which RotoView responds to the sensor data.
We can see that the navigation rate is coarse (strong) during the first tilt, representing the THROW gesture, and it dynamically reduces to provide a fine navigation GLIDE during the second side-to-side tilt.
In Dynamic Scroll mode, we define the abstract relation between the view navigation rate and the sensor data along each axis as the sensitivity. The sensitivity of both axis may be different. We can similarly define a Normalized Time Response Graph as time response curve with normalized sensitivity values and an extendable time length. The time axis of such normalized time response graph (horizontal length) should be mapped to a desired time length. The RotoView app, for example, maps all of the time response graphs to 5 seconds, but the user can change this value.
The vertical axis of the Normazlized Time Response Graph is the relative intensity, and is further scaled within the RotoView algorithms. In our current RotoView app implementation, the vertical axis is divided to THROW gestures for values that are above 5.0, and GLIDE gestures below 5.0. In the current app implementation, values from 5 and above are interpreted in a stronger response based on the notion of Non-linear response curve of Fig. 1 and 2. This enables the THROW gesture in the app to achieve stronger speed so that small rotations during THROW allow the user to reach all edges of the magnified contents view rapidly. In terms of the curve response, a value of 8.0 produces much more than two times the scrolling speed of a value of 4.0 which is interpreted as GLIDE. Of course, other implementationss can use logarithmic scale for vertical axis to achieve the same result.
The following screenshots show several examples of time response graphs as captured from the RotoView app.
Typical response start with the THROW gesture (coarse navigation) followed by a GLIDE gesture (fine navigation) from which the navigation mode is exited.
This fixed response graph can be selected for instances were the stored virtual view is not much larger than the screen view. Fixed response are dealt as a GLIDE gesture.
This normalized time response graph emulates a delayed "Flick" gesture. It starts from a short GLIDE followed by a strong THROW gesture that produces a sharp scrolling before returning to fine navigation.
In the first example, the intensity for the first three time slots of navigation mode is set to 8, well within the THROW region for initial coarse view navigation. From time slot 3 to 5 the intensity goes down to 3, thus providing a GLIDE gesture (fine scrolling). This graph results in the behavior of Fig. 3.
If the scrolling process continues beyond the time span of the time response graph, scrolling speed is determined by the last value of the graph. The actual RotoView app includes several touch gestures that allow the user to restart the response graph, or to abort the THROW portion quickly.
The second example shows the use of a simple fixed response. This may be selected automatically (or by the user) for instances where the stored view is not much larger than the actual screen view. The last example emulates the "flick" action, particularly if the graph is mapped to a short time length.
The Dynamic Response algorithms create a natural subliminal closed loop comprising the user's hand movements and the resultant navigation. By eliminating the need for one-to-one mapping between a tilt or hand movement and the exact view positioning, RotoView allows for smoother and more intuitive view navigation. Users can setup the Dynamic Response to their exact preference to achieve the most comfortable results.
The Dynamic Response algorithms further enables the use of sensors with lower accuracy since there is no need for an exact alignment of the displayed view with the relative tilt. This may have important low cost benefits for mass production.
Additional issues relating to the user interface experience with RotoView are detailed at www.rotoview.com/rv_user_interface.htm.
The RotoView Dynamic Response algorithms are protected by our patents and copyrighted software. Partial implementation in our RotoView apps introduces these algorithms to potential licensees. Further information requires a Non-Disclosure Agreement. Please contact Scott LaRoche at 1+ (281) 879-6226, e-mail email@example.com.