annotate Source/Display/KeyboardTesterDisplay.cpp @ 17:73d2ec21de9a

Added ability to test the TouchKeys sensors for functionality. Enable the option at compile time.

/*
  TouchKeys: multi-touch musical keyboard control software
  Copyright (c) 2013 Andrew McPherson

  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 3 of the License, 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.  If not, see <http://www.gnu.org/licenses/>.
 
  =====================================================================

  KeyboardTesterDisplay.cpp: A keyboard display for raw data that can be used
  for testing the functionality of individual TouchKeys sensors
*/

#ifdef ENABLE_TOUCHKEYS_SENSOR_TEST

#include "KeyboardTesterDisplay.h"
#include "../MainApplicationController.h"
#include "../TouchKeys/PianoKeyboard.h"

const int KeyboardTesterDisplay::kNumSensorsPerKey = 26;
const int KeyboardTesterDisplay::kDefaultSensorThreshold = 16;

// Constructor
KeyboardTesterDisplay::KeyboardTesterDisplay(MainApplicationController& controller, PianoKeyboard& keyboard)
: controller_(controller), keyboard_(keyboard),
  currentlyActiveKey_(-1), sensorThreshold_(kDefaultSensorThreshold) {
    for(int i = 0; i < 128; i++)
        resetSensorState(i);
    
    setOscController(&keyboard_);
    addOscListener("/touchkeys/rawbytes");
}

// Render the display starting with the underlying keyboard and
// then adding our own display info on top
void KeyboardTesterDisplay::render() {
	if(lowestMidiNote_ == highestMidiNote_)
		return;
	
	// Start with a light gray background
	glClearColor(0.8, 0.8, 0.8, 1.0);
	glClear(GL_COLOR_BUFFER_BIT);
	glLoadIdentity();
    
	float invAspectRatio = totalDisplayWidth_ / totalDisplayHeight_;
	float scaleValue = 2.0 / totalDisplayWidth_;
	
	glScalef(scaleValue, scaleValue * invAspectRatio, scaleValue);
	glTranslatef(-1.0 / scaleValue, -totalDisplayHeight_ / 2.0, 0);
	glTranslatef(kDisplaySideMargin, kDisplayBottomMargin, 0.0);
	
	glPushMatrix();
    
	// Draw the keys themselves first, with analog values if present, then draw the touches
	for(int key = lowestMidiNote_; key <= highestMidiNote_; key++) {
		if(keyShape(key) >= 0) {
			// White keys: draw and move the frame over for the next key
			drawWhiteKey(0, 0, keyShape(key), key == lowestMidiNote_,
                         key == highestMidiNote_, (key == currentlyActiveKey_) || (key == currentHighlightedKey_));
            // Draw sensor state for this key
            drawSensorState(key, kWhiteKeyBackOffsets[keyShape(key)], 0, kWhiteKeyBackWidths[keyShape(key)], kWhiteKeyFrontLength + kWhiteKeyBackLength);
			glTranslatef(kWhiteKeyFrontWidth + kInterKeySpacing, 0, 0);
		}
		else {
			// Black keys: draw and leave the frame in place
			int previousWhiteKeyShape = keyShape(key - 1);
			float offsetH = -1.0 + kWhiteKeyBackOffsets[previousWhiteKeyShape] + kWhiteKeyBackWidths[previousWhiteKeyShape];
			float offsetV = kWhiteKeyFrontLength + kWhiteKeyBackLength - kBlackKeyLength;
            
			glTranslatef(offsetH, offsetV, 0.0);
			drawBlackKey(0, 0, (key == currentlyActiveKey_) || (key == currentHighlightedKey_));
            // Draw sensor state for this key
            drawSensorState(key, 0, 0, kBlackKeyWidth, kBlackKeyLength);
			glTranslatef(-offsetH, -offsetV, 0.0);
		}
	}
	
	// Restore to the original location we used when drawing the keys
	glPopMatrix();
    
	needsUpdate_ = false;    
	glFlush();
}

