ts.c

Go to the documentation of this file.

/*
 * File Name: ts.c
 */

/*
 * This file is part of gtktscal.
 *
 * gtktscal is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * gtktscal is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * This code is originally from xtscal:
 *
 * Copyright (C) 2003, 2004 Philip Blundell <philb@gnu.org>
 *
 * Modifications:
 *
 * Copyright (C) 2008 iRex Technologies B.V.
 */

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <math.h>
#include <string.h>
#include <sys/ioctl.h>

#include <glib.h>
#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <gdk/gdkx.h>

#include <X11/extensions/xcalibrate.h>

#include "h3600_ts.h"
#include "calibrate.h"
#include "ts.h"

#define ENOUGH 5
#define MAX_SAMPLES 40
#define OFFSET 150
#define ALLOWED_OFFSET 80

#define RAW_DEVICE "/dev/ttyS0"

struct point sample[MAX_SAMPLES];
calibration cal;
int ts_fd;
int samples;
static int a_cur[7];
int event = 0;

extern int flag_debug;
extern int flag_sanityCheck;
extern void next_target();

void ts_init(int width, int height, int rotation)
{
    int i;

    cal.xscr[0] = OFFSET;
    cal.yscr[0] = OFFSET;
    cal.xscr[1] = width - OFFSET;
    cal.yscr[1] = OFFSET;
    cal.xscr[2] = width - OFFSET;
    cal.yscr[2] = height - OFFSET;
    cal.xscr[3] = OFFSET;
    cal.yscr[3] = height - OFFSET;
    cal.xscr[4] = (width / 2);
    cal.yscr[4] = (height / 2);
    
    for (i=0;i<NR_POINTS;i++)
    {
        switch (rotation)
        {
            case 0:
                cal.xfb[i] = cal.xscr[i];
                cal.yfb[i] = cal.yscr[i];
                break;
            case 90:
                cal.xfb[i] = cal.yscr[i];
                cal.yfb[i] = width - cal.xscr[i];
                break;
            case 180:
                cal.xfb[i] = width - cal.xscr[i];
                cal.yfb[i] = height - cal.yscr[i];
                break;
            case 270:
                cal.xfb[i] = height - cal.yscr[i];
                cal.yfb[i] = cal.xscr[i];
                break;
        }
    }
} 

void ts_get_target(int nth, int *x, int *y)
{
    *x = cal.xscr[nth];
    *y = cal.yscr[nth];
}

void ts_get_current_target(int *x, int *y)
{
    *x = cal.xscr[event];
    *y = cal.yscr[event];
}

int sort_by_x (const void* a, const void *b)
{
    return (((struct point *)a)->x - ((struct point *)b)->x);
}

int sort_by_y (const void* a, const void *b)
{
    return (((struct point *)a)->y - ((struct point *)b)->y);
}

void ts_write_calibration(char *filename)
{
    TS_CAL tc;
    int xtrans, ytrans, xscale, yscale, xyscale, yxscale;
    
    FILE *fp;
    if (flag_debug)
        printf ("constants are: %d %d %d %d %d %d %d\n", 
                cal.a[1], 
                cal.a[2], 
                cal.a[0], 
                cal.a[4], 
                cal.a[5], 
                cal.a[3], 
                cal.a[6]);
    
    fp = fopen (filename, "w");
    if (!fp)
    {
        perror (filename);
        exit (1);
    }
    fprintf (fp, "%d %d %d %d %d %d %d\n", 
            cal.a[1], 
            cal.a[2], 
            cal.a[0], 
            cal.a[4], 
            cal.a[5], 
            cal.a[3], 
            cal.a[6]);
    fclose (fp); 
    return;
    
    xtrans = cal.a[0] / cal.a[6];
    ytrans = cal.a[3] / cal.a[6];
    xscale = cal.a[1] * 256 / cal.a[6];
    yscale = cal.a[5] * 256 / cal.a[6];
    xyscale = cal.a[2] * 256 / cal.a[6];
    yxscale = cal.a[4] * 256 / cal.a[6];
    
    tc.xtrans = xtrans;
    tc.ytrans = ytrans;
    tc.xscale = xscale;
    tc.yscale = yscale;
    tc.xyswap = 0;
    
    printf ("%d %d %d %d %d\n", 
            tc.xscale, tc.xtrans, tc.yscale, tc.ytrans, tc.xyswap);
    
    if (ioctl (ts_fd, TS_SET_CAL, (void *)&tc) != 0)
    {
        perror ("TS_SET_CAL");
        exit (1);
    }
}

