提交: 084adde93435e7f74e0dfdded5a5bb0ba4ae90a0 - xinput_calibrator (git)

A generic touchscreen calibration program for X.Org

Commit MetaInfo

• 修订版: 084adde93435e7f74e0dfdded5a5bb0ba4ae90a0 (tree)
• 时间: 2012-06-19 06:36:45
• 作者: Tias Guns <tias@ulys...>
• Commiter: Tias Guns

Log Message

Merge branch 'tester'

A tester object to faithfully test the calibration routines.
This will be reused for testing the evdev calibration (which
is non-standard) as well.

更改概述

• modified: src/Makefile.am
• modified: src/calibrator.cpp
• modified: src/calibrator.hh
• modified: src/calibrator/Makefile.am
• add: src/calibrator/Tester.cpp
• add: src/calibrator/Tester.hpp
• add: src/tester.cpp

差异

--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -30,7 +30,7 @@ SUBDIRS = \
 
 AM_CXXFLAGS = -Wall -ansi -pedantic
 
-bin_PROGRAMS = xinput_calibrator
+bin_PROGRAMS = xinput_calibrator tester
 
 COMMON_SRCS=calibrator.cpp calibrator/XorgPrint.cpp calibrator/Evdev.cpp calibrator/Usbtouchscreen.cpp main_common.cpp
 
@@ -51,6 +51,10 @@ xinput_calibrator_CXXFLAGS = $(XINPUT_CFLAGS) $(GTKMM_CFLAGS) $(AM_CXXFLAGS)
 xinput_calibrator_LDFLAGS = -Wl,--as-needed
 endif
 
+tester_SOURCES = tester.cpp calibrator.cpp calibrator/Tester.cpp
+tester_LDADD = $(XINPUT_LIBS) $(XRANDR_LIBS) $(X11_LIBS)
+tester_CXXFLAGS = $(XINPUT_CFLAGS) $(X11_CFLAGS) $(XRANDR_CFLAGS) $(AM_CXXFLAGS)
+
 EXTRA_DIST = \
 	calibrator.cpp \
 	calibrator.hh \

--- a/src/calibrator.cpp
+++ b/src/calibrator.cpp
@@ -251,3 +251,71 @@ bool Calibrator::has_xorgconfd_support(Display* dpy) {
 
     return has_support;
 }
+
+/*
+ * FROM xf86Xinput.c
+ *
+ * Cx     - raw data from touch screen
+ * to_max - scaled highest dimension
+ *          (remember, this is of rows - 1 because of 0 origin)
+ * to_min  - scaled lowest dimension
+ * from_max - highest raw value from touch screen calibration
+ * from_min  - lowest raw value from touch screen calibration
+ *
+ * This function is the same for X or Y coordinates.
+ * You may have to reverse the high and low values to compensate for
+ * different orgins on the touch screen vs X.
+ *
+ * e.g. to scale from device coordinates into screen coordinates, call
+ * xf86ScaleAxis(x, 0, screen_width, dev_min, dev_max);
+ */
+int
+xf86ScaleAxis(int Cx, int to_max, int to_min, int from_max, int from_min)
+{
+    int X;
+    int64_t to_width = to_max - to_min;
+    int64_t from_width = from_max - from_min;
+
+    if (from_width) {
+        X = (int) (((to_width * (Cx - from_min)) / from_width) + to_min);
+    }
+    else {
+        X = 0;
+        printf("Divide by Zero in xf86ScaleAxis\n");
+        exit(1);
+    }
+
+    if (X > to_max)
+        X = to_max;
+    if (X < to_min)
+        X = to_min;
+
+    return X;
+}
+
+// same but without rounding to min/max
+int
+scaleAxis(int Cx, int to_max, int to_min, int from_max, int from_min)
+{
+    int X;
+    int64_t to_width = to_max - to_min;
+    int64_t from_width = from_max - from_min;
+
+    if (from_width) {
+        X = (int) (((to_width * (Cx - from_min)) / from_width) + to_min);
+    }
+    else {
+        X = 0;
+        printf("Divide by Zero in scaleAxis\n");
+        exit(1);
+    }
+
+    /* no rounding to max/min
+    if (X > to_max)
+        X = to_max;
+    if (X < to_min)
+        X = to_min;
+    */
+
+    return X;
+}

--- a/src/calibrator.hh
+++ b/src/calibrator.hh
@@ -27,8 +27,12 @@
 
 #include <stdexcept>
 #include <X11/Xlib.h>
+#include <stdio.h>
 #include <vector>
 
