Managing correctly X/Y swap and X or Y inversion: - detect swap and inversion modification - take into account for inversion in calibration computation since Evdev is doing inversion after calibration. - Mainly tested for Evdev based driver. To be tested for USB.

Sorting outputs to stdout in such a way to only get calibration commands at output => scriptable.

Author: tonio73

src/calibrator.cpp

@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2009 Tias Guns
  * Copyright (c) 2009 Soren Hauberg
+ * Copyright (c) 2011 Antoine Hue
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -26,46 +27,37 @@
 #include <iostream>
 #include <fstream>
 #include <cstring>
+#include <stdarg.h>
 
 #include "calibrator.hh"
 
-Calibrator::Calibrator(const char* const device_name0, const XYinfo& axys0,
-    const bool verbose0, const int thr_misclick, const int thr_doubleclick, const OutputType output_type0, const char* geometry0)
-  : device_name(device_name0), old_axys(axys0), verbose(verbose0), num_clicks(0), threshold_doubleclick(thr_doubleclick), threshold_misclick(thr_misclick), output_type(output_type0), geometry(geometry0)
-{
-}
+// static instance
+bool Calibrator::verbose = false;
 
-void Calibrator::set_threshold_doubleclick(int t)
-{
-    threshold_doubleclick = t;
-}
-
-void Calibrator::set_threshold_misclick(int t)
-{
-    threshold_misclick = t;
-}
-
-int Calibrator::get_numclicks()
+Calibrator::Calibrator(const char* const device_name0, const XYinfo& axys0,
+    const int thr_misclick, const int thr_doubleclick, const OutputType output_type0, const char* geometry0)
+: device_name(device_name0),
+    threshold_doubleclick(thr_doubleclick), threshold_misclick(thr_misclick),
+    output_type(output_type0), geometry(geometry0)
 {
-    return num_clicks;
-}
+    old_axys = axys0;
 
