mayhem-firmware/firmware/application/apps/ui_touch_calibration.cpp

206 lines
5.9 KiB
C++
Raw Normal View History

2016-07-27 14:15:21 -07:00
/*
* Copyright (C) 2016 Jared Boone, ShareBrained Technology, Inc.
*
* This file is part of PortaPack.
*
* This program 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, or (at your option)
* any later version.
*
* This program 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; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street,
* Boston, MA 02110-1301, USA.
*/
#include "ui_touch_calibration.hpp"
#include "irq_controls.hpp"
#include "portapack_persistent_memory.hpp"
using namespace portapack;
2016-07-27 14:15:21 -07:00
namespace ui {
TouchCalibrationView::TouchCalibrationView(
NavigationView& nav)
: nav{nav},
calibration{touch::Calibration()} {
add_children({
&image_calibrate_0,
&image_calibrate_1,
&image_calibrate_2,
&image_verify_0,
&image_verify_1,
&image_verify_2,
&label_calibrate,
&label_verify,
&label_success,
&label_failure,
&button_cancel,
&button_ok,
});
button_cancel.on_select = [this](Button&) { this->on_cancel(); };
button_ok.on_select = [this](Button&) { this->on_ok(); };
set_phase(Phase::Calibrate0);
2016-07-27 14:15:21 -07:00
}
void TouchCalibrationView::focus() {
button_cancel.focus();
2016-07-27 14:15:21 -07:00
}
void TouchCalibrationView::update_target() {
const auto phase_calibrate = (phase == Phase::Calibrate0) || (phase == Phase::Calibrate1) || (phase == Phase::Calibrate2);
const auto phase_verify = (phase == Phase::Verify0) || (phase == Phase::Verify1) || (phase == Phase::Verify2);
2016-07-27 14:15:21 -07:00
image_calibrate_0.hidden(phase != Phase::Calibrate0);
image_calibrate_1.hidden(phase != Phase::Calibrate1);
image_calibrate_2.hidden(phase != Phase::Calibrate2);
2016-07-27 14:15:21 -07:00
image_verify_0.hidden(phase != Phase::Verify0);
image_verify_1.hidden(phase != Phase::Verify1);
image_verify_2.hidden(phase != Phase::Verify2);
2016-07-27 14:15:21 -07:00
label_calibrate.hidden(!phase_calibrate);
label_verify.hidden(!phase_verify);
label_success.hidden(phase != Phase::Success);
label_failure.hidden(phase != Phase::Failure);
2016-07-27 14:15:21 -07:00
button_ok.hidden((phase != Phase::Success) && (phase != Phase::Failure));
2016-07-27 14:15:21 -07:00
/* TODO: Such a hack to get around a poor repaint implementation! This "technique"
* occurs in other places...
*/
set_dirty();
2016-07-27 14:15:21 -07:00
}
void TouchCalibrationView::set_phase(const Phase value) {
if (value != phase) {
phase = value;
update_target();
}
2016-07-27 14:15:21 -07:00
}
uint32_t TouchCalibrationView::distance_squared(const Point& touch_point, const Image& target) {
const auto target_point = target.screen_rect().center();
const int32_t dx = target_point.x() - touch_point.x();
const int32_t dy = target_point.y() - touch_point.y();
const uint32_t dx2 = dx * dx;
const uint32_t dy2 = dy * dy;
return dx2 + dy2;
2016-07-27 14:15:21 -07:00
}
void TouchCalibrationView::touch_complete() {
auto next_phase = static_cast<Phase>(toUType(phase) + 1);
switch (phase) {
case Phase::Calibrate0:
case Phase::Verify0:
digitizer_points[0] = average;
break;
case Phase::Calibrate1:
case Phase::Verify1:
digitizer_points[1] = average;
break;
case Phase::Calibrate2:
case Phase::Verify2:
digitizer_points[2] = average;
break;
default:
break;
}
if (phase == Phase::Calibrate2) {
const std::array<Point, 3> display_points{{
image_calibrate_0.screen_rect().center(),
image_calibrate_1.screen_rect().center(),
image_calibrate_2.screen_rect().center(),
}};
calibration = {digitizer_points, display_points};
}
if (phase == Phase::Verify2) {
const auto calibrated_0 = calibration.translate(digitizer_points[0]);
const auto d_sq_0 = distance_squared(calibrated_0, image_verify_0);
const auto calibrated_1 = calibration.translate(digitizer_points[1]);
const auto d_sq_1 = distance_squared(calibrated_1, image_verify_1);
const auto calibrated_2 = calibration.translate(digitizer_points[2]);
const auto d_sq_2 = distance_squared(calibrated_2, image_verify_2);
if ((d_sq_0 < verify_d_sq_max) && (d_sq_1 < verify_d_sq_max) && (d_sq_2 < verify_d_sq_max)) {
next_phase = Phase::Success;
} else {
next_phase = Phase::Failure;
}
}
set_phase(next_phase);
2016-07-27 14:15:21 -07:00
}
void TouchCalibrationView::on_ok() {
if (phase == Phase::Success) {
persistent_memory::set_touch_calibration(calibration);
nav.pop();
}
if (phase == Phase::Failure) {
set_phase(Phase::Calibrate0);
}
2016-07-27 14:15:21 -07:00
}
void TouchCalibrationView::on_cancel() {
nav.pop();
2016-07-27 14:15:21 -07:00
}
void TouchCalibrationView::on_frame_sync() {
switch (phase) {
case Phase::Calibrate0:
case Phase::Calibrate1:
case Phase::Calibrate2:
case Phase::Verify0:
case Phase::Verify1:
case Phase::Verify2:
break;
default:
return;
}
const auto frame = get_touch_frame();
const auto metrics = touch::calculate_metrics(frame);
const auto x = metrics.x * 1024;
const auto y = metrics.y * 1024;
if (metrics.r < 640.0f) {
if (samples_count > 0) {
average.x = ((average.x * 7) + x) / 8;
average.y = ((average.y * 7) + y) / 8;
} else {
average.x = x;
average.y = y;
}
samples_count += 1;
} else {
if (samples_count >= samples_limit) {
touch_complete();
}
samples_count = 0;
}
2016-07-27 14:15:21 -07:00
}
} /* namespace ui */