int validate_input(int xin, int yin, int pos)
{
    int xconv, yconv;
    
    xconv = (a_cur[2] + a_cur[0] * xin + a_cur[1] * yin) / a_cur[6];
    yconv = (a_cur[5] + a_cur[3] * xin + a_cur[4] * yin) / a_cur[6];
    
    if (flag_debug)
        printf ("validate delta X %d, delta Y %d, checkval %d\n", 
                (xconv - cal.xfb[pos]),
                (yconv - cal.yfb[pos]), 
                abs(xconv - cal.xfb[pos]) + abs(yconv - cal.yfb[pos]));
    
    // Check to see if the converted x/y is far from current settings
    if (abs(xconv - cal.xfb[pos]) + abs(yconv - cal.yfb[pos]) > ALLOWED_OFFSET)
    {
        fprintf(stderr, "xconv=%d, yconv=%d, cal.xfb[%d]=%d, cal.yfb[%d]=%d (%d > %d)\n", 
                xconv, yconv, pos, cal.xfb[pos], pos, cal.yfb[pos], 
                abs(xconv - cal.xfb[pos]) + abs(yconv - cal.yfb[pos]), 
                ALLOWED_OFFSET);
        return 0;
    }
    return 1;
}

int ts_handle_event (int x, int y, int pressure)
{
    if (pressure)
    {
        if (samples < MAX_SAMPLES)
        {
            sample[samples].x = x;
            sample[samples].y = y;
            samples++;
        }
    }
    else
    {
        if (samples > ENOUGH)
        {
            int middle, sx, sy;
            
            middle = samples / 2;
            qsort (sample, samples, sizeof(struct point), sort_by_x);
            if (samples & 1)
                sx = sample[middle].x;
            else
                sx = (sample[middle-1].x + sample[middle].x) / 2;
            qsort (sample, samples, sizeof(struct point), sort_by_y);
            if (samples & 1)
                sy = sample[middle].y;
            else
                sy = (sample[middle-1].y + sample[middle].y) / 2;
            
            cal.x[event] = sx;
            cal.y[event] = sy;
            
            if (flag_sanityCheck && !validate_input(cal.x[event], cal.y[event], event))
            {
                fprintf(stderr, "Invalid input!\n");
                samples = 0;
                return TS_CALIBRATION_IN_PROGRESS;
            }
            
            if (flag_debug)
                fprintf (stderr, "point %d: [%d %d]\n", 
                        event, cal.x[event], cal.y[event]);

            event++;
            
            if (event < NR_POINTS)
            {
                samples = 0;
                next_target();
            }
            else
            {
                if (perform_calibration (&cal))
                {
                    return TS_CALIBRATION_DONE;
                }
                else
                {
                    samples = 0;
                    event = 0;
                    next_target();
                }
            }
        }
    }
    return TS_CALIBRATION_IN_PROGRESS;
}

void ts_set_calibration(char **args)
{
    TS_CAL tc;
    
    tc.xscale = atoi (args[0]);
    tc.xtrans = atoi (args[1]);
    tc.yscale = atoi (args[2]);
    tc.ytrans = atoi (args[3]);
    tc.xyswap = atoi (args[4]);
    
    if (flag_debug)
        fprintf (stderr, "setting: %d %d %d %d %d\n", 
                 tc.xtrans, tc.ytrans, tc.xscale, tc.yscale, tc.xyswap);
    
    if (ioctl (ts_fd, TS_SET_CAL, (void *)&tc) != 0)
    {
        perror ("TS_SET_CAL");
        exit (1);
    }
}

void ts_show_calibration (void)
{
    TS_CAL tc;
    
    if (ioctl (ts_fd, TS_GET_CAL, (void *)&tc) != 0)
    {
        perror ("TS_GET_CAL");
        exit (1);
    }
    
    printf ("%d %d %d %d %d\n", 
            tc.xscale, tc.xtrans, tc.yscale, tc.ytrans, tc.xyswap);
}

void ts_read_current_settings(char *filename)
{
    FILE* fp = NULL;
    
    // give default value in case the pointercal does not exist
   // 4317 -4 -2205916 8 -4189 84612704 65536
    a_cur[0] = 4317;
    a_cur[1] = -4;
    a_cur[2] = -2205916;
    a_cur[3] = 8;
    a_cur[4] = -4189;
    a_cur[5] = 84612704;
    a_cur[6] = 65536;

    if ((fp = fopen(filename, "r")) != NULL)
    {
        fscanf(fp, "%d %d %d %d %d %d %d",
               a_cur + 0,
               a_cur + 1,
               a_cur + 2,
               a_cur + 3,
               a_cur + 4,
               a_cur + 5,
               a_cur + 6);
        
        fclose(fp);
    }
}