// Set the threshold level at which a sensor is considered active
void KeyboardTesterDisplay::setSensorThreshold(int threshold) {
    sensorThreshold_ = threshold;
}

// Set the state of a given sensor on a given key to be on or off,
// based on some externally-computed threshold. Sensors that are on
// will flip the "good" flag to true, which remains set until cleared
// externally.
void KeyboardTesterDisplay::setSensorState(int key, int sensor, bool active) {
    if(key < 0 || key > 127)
        return;
    if(sensor < 0 || sensor >= kNumSensorsPerKey)
        return;
    if(active) {
        keySensorActive_[key] |= (1 << sensor);
        keySensorGood_[key] |= (1 << sensor);
    }
    else
        keySensorActive_[key] &= ~(1 << sensor);
    currentlyActiveKey_ = key;
    needsUpdate_ = true;
    
    if(allSensorsGood(currentlyActiveKey_)) {
        controller_.touchkeySensorTestSetKey(key + 1);
    }
}

// Indicate whether all sensors have shown an active value on this key
bool KeyboardTesterDisplay::allSensorsGood(int key) {
    if(key < 0 || key > 127)
        return false;
    unsigned int mask = (1 << kNumSensorsPerKey) - 1;
    
    return ((keySensorGood_[key] & mask) == mask);
}

// Reset the sensor state to all off
void KeyboardTesterDisplay::resetSensorState(int key) {
    if(key < 0 || key > 127)
        return;
    keySensorGood_[key] = 0;
    keySensorActive_[key] = 0;
    if(currentlyActiveKey_ == key)
        currentlyActiveKey_ = -1;
}

// Draw the given key sensors as being active, good, or inactive
void KeyboardTesterDisplay::drawSensorState(int key, float x, float y, float width, float height) {
    float heightInset = height / ((float)kNumSensorsPerKey * 10);
    
    glPushMatrix();
    glTranslatef(x, y, 0);
    
    for(int i = 0; i < kNumSensorsPerKey; i++) {
        // Draw each sensor in sequence: red = never activated; yellow = active; green = previously
        // activated (good)
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
        if(keySensorActive_[key] & (1 << i) && key == currentlyActiveKey_)
            glColor3f(1.0, 1.0, 0.0);   // Sensor active right now = yellow
        else if(keySensorGood_[key] & (1 << i))
            glColor3f(0.0, 1.0, 0.0);   // Sensor has been active (good) = green
        else
            glColor3f(1.0, 0.0, 0.0);   // Sensor has not yet been active = red
        
        glBegin(GL_POLYGON);
        glVertex2f(width * 0.1, heightInset);
        glVertex2f(width * 0.1, height / (float)kNumSensorsPerKey - heightInset);
        glVertex2f(width * 0.9, height / (float)kNumSensorsPerKey - heightInset);
        glVertex2f(width * 0.9, heightInset);
        glEnd();
        
        glTranslatef(0, height / (float)kNumSensorsPerKey, 0);
    }
    
    glPopMatrix();
}

// OSC callback method, for when data comes in
bool KeyboardTesterDisplay::oscHandlerMethod(const char *path, const char *types, int numValues, lo_arg **values, void *data) {
    // Look for a blob in value 0 holding the raw data
    if(numValues < 1)
        return false;
    if(types[0] != 'b')
        return false;
    
    // Get OSC blob which holds raw data
    lo_blob blob = values[0];
    int bufferSize = lo_blob_datasize(blob);
    const unsigned char *buffer = (const unsigned char *)lo_blob_dataptr(blob);
    
    // buffer[0] holds the key number from which this data came. Make sure it's sane.
    if(bufferSize == 0)
        return false;
    if(buffer[0] > 127)
        return false;
    
    // The remainder is raw data, with each single byte corresponding to a sensor.
    for(int i = 1; i < bufferSize; i++) {
        bool active = (buffer[i] >= sensorThreshold_);
        setSensorState(buffer[0], i - 1, active);
    }
    
    return true;
}

#endif // ENABLE_TOUCHKEYS_SENSOR_TEST