-const char* Calibrator::get_geometry()
-{
-    return geometry;
+    clicked.num = 0;
+    //clicked.x(NUM_POINTS);
+    //clicked.y(NUM_POINTS);
 }
 
 bool Calibrator::add_click(int x, int y)
 {
     // Double-click detection
-    if (threshold_doubleclick > 0 && num_clicks > 0) {
-        int i = num_clicks-1;
+    if (threshold_doubleclick > 0 && clicked.num > 0) {
+        int i = clicked.num - 1;
         while (i >= 0) {
-            if (abs(x - clicked_x[i]) <= threshold_doubleclick
-                && abs(y - clicked_y[i]) <= threshold_doubleclick) {
+            if (abs(x - clicked.x[i]) <= threshold_doubleclick
+                && abs(y - clicked.y[i]) <= threshold_doubleclick) {
                 if (verbose) {
-                    printf("DEBUG: Not adding click %i (X=%i, Y=%i): within %i pixels of previous click\n",
-                        num_clicks, x, y, threshold_doubleclick);
+                    trace ( "Not adding click %i (X=%i, Y=%i): within %i pixels of previous click\n",
+                         clicked.num, x, y, threshold_doubleclick);
                 }
                 return false;
             }
@@ -74,52 +66,61 @@ bool Calibrator::add_click(int x, int y)
     }
 
     // Mis-click detection
-    if (threshold_misclick > 0 && num_clicks > 0) {
+    if (threshold_misclick > 0 && clicked.num > 0) {
         bool misclick = true;
 
-        if (num_clicks == 1) {
-            // check that along one axis of first point
-            if (along_axis(x,clicked_x[0],clicked_y[0]) ||
-                along_axis(y,clicked_x[0],clicked_y[0]))
-                misclick = false;
-        } else if (num_clicks == 2) {
-            // check that along other axis of first point than second point
-            if ((along_axis(y,clicked_x[0],clicked_y[0]) &&
-                 along_axis(clicked_x[1],clicked_x[0],clicked_y[0])) ||
-                (along_axis(x,clicked_x[0],clicked_y[0]) &&
-                 along_axis(clicked_y[1],clicked_x[0],clicked_y[0])))
-                misclick = false;
-        } else if (num_clicks == 3) {
-            // check that along both axis of second and third point
-            if ((along_axis(x,clicked_x[1],clicked_y[1]) &&
-                 along_axis(y,clicked_x[2],clicked_y[2])) ||
-                (along_axis(y,clicked_x[1],clicked_y[1]) &&
-                 along_axis(x,clicked_x[2],clicked_y[2])))
-                misclick = false;
+        switch (clicked.num) {
+            case 1:
+                // check that along one axis of first point
+                if (along_axis(x,clicked.x[UL],clicked.y[UL]) ||
+                        along_axis(y,clicked.x[UL],clicked.y[UL]))
+                {
+                    misclick = false;
+                } else {
+                    trace ( "Mis-click detected, click %i (X=%i, Y=%i) not aligned with click 0 (X=%i, Y=%i) (threshold=%i)\n",
+                            clicked.num, x, y, clicked.x[UL], clicked.y[UL], threshold_misclick);
+                }
+                break;
+
+            case 2:
+                // check that along other axis of first point than second point
+                if ((along_axis( y, clicked.x[UL], clicked.y[UL])
+                            && along_axis( clicked.x[UR], clicked.x[UL], clicked.y[UL]))
+                        || (along_axis( x, clicked.x[UL], clicked.y[UL])
+                            && along_axis( clicked.y[UR], clicked.x[UL], clicked.y[UL])))
+                {
+                    misclick = false;
+                } else {
+                    trace ( "Mis-click detected, click %i (X=%i, Y=%i) not aligned with click 0 (X=%i, Y=%i) or click 1 (X=%i, Y=%i) (threshold=%i)\n",
+                            clicked.num, x, y, clicked.x[UL], clicked.y[UL], clicked.x[UR], clicked.y[UR], threshold_misclick);
+                }
+                break;
+
+            case 3:
+                // check that along both axis of second and third point
+                if ( ( along_axis( x, clicked.x[UR], clicked.y[UR])
+                            &&   along_axis( y, clicked.x[LL], clicked.y[LL]) )
+                        ||( along_axis( y, clicked.x[UR], clicked.y[UR])
+                            &&  along_axis( x, clicked.x[LL], clicked.y[LL]) ) )
+                {
+                    misclick = false;
+                } else {
+                    trace ( "Mis-click detected, click %i (X=%i, Y=%i) not aligned with click 1 (X=%i, Y=%i) or click 2 (X=%i, Y=%i) (threshold=%i)\n",
+                            clicked.num, x, y, clicked.x[UR], clicked.y[UR], clicked.x[LL], clicked.y[LL], threshold_misclick);
+                }
         }
 
         if (misclick) {
-            if (verbose) {
-                if (num_clicks == 1)
-                    printf("DEBUG: Mis-click detected, click %i (X=%i, Y=%i) not aligned with click 0 (X=%i, Y=%i) (threshold=%i)\n", num_clicks, x, y, clicked_x[0], clicked_y[0], threshold_misclick);
-                else if (num_clicks == 2)
-                    printf("DEBUG: Mis-click detected, click %i (X=%i, Y=%i) not aligned with click 0 (X=%i, Y=%i) or click 1 (X=%i, Y=%i) (threshold=%i)\n", num_clicks, x, y, clicked_x[0], clicked_y[0], clicked_x[1], clicked_y[1], threshold_misclick);
-                else if (num_clicks == 3)
-                    printf("DEBUG: Mis-click detected, click %i (X=%i, Y=%i) not aligned with click 1 (X=%i, Y=%i) or click 2 (X=%i, Y=%i) (threshold=%i)\n", num_clicks, x, y, clicked_x[1], clicked_y[1], clicked_x[2], clicked_y[2], threshold_misclick);
-            }
-
             reset();
             return false;
         }
     }
 
-    clicked_x[num_clicks] = x;
-    clicked_y[num_clicks] = y;
-    num_clicks++;
-
-    if (verbose)
-        printf("DEBUG: Adding click %i (X=%i, Y=%i)\n", num_clicks-1, x, y);
+    clicked.x.push_back(x);
+    clicked.y.push_back(y);
+    clicked.num++;
 
+    trace("Adding click %i (X=%i, Y=%i)\n", clicked.num-1, x, y);
     return true;
 }
 
@@ -129,47 +130,86 @@ inline bool Calibrator::along_axis(int xy, int x0, int y0)
             (abs(xy - y0) <= threshold_misclick));
 }
 
+/// Compute calibration on 1 axis
+/// (all +0.5 for float to int rounding)
+void Calibrator::process_axys( int screen_dim, const AxisInfo &previous, std::vector<int> &clicked, AxisInfo &updated )
+{
+    // These are scaled using the values of old_axys
+    const float old_scale = (previous.max - previous.min)/(float)screen_dim;
+
+    // Sort to get lowest two and highest two whatever is the orientation
+    std::sort( clicked.begin(), clicked.end());
+    // If inverted, must undo inversion since calibration is before in evdev driver.
+    if ( previous.invert ) {
+        updated.min = ( (2*screen_dim - clicked[2] - clicked[3]) * old_scale/2 ) + previous.min + 0.5;
+        updated.max = ( (2*screen_dim - clicked[0] - clicked[1]) * old_scale/2 ) + previous.min + 0.5;
+    } else {
+        updated.min = ( (clicked[0] + clicked[1]) * old_scale/2 ) + previous.min + 0.5;
+        updated.max = ( (clicked[2] + clicked[3]) * old_scale/2 ) + previous.min + 0.5;
+    }
+
+    // Add/subtract the offset that comes from not having the points in the
+    // corners (using the new scale, assumed better than previous)
+    const int new_delta = (updated.max - updated.min) / (float)(num_blocks - 2) + 0.5;
+    updated.min -= new_delta;
+    updated.max += new_delta;
+}
+
+// Compute calibration and correct orientation from captured coordinates
 bool Calibrator::finish(int width, int height)
 {
-    if (get_numclicks() != 4) {
+    if (get_numclicks() != NUM_POINTS) {
         return false;
     }
 
-    // Should x and y be swapped?
-    const bool swap_xy = (abs (clicked_x [UL] - clicked_x [UR]) < abs (clicked_y [UL] - clicked_y [UR]));
-    if (swap_xy) {
-        std::swap(clicked_x[LL], clicked_x[UR]);
-        std::swap(clicked_y[LL], clicked_y[UR]);
+    trace ( "Screen size=%dx%d\n", width, height );
+    trace ( "Expected screen coordinates, x.min=%d, x.max=%d, y.min=%d, y.max=%d\n",
+            width/num_blocks, width-width/num_blocks,
+            height/num_blocks, height - height/num_blocks);
+
+    // Evdev v2.3.2 order to compute coordinates from peripheral to screen:
+    // - swap xy axis
+    // - calibration (offset and scale)
+    // - invert x, invert y axis
+
+    trace ( "Previous orientation: swap_xy=%d, invert_x=%d, invert_y=%d\n", old_axys.swap_xy, old_axys.x.invert, old_axys.y.invert );
+
+    // Compute orientation modifications from existing (if orientation is already corrected, no change)
+    // Start reverse order vs. evdev: from screen to peripheral
+
+    // Check if axes are inverted ?
+    bool invert_x = false, invert_y = false;
+    if ( clicked.x[UL] > clicked.x[LR] ) {
+        invert_x = true;
     }
 
-    // Compute min/max coordinates.
-    XYinfo axys;
-    // These are scaled using the values of old_axys
-    const float scale_x = (old_axys.x_max - old_axys.x_min)/(float)width;
-    axys.x_min = ((clicked_x[UL] + clicked_x[LL]) * scale_x/2) + old_axys.x_min;
-    axys.x_max = ((clicked_x[UR] + clicked_x[LR]) * scale_x/2) + old_axys.x_min;
-    const float scale_y = (old_axys.y_max - old_axys.y_min)/(float)height;
-    axys.y_min = ((clicked_y[UL] + clicked_y[UR]) * scale_y/2) + old_axys.y_min;
-    axys.y_max = ((clicked_y[LL] + clicked_y[LR]) * scale_y/2) + old_axys.y_min;
+    if ( clicked.y[UL] > clicked.y[LR] ) {
+        invert_y = true;
+    }
 
-    // Add/subtract the offset that comes from not having the points in the
-    // corners (using the same coordinate system they are currently in)
-    const int delta_x = (axys.x_max - axys.x_min) / (float)(num_blocks - 2);
-    axys.x_min -= delta_x;
-    axys.x_max += delta_x;
-    const int delta_y = (axys.y_max - axys.y_min) / (float)(num_blocks - 2);
-    axys.y_min -= delta_y;
-    axys.y_max += delta_y;
+    XYinfo new_axys; // new axys origin and scaling
 
+    // Should x and y be swapped
+    const bool swap_xy = (abs (clicked.x [UL] - clicked.x [UR]) < abs (clicked.y [UL] - clicked.y [UR]));
+    trace ( "Orientation modifications: swap_xy=%d, invert_x=%d, invert_y=%d\n", swap_xy, invert_x, invert_y);
 
-    // If x and y has to be swapped we also have to swap the parameters
+    /// Compute calibration
     if (swap_xy) {
-        std::swap(axys.x_min, axys.y_max);
-        std::swap(axys.y_min, axys.x_max);
+        process_axys( height, old_axys.x, clicked.y, new_axys.x );
+        process_axys( width, old_axys.y, clicked.x, new_axys.y );
+    } else {
+        process_axys( width, old_axys.x, clicked.x, new_axys.x );
+        process_axys( height, old_axys.y, clicked.y, new_axys.y );
     }
 
+    new_axys.swap_xy = old_axys.swap_xy ^ swap_xy;
+    new_axys.x.invert = old_axys.x.invert ^ invert_x;
+    new_axys.y.invert = old_axys.y.invert ^ invert_y;
+
+    trace ( "New orientation: swap_xy=%d, invert_x=%d, invert_y=%d\n", new_axys.swap_xy, new_axys.x.invert, new_axys.y.invert );
+
     // finish the data, driver/calibrator specific
-    return finish_data(axys, swap_xy);
+    return finish_data(new_axys);
 }
 
 const char* Calibrator::get_sysfs_name()
@@ -202,8 +242,7 @@ bool Calibrator::is_sysfs_name(const char* name) {
                     std::string devname;
                     std::getline(ifile, devname);
                     if (devname == name) {
-                        if (verbose)
-                            printf("DEBUG: Found that '%s' is a sysfs name.\n", name);
+                        trace("Found that '%s' is a sysfs name.\n", name);
                         return true;
                     }
                 }
@@ -213,9 +252,8 @@ bool Calibrator::is_sysfs_name(const char* name) {
     }
     (void) closedir(dp);
 
-    if (verbose)
-        printf("DEBUG: Name '%s' does not match any in '%s/event*/%s'\n",
-                    name, SYSFS_INPUT, SYSFS_DEVNAME);
+    trace ("Name '%s' does not match any in '%s/event*/%s'\n",
+            name, SYSFS_INPUT, SYSFS_DEVNAME);
     return false;
 }
 
@@ -227,7 +265,7 @@ bool Calibrator::has_xorgconfd_support(Display* dpy) {
         display = XOpenDisplay(NULL);
 
     if (display == NULL) {
-        fprintf(stderr, "Unable to connect to X server\n");
+        error ( "Unable to connect to X server\n");
         exit(1);
     }
 
@@ -241,3 +279,46 @@ bool Calibrator::has_xorgconfd_support(Display* dpy) {
 
     return has_support;
 }
+
+/// Write calibration output (to stdout)
+void Calibrator::output ( const char *format, ... )
+{
+    va_list vl;
+    va_start ( vl, format );
+    vprintf ( format, vl );
+    va_end ( vl );
+}
+
+/// Dump debug information if verbose activated
+void Calibrator::trace ( const char *format, ...)
+{
+    if ( verbose == true ) {
+        printf ( "DEBUG: ");
+        va_list vl;
+        va_start ( vl, format );
+        vprintf ( format, vl );
+        va_end ( vl );
+    }
+}
+
+/// Information to user, if verbose mode activated
+void Calibrator::info ( const char *format, ... )
+{
+    if ( verbose == true ) {
+        printf ( "INFO: ");
+        va_list vl;
+        va_start ( vl, format );
+        vprintf ( format, vl );
+        va_end ( vl );
+    }
+}
+
+/// Error (non fatal)
+void Calibrator::error ( const char *format, ...)
+{
+    fprintf ( stderr, "ERROR: ");
+    va_list vl;
+    va_start ( vl, format );
+    vprintf ( format, vl );
+    va_end ( vl );
+}