+int xf86ScaleAxis(int Cx, int to_max, int to_min, int from_max, int from_min);
+int scaleAxis(int Cx, int to_max, int to_min, int from_max, int from_min);
+
 /*
  * Number of blocks. We partition the screen into 'num_blocks' x 'num_blocks'
  * rectangles of equal size. We then ask the user to press points that are
@@ -91,6 +95,18 @@ struct XYinfo {
     void do_swap_xy() {
         swap_xy = !swap_xy;
     }
+
+    void do_xf86ScaleAxis(XYinfo& to, XYinfo& from) {
+        x.min = xf86ScaleAxis(x.min, to.x.max, to.x.min, from.x.max, from.x.min);
+        x.max = xf86ScaleAxis(x.max, to.x.max, to.x.min, from.x.max, from.x.min);
+        y.min = xf86ScaleAxis(y.min, to.y.max, to.y.min, from.y.max, from.y.min);
+        y.max = xf86ScaleAxis(y.max, to.y.max, to.y.min, from.y.max, from.y.min);
+    }
+
+    void print(const char* xtra="\n") {
+        printf("XYinfo: x.min=%i, x.max=%i, y.min=%i, y.max=%i, swap_xy=%i, invert_x=%i, invert_y=%i%s",
+               x.min, x.max, y.min, y.max, swap_xy, x.invert, y.invert, xtra);
+    }
 };
 
 /// Names of the points

--- a/src/calibrator/Makefile.am
+++ b/src/calibrator/Makefile.am
@@ -1,4 +1,5 @@
 EXTRA_DIST = \
 	Evdev.cpp \
 	Usbtouchscreen.cpp \
-	XorgPrint.cpp
+	XorgPrint.cpp \
+	Tester.cpp

--- /dev/null
+++ b/src/calibrator/Tester.cpp
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2009 Tias Guns
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "calibrator/Tester.hpp"
+
+#include <cstdio>
+
+CalibratorTester::CalibratorTester(const char* const device_name0, const XYinfo& axys0, const int thr_misclick, const int thr_doubleclick, const OutputType output_type, const char* geometry)
+  : Calibrator(device_name0, axys0, thr_misclick, thr_doubleclick, output_type, geometry)
+{
+    //printf("Starting test driver\n");
+}
+
+bool CalibratorTester::finish_data(const XYinfo axis)
+{
+    new_axis = axis;
+
+    return true;
+}
+
+XYinfo CalibratorTester::emulate_driver(XYinfo& raw, bool useNewAxis, XYinfo screen, XYinfo device) {
+    XYinfo calibAxis;
+    if (useNewAxis)
+        calibAxis = new_axis;
+    else
+        calibAxis = old_axys;
+
+    /**
+     * The most simple and intuitive calibration implementation
+     * if only all drivers sticked to this...
+     * Note that axis inversion is automatically supported
+     * by the ScaleAxis implementation (swapping max/min on
+     * one axis will result in the inversion being calculated)
+     */
+
+    // placeholder for the new coordinates
+    XYinfo result(raw);
+
+    // swap coordinates if asked
+    if (calibAxis.swap_xy) {
+        result.x.min = raw.y.min;
+        result.x.max = raw.y.max;
+        result.y.min = raw.x.min;
+        result.y.max = raw.x.max;
+    }
+
+    result.do_xf86ScaleAxis(device, calibAxis);
+
+    // the last step is usually done by the X server,
+    // or transparently somewhere on the way
+    result.do_xf86ScaleAxis(screen, device);
+    return result;
+}

--- /dev/null
+++ b/src/calibrator/Tester.hpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2009 Tias Guns
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef CALIBRATOR_TESTER_HPP
+#define CALIBRATOR_TESTER_HPP
+
+#include "calibrator.hh"
+
+/***************************************
+ * Class for generic Xorg driver,
+ * outputs new Xorg.conf and FDI policy, on stdout
+ ***************************************/
+class CalibratorTester: public Calibrator
+{
+protected:
+    // store the new axis for use in driver emulation
+    XYinfo new_axis;
+
+public:
+    CalibratorTester(const char* const device_name, const XYinfo& axys,
+        const int thr_misclick=0, const int thr_doubleclick=0,
+        const OutputType output_type=OUTYPE_AUTO, const char* geometry=0);
+
+    virtual bool finish_data(const XYinfo new_axis);
+
+    // emulate the driver processing the coordinates in 'raw'
+    XYinfo emulate_driver(XYinfo& raw, bool useNewAxis, XYinfo screen, XYinfo device);
+
+    void new_axis_print() {
+        new_axis.print();
+    }
+};
+
+#endif

