Attachment 137745 Details for Bug 105306 – hysteresis-test.c

hysteresis-test.c

test.c (text/plain), 5.02 KB, created by Peter Hutterer on 2018-03-02 04:01:10 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Peter Hutterer

Created: 2018-03-02 04:01:10 UTC

Size: 5.02 KB

patch

obsolete

>#include <stdio.h>
>#include <stdlib.h>
>#include <math.h>
>
>#define max(a, b) ((a > b) ? a : b)
>#define min(a, b) ((a < b) ? a : b)
>
>struct device_coords { int x; int y; };
>
>/* from comment 12 in https://bugs.freedesktop.org/show_bug.cgi?id=105108#c12 */
>static inline struct device_coords
>evdev_hysteresis_105108(const struct device_coords point,
>                        const struct device_coords center,
>                        const struct device_coords margin)
>{
>	struct device_coords diff;
>	struct device_coords p;
>	int offset = 0;
>	float ratio;
>
>	diff.x = point.x - center.x; /* -3 */
>	diff.y = point.y - center.y; /* -9 */
>
>	/* do we need to test for a real circle here? */
>	if (abs(diff.x) <= margin.x && abs(diff.y) <= margin.y)
>		return center;
>
>	/* If we're outside the margin, we always move back by
>	 * the margin, never any other value. So we can use a few tricks to
>	 * make this easier to calculate because there are a finite number
>	 * of vectors we use to move back (2*margin). And the margin is
>	 * usually small, so there's rounding anyway to meet the integer
>	 * coordinates. Thus the algorithm is:
>	 *
>	 * For a movement vector (x, y), calculate the ratio y:x.
>	 * Multiply that ratio by the margin, the vector
>	 * (-margin, -int(margin * ratio)) is now the vector to subtract
>	 * from (x, y). Add the right x/y swapping and the infinity
>	 * exceptions and we're good.
>	 *
>	 * Example for margin 8:
>	 * (20, 1) -> ratio 0.05 -> vec (-8, 0) -> final position (12, 1)
>	 * (20, 10) -> ratio 0.5 -> vec (-8, -4) -> final position (12, 6)
>	 * (20, 20) -> ratio 1.0 -> vec (-8, -8) -> final position (12, 12)
>	 *
>	 * And if y > x we swap things around:
>	 * (10, 20) -> ratio 0.5 -> vec (-4, -8) -> final position (6, 12)
>	 * ...
>	 */
>
>	p = point;
>	if (diff.x == 0 || diff.y == 0)
>		goto out;
>	else
>		ratio = 1.0 * max(abs(diff.x), abs(diff.y))/
>				min(abs(diff.x), abs(diff.y));
>
>	offset = (int)(margin.x/ratio);
>
>out:
>	if (abs(diff.x) >= abs(diff.y)) {
>		p.x -= margin.x * ((diff.x > 0) ? 1 : -1);
>		p.y -= offset * ((diff.y > 0) ? 1 : -1);
>	} else {
>		p.x -= offset * ((diff.x > 0) ? 1 : -1);
>		p.y -= margin.x * ((diff.y > 0) ? 1 : -1);
>	}
>
>	return p;
>}
>
>/* From attachment in bug https://bugs.freedesktop.org/show_bug.cgi?id=105306 */
>static inline struct device_coords
>evdev_hysteresis_105306(const struct device_coords *in,
>                        const struct device_coords *center,
>                        const struct device_coords *margin)
>{
>	int dx = in->x - center->x;
>	int dy = in->y - center->y;
>	int dx2 = dx * dx;
>	int dy2 = dy * dy;
>	int a = margin->x;
>	int b = margin->y;
>	double normalized_finger_distance, finger_distance, margin_distance;
>	double lag_x, lag_y;
>	struct device_coords result;
>
>	if (!a || !b)
>		return *in;
>
>	/*
>	 * Basic equation for an ellipse of radii a,b:
>	 *   xÂ²/aÂ² + yÂ²/bÂ² = 1
>	 * But we start by making a scaled ellipse passing through the
>	 * relative finger location (dx,dy). So the scale of this ellipse is
>	 * the ratio of finger_distance to margin_distance:
>	 *   dxÂ²/aÂ² + dyÂ²/bÂ² = normalized_finger_distanceÂ²
>	 */
>	normalized_finger_distance = sqrt((double)dx2 / (a * a) +
>					  (double)dy2 / (b * b));
>
>	/* Which means anything less than 1 is within the elliptical margin */
>	if (normalized_finger_distance < 1.0)
>		return *center;
>
>	finger_distance = sqrt(dx2 + dy2);
>	margin_distance = finger_distance / normalized_finger_distance;
>
>	/*
>	 * Now calculate the x,y coordinates on the edge of the margin ellipse
>	 * where it intersects the finger vector. Shortcut: We achieve this by
>	 * finding the point with the same gradient as dy/dx.
>	 */
>	if (dx) {
>		double gradient = (double)dy / dx;
>		lag_x = margin_distance / sqrt(gradient * gradient + 1);
>		lag_y = sqrt((margin_distance + lag_x) *
>			     (margin_distance - lag_x));
>	} else {  /* Infinite gradient */
>		lag_x = 0.0;
>		lag_y = margin_distance;
>	}
>
>	/*
>	 * 'result' is the centre of an ellipse (radii a,b) which has been
>	 * dragged by the finger moving inside it to 'in'. The finger is now
>	 * touching the margin ellipse at some point: (Â±lag_x,Â±lag_y)
>	 */
>	result.x = (dx >= 0) ? in->x - lag_x : in->x + lag_x;
>	result.y = (dy >= 0) ? in->y - lag_y : in->y + lag_y;
>	return result;
>}
>
>const struct device_coords margin = { 8, 8 };
>const struct device_coords center = { 0, 0 };
>
>void print_one(int x, int y)
>{
>    struct device_coords point = {x, y};
>    struct device_coords result;
>    //result = _evdev_hysteresis_105306(&point, &center, &margin);
>    result = evdev_hysteresis_105108(point, center, margin);
>    printf("%3d %3d to %3d %3d\n", point.x, point.y, result.x, result.y);
>}
>
>
>int main(void) {
>    //print_one(-3, 9);
>
>    for (int x = -margin.x * 2; x <= margin.x * 2; x++) {
>        for (int y = -margin.y * 2; y <= margin.y * 2; y++) {
>            struct device_coords point = {x, y};
>            struct device_coords result;
>
>            result = evdev_hysteresis_105306(&point, &center, &margin);
>            //result = evdev_hysteresis_105108(point, center, margin);
>
>            printf("%3d %3d to %3d %3d\n", point.x, point.y, result.x, result.y);
>        }
>    }
>
>    return 0;
>}

Actions: View

Attachments on bug 105306: 137715 | 137744 | 137745 | 137746

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.