comparison Source/Mappings/KeyDivision/TouchkeyKeyDivisionMapping.cpp @ 0:3580ffe87dc8

First commit of TouchKeys public pre-release.

+/*
+  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/>.
+ 
+  =====================================================================
+
+  TouchkeyKeyDivisionMapping.cpp: per-note mapping for the split-key mapping
+  which triggers different actions or pitches depending on where the key
+  was struck.
+*/
+
+#include "TouchkeyKeyDivisionMapping.h"
+#include "TouchkeyKeyDivisionMappingFactory.h"
+
+#define DEBUG_KEY_DIVISION_MAPPING
+
+const int TouchkeyKeyDivisionMapping::kDefaultNumberOfSegments = 2;
+const timestamp_diff_type TouchkeyKeyDivisionMapping::kDefaultDetectionTimeout = milliseconds_to_timestamp(25.0);
+const int TouchkeyKeyDivisionMapping::kDefaultDetectionParameter = kDetectionParameterYPosition;
+const int TouchkeyKeyDivisionMapping::kDefaultRetriggerNumFrames = 2;
+
+// Main constructor takes references/pointers from objects which keep track
+// of touch location, continuous key position and the state detected from that
+// position. The PianoKeyboard object is strictly required as it gives access to
+// Scheduler and OSC methods. The others are optional since any given system may
+// contain only one of continuous key position or touch sensitivity
+TouchkeyKeyDivisionMapping::TouchkeyKeyDivisionMapping(PianoKeyboard &keyboard, MappingFactory *factory, int noteNumber, Node<KeyTouchFrame>* touchBuffer,
+                                                     Node<key_position>* positionBuffer, KeyPositionTracker* positionTracker)
+: TouchkeyBaseMapping(keyboard, factory, noteNumber, touchBuffer, positionBuffer, positionTracker),
+numberOfSegments_(kDefaultNumberOfSegments), candidateSegment_(-1), detectedSegment_(-1), defaultSegment_(0),
+detectionParameter_(kDefaultDetectionParameter), retriggerable_(false), retriggerNumFrames_(kDefaultRetriggerNumFrames),
+retriggerKeepsVelocity_(true),
+midiNoteOnTimestamp_(missing_value<timestamp_type>::missing()), timeout_(kDefaultDetectionTimeout),
+lastNumActiveTouches_(-1)
+{
+}
+
+// Reset state back to defaults
+void TouchkeyKeyDivisionMapping::reset() {
+    TouchkeyBaseMapping::reset();
+    
+    candidateSegment_ = detectedSegment_ = -1;
+    midiNoteOnTimestamp_ = missing_value<timestamp_type>::missing();
+}
+
+// Resend all current parameters
+void TouchkeyKeyDivisionMapping::resend() {
+    if(detectedSegment_ >= 0)
+        sendSegmentMessage(detectedSegment_, true);
+}
+
+// Set the pitch bend values (in semitones) for each segment. These
+// values are in relation to the pitch of this note
+void TouchkeyKeyDivisionMapping::setSegmentPitchBends(const float *bendsInSemitones, int numBends) {
+    // Clear old values and refill the vector
+    segmentBends_.clear();
+    for(int i = 0; i < numBends; i++)
+        segmentBends_.push_back(bendsInSemitones[i]);
+}
+
+// This method receives data from the touch buffer or possibly the continuous key angle (not used here)
+void TouchkeyKeyDivisionMapping::triggerReceived(TriggerSource* who, timestamp_type timestamp) {
+    if(who == touchBuffer_) {
+        // If we get here, a new touch frame has been received and there is no segment detected
+        // yet. We should come up with a candidate segment. If the MIDI note is on, activate this
+        // segment right away. Otherwise, save it for later so when the MIDI note begins, we have
+        // it ready to go.
+        if(!touchBuffer_->empty()) {
+            const KeyTouchFrame& frame = touchBuffer_->latest();
+            
+            if(detectedSegment_ < 0) {
+                int candidateBasedOnYPosition = -1, candidateBasedOnNumberOfTouches = -1;
+                
+                // Find the first touch. TODO: eventually look for the largest touch
+                float yPosition = frame.locs[0];
+                
+                // Calculate two possible segments based on touch location and based on
+                // number of touches.
+                candidateBasedOnYPosition = segmentForLocation(yPosition);
+                candidateBasedOnNumberOfTouches = segmentForNumTouches(frame.count);
+                
+                if(detectionParameter_ == kDetectionParameterYPosition)
+                    candidateSegment_ = candidateBasedOnYPosition;
+                else if(detectionParameter_ == kDetectionParameterNumberOfTouches)
+                    candidateSegment_ = candidateBasedOnNumberOfTouches;
+                else if(detectionParameter_ == kDetectionParameterYPositionAndNumberOfTouches) {
+                    // Choose the maximum segment specified by the other two methods
+                    candidateSegment_ = candidateBasedOnNumberOfTouches > candidateBasedOnYPosition ? candidateBasedOnNumberOfTouches : candidateBasedOnYPosition;
+                }
+                else // Shouldn't happen
+                    candidateSegment_ = -1;
+                
+                if(noteIsOn_) {
+                    detectedSegment_ = candidateSegment_;
+#ifdef DEBUG_KEY_DIVISION_MAPPING
+                    cout << "TouchkeyKeyDivisionMapping::triggerReceived(): detectedSegment_ = " << detectedSegment_ << endl;
+#endif
+                    sendSegmentMessage(detectedSegment_);
+                }
+            }
+            else if(retriggerable_ &&
+                    (lastNumActiveTouches_ == 1 &&
+                    frame.count >= 2) && noteIsOn_) {
+                // Here, there was one touch active before and now there are two. Look for the
+                // location of the most recently added touch, and determine whether it matches a
+                // segment different from the one we're in. If so, retrigger the MIDI note
+                // with a different pitch bend
+                
+                int newCandidate = segmentForLocation(locationOfNewestTouch(frame));
+                
+#ifdef DEBUG_KEY_DIVIOSION_MAPPING
+                cout << "TouchkeyKeyDivisionMapping: touch added with candidate segment " << newCandidate << " (current is " << detectedSegment_ << ")\n";
+#endif
+                if(newCandidate != detectedSegment_) {
+                    // Set up a new segment to retrigger and tell the scheduler to insert the mapping
+                    detectedSegment_ = newCandidate;
+                    
+                    // Find the keyboard segment, which gives us the output port
+                    int outputPort = static_cast<TouchkeyKeyDivisionMappingFactory*>(factory_)->segment().outputPort();
+                    
+                    // Send MIDI note-on on the same channel as previously
+                    int ch = keyboard_.key(noteNumber_)->midiChannel();
+                    int vel = 64;
+                    if(retriggerKeepsVelocity_)
+                        vel = keyboard_.key(noteNumber_)->midiVelocity();
+                    keyboard_.midiOutputController()->sendNoteOn(outputPort, ch, noteNumber_, vel);
+                    sendSegmentMessage(detectedSegment_);
+                }
+            }
+            
+            // Save the number of active touches for next time
+            lastNumActiveTouches_ = frame.count;
+        }
+    }
+}
+
+// Mapping method. This actually does the real work of sending OSC data in response to the
+// latest information from the touch sensors or continuous key angle
+timestamp_type TouchkeyKeyDivisionMapping::performMapping() {
+    timestamp_type currentTimestamp = keyboard_.schedulerCurrentTimestamp();
+    
+    if(detectedSegment_ >= 0) {
+        // Found segment; no need to keep sending mapping callbacks
+        nextScheduledTimestamp_ = 0;
+        return 0;
+    }
+    
+    if(currentTimestamp - midiNoteOnTimestamp_ > timeout_) {
+        // Timeout occurred. Activate default segment
+#ifdef DEBUG_KEY_DIVISION_MAPPING
+        cout << "TouchkeyKeyDivisionMapping: timeout\n";
+#endif
+        detectedSegment_ = defaultSegment_;
+        sendSegmentMessage(detectedSegment_);
+        nextScheduledTimestamp_ = 0;
+        return 0;
+    }
+    
+    // Register for the next update by returning its timestamp
+    nextScheduledTimestamp_ = currentTimestamp + updateInterval_;
+    return nextScheduledTimestamp_;
+}
+
+// MIDI note-on received. If we have a candidate segment, activate it as the actual segment
+void TouchkeyKeyDivisionMapping::midiNoteOnReceived(int channel, int velocity) {
+    midiNoteOnTimestamp_ = keyboard_.schedulerCurrentTimestamp();
+    
+    if(detectedSegment_ < 0) {
+#ifdef DEBUG_KEY_DIVISION_MAPPING
+        cout << "TouchkeyKeyDivisionMapping::midiNoteOnReceived(): candidateSegment_ = " << candidateSegment_ << endl;
+#endif
+        detectedSegment_ = candidateSegment_;
+        if(detectedSegment_ >= 0) {
+            sendSegmentMessage(detectedSegment_);
+        }
+    }
+}
+
+// MIDI note-off received. Reset back to the detecting state so we can assign the next note to a segment
+void TouchkeyKeyDivisionMapping::midiNoteOffReceived(int channel) {
+    detectedSegment_ = candidateSegment_ = -1;
+}
+
+void TouchkeyKeyDivisionMapping::sendSegmentMessage(int segment, bool force) {
+    if(force || !suspended_) {
+        keyboard_.sendMessage("/touchkeys/keysegment", "ii", noteNumber_, segment, LO_ARGS_END);
+        if(segment < segmentBends_.size() && segment >= 0) {
+#ifdef DEBUG_KEY_DIVISION_MAPPING
+            cout << "TouchkeyKeyDivisionMapping::sendSegmentMessage(): pitch bend = " << segmentBends_[segment] << endl;
+#endif
+            sendPitchBendMessage(segmentBends_[segment], force);
+        }
+        else {
+#ifdef DEBUG_KEY_DIVISION_MAPPING
+            cout << "TouchkeyKeyDivisionMapping::sendSegmentMessage(): no bend for segment " << segment << endl;
+#endif
+        }
+    }
+    else {
+#ifdef DEBUG_KEY_DIVISION_MAPPING
+        cout << "TouchkeyKeyDivisionMapping::sendSegmentMessage(): suspended, not sending segment " << segment << endl;
+#endif
+    }
+}
+
+// Send the pitch bend message of a given number of a semitones. Send by OSC,
+// which can be mapped to MIDI CC externally
+void TouchkeyKeyDivisionMapping::sendPitchBendMessage(float pitchBendSemitones, bool force) {
+    if(force || !suspended_)
+        keyboard_.sendMessage(controlName_.c_str(), "if", noteNumber_, pitchBendSemitones, LO_ARGS_END);
+}
+
+// Find the segment corresponding to a (Y) touch location
+int TouchkeyKeyDivisionMapping::segmentForLocation(float location) {
+    // Divide the key into evenly-spaced regions, and identify and candidate segment.
+    // Since the location can go up to 1.0, make sure the top value doesn't overflow
+    // the number of segments
+    int segment = floorf(location * (float)numberOfSegments_);
+    if(segment >= numberOfSegments_)
+        segment = numberOfSegments_ - 1;
+    return segment;
+}
+
+// Find the segment corresponding to a number of touches
+int TouchkeyKeyDivisionMapping::segmentForNumTouches(int numTouches) {
+    // Check the number of touches, which could divide the note into as many
+    // as three segments.
+    if(numTouches <= 0)
+        return -1;
+    
+    int segment = numTouches - 1;
+    if(segment >= numberOfSegments_)
+        segment = numberOfSegments_ - 1;
+    return segment;
+}
+
+// Return the location of the most recently added touch (indicated by the highest ID)
+float TouchkeyKeyDivisionMapping::locationOfNewestTouch(KeyTouchFrame const& frame) {
+    if(frame.count == 0)
+        return -1.0;
+    
+    // Go through the active touches and find the one with the highest id
+    int highestId = -1;
+    float location = -1.0;
+    for(int i = 0; i < frame.count; i++) {
+        if(frame.ids[i] > highestId) {
+            highestId = frame.ids[i];
+            location = frame.locs[i];
+        }
+    }
+    
+    return location;
+}