--- /dev/null
+++ b/src/tester.cpp
@@ -0,0 +1,105 @@
+#include <algorithm>
+#include <stdio.h>
+#include <vector>
+
+#include "calibrator.hh"
+#include "calibrator/Tester.hpp"
+
+int main() {
+    // screen dimensions
+    int width = 800;
+    int height = 600;
+    XYinfo screen_res(0, width, 0, height);
+
+    int delta_x = width/(float)num_blocks;
+    int delta_y = height/(float)num_blocks;
+    XYinfo target(delta_x, width-delta_x, delta_y, height-delta_y);
+
+    int slack = 2; // amount of pixels result can be off target
+
+    XYinfo dev_res(0, 1000, 0, 1000);
+
+    std::vector<XYinfo> old_axes;
+    old_axes.push_back( XYinfo(0, 1000, 0, 1000) );
+    old_axes.push_back( XYinfo(1000, 0, 0, 1000) );
+    old_axes.push_back( XYinfo(0, 1000, 1000, 0) );
+    old_axes.push_back( XYinfo(1000, 0, 0, 1000) );
+    old_axes.push_back( XYinfo(0, 1000, 0, 1000, 1, 0, 0) );
+    old_axes.push_back( XYinfo(0, 1000, 0, 1000, 1, 0, 1) );
+    old_axes.push_back( XYinfo(0, 1000, 0, 1000, 1, 1, 0) );
+    old_axes.push_back( XYinfo(0, 1000, 0, 1000, 1, 1, 1) );
+    old_axes.push_back( XYinfo(1000, 0, 0, 1000, 1, 0, 0) );
+    old_axes.push_back( XYinfo(1000, 0, 0, 1000, 1, 0, 1) );
+    old_axes.push_back( XYinfo(1000, 0, 0, 1000, 1, 1, 0) );
+    old_axes.push_back( XYinfo(1000, 0, 0, 1000, 1, 1, 1) );
+    // non device-resolution calibs
+    old_axes.push_back( XYinfo(42, 929, 20, 888) );
+    // xf86ScaleAxis rounds to min/max, this can lead to inaccurate
+    // results! Can we fix that?
+    old_axes.push_back( XYinfo(42, 929, 20, 888) );
+    //old_axes.push_back( XYinfo(-9, 895, 124, 990) ); // this is the true axis
+                                                       // rounding error when raw_coords are swapped???
+    //old_axes.push_back( XYinfo(75, 750, 20, 888) ); // rounding error on X axis
+    //old_axes.push_back( XYinfo(42, 929, 120, 888) ); // rounding error on Y axis
+
+    // raw device coordinates to emulate
+    std::vector<XYinfo> raw_coords;
+    // normal
+    raw_coords.push_back( XYinfo(105, 783, 233, 883) );
+    // invert x, y, x+y
+    raw_coords.push_back( XYinfo(783, 105, 233, 883) );
+    raw_coords.push_back( XYinfo(105, 783, 883, 233) );
+    raw_coords.push_back( XYinfo(783, 105, 883, 233) );
+    // swap
+    raw_coords.push_back( XYinfo(233, 883, 105, 783) );
+    // swap and inverts
+    raw_coords.push_back( XYinfo(233, 883, 783, 105) );
+    raw_coords.push_back( XYinfo(883, 233, 105, 783) );
+    raw_coords.push_back( XYinfo(883, 233, 783, 105) );
+
+    for (unsigned a=0; a != old_axes.size(); a++) {
+        XYinfo old_axis(old_axes[a]);
+        printf("Old axis: "); old_axis.print();
+
+    for (unsigned c=0; c != raw_coords.size(); c++) {
+        XYinfo raw(raw_coords[c]);
+        //printf("Raw: "); raw.print();
+
+        CalibratorTester calib("Tester", old_axis);
+
+        // clicked from raw
+        XYinfo clicked = calib.emulate_driver(raw, false, screen_res, dev_res);// false=old_axis
+        //printf("\tClicked: "); clicked.print();
+
+        // emulate screen clicks
+        calib.add_click(clicked.x.min, clicked.y.min);
+        calib.add_click(clicked.x.max, clicked.y.min);
+        calib.add_click(clicked.x.min, clicked.y.max);
+        calib.add_click(clicked.x.max, clicked.y.max);
+        calib.finish(width, height);
+
+        // test result
+        XYinfo result = calib.emulate_driver(raw, true, screen_res, dev_res); // true=new_axis
+
+        int maxdiff = std::max(abs(target.x.min - result.x.min),
+                      std::max(abs(target.x.max - result.x.max),
+                      std::max(abs(target.y.min - result.y.min),
+                               abs(target.y.max - result.y.max)))); // no n-ary max in c++??
+        if (maxdiff > slack) {
+            printf("-\n");
+            printf("Old axis: "); old_axis.print();
+            printf("Raw: "); raw.print();
+            printf("Clicked: "); clicked.print();
+            printf("New axis: "); calib.new_axis_print();
+            printf("Error: difference between target and result: %i > %i:\n", maxdiff, slack);
+            printf("\tTarget: "); target.print();
+            printf("\tResult: "); result.print();
+            exit(1);
+        }
+
+        printf("%i", maxdiff);
+    } // loop over raw_coords
+
+        printf(". OK\n");
+    } // loop over old_axes
+}