Parag Kumar Mital

/*
 *  Created by Parag K. Mital - http://pkmital.com
 *  Contact: parag@pkmital.com
 *
 *  Copyright 2013 Parag K. Mital. All rights reserved.
 *
 *   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.
 */
 
// header files declare classes...
 
#pragma once
 
#include "ofMain.h" // this lets us use openFrameworks
 
// enum's are like integers but have names for their values instead of numbers.
// so instead of an int being equal to 0, you have a buttonState equal to button_default...
// and instead of an int being equal to 1, you have a buttonState equal to button_pressed...
enum buttonState {
    button_default = 0,
    button_pressed = 1
};
 
class myButton
{
public:
 
    //--------------------------------------------------------------
    // this is a constructor.  every c++ class has one.  it is the same name as the class
    // it is automagically called when you create a new instance of this class.  you
    // can put any setup of your object inside of this function.
    myButton();
 
    //--------------------------------------------------------------
    // we'll draw our button inside this function
    void draw();
 
    //--------------------------------------------------------------
    // we create a few "setters" which will change our internal variables (like color, position, size).
    void setColorForState(buttonState stateToChange, ofColor colorToChangeItTo);
    void setPosition(int x, int y);
    void setPosition(ofPoint pt);
    void setSize(int w, int h);
 
    //--------------------------------------------------------------
    // we provide a method to easily get access to our button's position
    ofPoint getPosition();
 
    //--------------------------------------------------------------
    // check if the button's state is currently "pressed"
    bool isPressed();
 
    //--------------------------------------------------------------
    // a method to call whenever the user is touching the screen...
    // we can test if the user touched our button and change the state of our button accordingly...
    // we return true if the button was pressed.
    bool touchDown(ofTouchEventArgs touch);
 
    //--------------------------------------------------------------
    // Our button class holds a few variables which help us keep track of our state, location and color...
    buttonState             myState;
    ofRectangle             myLocation;
    ofColor                 myColorForDefault, myColorForPressed;
};

/*
 *  Created by Parag K. Mital - http://pkmital.com
 *  Contact: parag@pkmital.com
 *
 *  Copyright 2013 Parag K. Mital. All rights reserved.
 *
 *   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 "myButton.h"
 
//--------------------------------------------------------------
myButton::myButton() {
    // our constructor is called automagically.
    // we put our initialization inside of here.
 
    // let's set every state's color to be white
    myColorForDefault = ofColor::white;
    myColorForPressed = ofColor::white;
 
    // and set our state to be the default one
    myState = button_default;
 
    // and set a simple default position and size for our button
    myLocation.x = 0;
    myLocation.y = 0;
    myLocation.width = 0;
    myLocation.height = 0;
}
 
//--------------------------------------------------------------
void myButton::draw() {
 
    // set the color based on our current state
    if (myState == button_default) {
        ofSetColor(myColorForDefault);
    }
    else if(myState == button_pressed) {
        ofSetColor(myColorForPressed);
    }
 
    // then draw a simple rectangle using our position.
    ofRect(myLocation.x,
           myLocation.y,
           myLocation.width,
           myLocation.height);
}
 
//--------------------------------------------------------------
void myButton::setColorForState(buttonState stateToChange,
                                ofColor colorToChangeItTo)
{
    // we check which state is being changed
    if (stateToChange == button_default) {
        // and change the color accordingly
        myColorForDefault = colorToChangeItTo;
    }
    else if(stateToChange == button_pressed) {
        myColorForPressed = colorToChangeItTo;
    }
}
 
//--------------------------------------------------------------
void myButton::setPosition(int x, int y)
{
    // constrain the location to be within the bounds of the application window
    myLocation.x = MIN(ofGetWidth() - myLocation.width, MAX(0,x));
    myLocation.y = MIN(ofGetHeight() - myLocation.height, MAX(0,y));
}
 
//--------------------------------------------------------------
void myButton::setPosition(ofPoint pt)
{
    // constrain the location to be within the bounds of the application window
    myLocation.x = MIN(ofGetWidth() - myLocation.width, MAX(0,pt.x));
    myLocation.y = MIN(ofGetHeight() - myLocation.height, MAX(0,pt.y));
}
 
//--------------------------------------------------------------
void myButton::setSize(int w, int h)
{
    // change our internal variables to match what size the user told us to be
    myLocation.width = w;
    myLocation.height = h;
}
 
//--------------------------------------------------------------
ofPoint myButton::getPosition()
{
    // return our internal position
    return myLocation.position;
}
 
//--------------------------------------------------------------
bool myButton::touchDown(ofTouchEventArgs touch)
{
    bool bTouched = false;
    // check if the touch's x,y position is inside the button
    if (myLocation.inside(touch.x, touch.y)) {
        bTouched = true;
        // if so, the user touched us!  let's change states by simply adding 1
        // to our current value.  this "cycles" through all the possible values (only 2).
        // if we had more possible values for buttonState, we would use a modulus of
        // however many different states we had, rather than 2...
        myState = (buttonState)((myState + 1) % 2);
    }
    return bTouched;
}
 
//--------------------------------------------------------------
bool myButton::isPressed()
{
    // check if we are being pressed
    return myState == button_pressed;
}

/*
 *  Created by Parag K. Mital - http://pkmital.com
 *  Contact: parag@pkmital.com
 *
 *  Copyright 2013 Parag K. Mital. All rights reserved.
 *
 *   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.
 */
#pragma once
 
#include "ofMain.h"
#include "ofxiPhone.h"
#include "ofxiPhoneExtras.h"
 
#include "maximilian.h"
 
#include "ofxBox2d.h"
 
// we create an additional class here that will be used to help us keep track of every
// recorded sound.  
class customData {
public:
    customData()
    {
        myID = currentSoundLUT;
        currentSoundLUT++;
    }
    // this id stores a number that corresponds to a number in a list 
    int myID;
    static int currentSoundLUT;
};
 
 
class testApp : public ofxiPhoneApp{
     
    public:
        void setup();
        void update();
        void draw();
        void exit();
     
        void touchDown(ofTouchEventArgs & touch);
        void touchMoved(ofTouchEventArgs & touch);
        void touchUp(ofTouchEventArgs & touch);
        void touchDoubleTap(ofTouchEventArgs & touch);
        void touchCancelled(ofTouchEventArgs & touch);
 
        void lostFocus();
        void gotFocus();
        void gotMemoryWarning();
        void deviceOrientationChanged(int newOrientation);
     
        void audioOut(float *buf, int size, int ch);
        void audioIn(float *buf, int size, int ch);
     
         
        // this is the function for contacts
        void contactStart(ofxBox2dContactArgs &e);
        void contactEnd(ofxBox2dContactArgs &e);
     
    //  the box2d world
    ofxBox2d                        box2d;
    //  default box2d circles
    vector      <ofxBox2dCircle>  circles;          
    //  storage for all the recordings we make
    vector<vector<float> >          recordings;
     
    // keep a buffer of audio samples for the current recording in progress
    vector<float>                   currentRecording;
     
    // and the current offset for this recording as it is being recorded
    int                             currentRecordingOffset;
     
    // also keep a table of indexes which store all sounds being played back
    vector<int>                     currentPlayingSounds;
     
    // and the offsets or the current sample being played from these sounds
    vector<int>                     currentPlayingSoundsOffset;
     
    // maximilian's maxiDyn which gives us a compressor to compress our sounds
    maxiDyn                         dyn;
     
    // and a boolean to check if we are currently recording
    bool                            bRecording;
};

/*
 *  Created by Parag K. Mital - http://pkmital.com
 *  Contact: parag@pkmital.com
 *
 *  Copyright 2013 Parag K. Mital. All rights reserved.
 *
 *   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 "testApp.h"
 
int customData::currentSoundLUT = 0;
 
//--------------------------------------------------------------
void testApp::setup() {
    bRecording = false;
     
    // initialize the accelerometer
    ofxAccelerometer.setup();
     
    // we initalize the box2d world.  there are parameters for the gravity and the bounding box of this world.
    // we also tell box2d how fast we need it to be.  it will try to run at this speed at best.
    // we also "register grabbing" which means we are able to interact with any objects we add to the box2d world.
    box2d.init();
    box2d.setGravity(0, 10);
    box2d.createBounds();
    box2d.setFPS(30.0);
    box2d.registerGrabbing();
 
    // add listeners. these are functions that are called only when a certain action is performed
    // we add 2 listeners that are executed whenever box2d's world discovered that some objects
    // have contacted each other.  for instance, a ball hit a wall, or a ball hit another ball.
    // we get 2 listeners, one for the start of the contact, and one for the end of it..
    ofAddListener(box2d.contactStartEvents, this, &testApp::contactStart);
    ofAddListener(box2d.contactEndEvents, this, &testApp::contactEnd);
 
    // setup maximilian audio settings
    maxiSettings::setup(44100, 1, 512);
     
    // setup openframeworks audio setings
    // (gives us the audioIn/audioOut callbacks)
    ofSoundStreamSetup(1, 1, 44100, 512, 3);
     
    // this forces audio output to the speaker rather than the headphone jack
    // (better to have these commands execute in response to a button press)
    //UInt32 category = kAudioSessionOverrideAudioRoute_Speaker;
    //AudioSessionSetProperty(kAudioSessionProperty_OverrideAudioRoute, sizeof(category), &category);
}
 
//--------------------------------------------------------------
void testApp::update()
{
    // get the current accelerometer reading as an ofPoint
    ofPoint currentForce = ofxAccelerometer.getForce();
     
    // reverse the y-direction as our screen coordinates are upside down in y
    currentForce.y = -currentForce.y;
     
    // and multiply by a factor to make the force "heavier"
    currentForce *= 9.8;
     
    // now we update our box2d world with the readings from our accelerometer
    box2d.setGravity(currentForce);
     
    // and tell box2d to update everything else
    box2d.update();
}
 
//--------------------------------------------------------------
void testApp::draw(){
    // set the background to be black every draw iteration
    ofBackground(0);
 
    // let's draw all circles - they know their internal position
    for(int i=0; i<circles.size(); i++) {
        ofFill();
        ofSetHexColor(0xf6c738);
        circles[i].draw();
    }
     
    // draw the box2d ground
    box2d.drawGround();
 
}
 
//--------------------------------------------------------------
void testApp::exit(){
 
}
 
//--------------------------------------------------------------
void testApp::audioOut(float *buf, int size, int ch)
{
    // first clear the sound output to be 0 by default
    memset(buf, 0, sizeof(float)*size*ch);
     
    // we create an iterator which goes through the list of sounds
    vector<int>::iterator it = currentPlayingSounds.begin();
     
    // and keep an iterator which keeps the current offset of that sound
    vector<int>::iterator it2 = currentPlayingSoundsOffset.begin();
     
    // now loop through all sounds that are playing
    while(it != currentPlayingSounds.end())
    {
        // we loop through the current audio frame's size and add all recordings that are currently playing
        for (int i = 0; i < size; i++) {
            // we use the currentPlayingSound's iterator to pick out the recording
            // and the offset to index the recording
            buf[i] += (recordings[(*it)][i + *it2]);
        }
         
        // and update the offset's to reflect that we just read "size" number of samples
        // this way, the next audio frame will play the recorded samples "size" samples farther than
        // this audio frame has played
        (*it2) += size;
         
        // we now check if the recorded sample has finished playing
        if((*it2) >= recordings[(*it)].size())
        {
            // if so, we delete it from the sounds that are playing
            it = currentPlayingSounds.erase(it);
            it2 = currentPlayingSoundsOffset.erase(it2);
        }
        else
        {
            // otherwise, keep it in the list, and move on to the next sound
            it++;
            it2++;
        }
    }
     
    // we use a compressor to keep the sound within [-1,1] bounds. otherwise, the sound will clip
    // if we add more than 1 sound to the output... 
    for (int i = 0; i < size; i++) {
        buf[i] = dyn.compressor(buf[i], 0.7);
    }
     
}
 
//--------------------------------------------------------------
void testApp::audioIn(float *buf, int size, int ch){
     
    // check if the user is recording a sound (pushed down on the screen)
    if (bRecording)
    {
        // get the current recording's size
        int idx = currentRecording.size();
         
        // now change it to be "size" samples bigger
        currentRecording.resize(idx + size);
         
        // loop through the length of size
        for (int i = 0; i < size; i++) {
             
            // and add all the samples of the current audio frame to the current recording
            currentRecording[idx + i] = buf[i];
        }
    }
}
 
 
 
//--------------------------------------------------------------
void testApp::contactStart(ofxBox2dContactArgs &e) {
    if(e.a != NULL && e.b != NULL) {
 
    }
}
 
 
 
//--------------------------------------------------------------
void testApp::contactEnd(ofxBox2dContactArgs &e) {
     
    // .a and .b store the contacting objects
    // we make sure they are not null, not sure why, but we do... 
    if(e.a != NULL && e.b != NULL) {
         
        // we get the data for each of these objects and CAST it to our custom data type
        customData * aData = (customData*)e.a->GetBody()->GetUserData();
        customData * bData = (customData*)e.b->GetBody()->GetUserData();
         
        // we first make sure that it is a circle, as the walls do not have custom data
        if(e.a->GetType() == b2Shape::e_circle && aData) {
            // then add to our table of playing sounds the circle's ID
            currentPlayingSounds.push_back(aData->myID);
            // also initialize the offset of this sound to be the 0th sample so it starts from the beginning
            currentPlayingSoundsOffset.push_back(0);
        }
         
        // we first make sure that it is a circle, as the walls do not have custom data
        if(e.b->GetType() == b2Shape::e_circle && bData) {
            // then add to our table of playing sounds the circle's ID
            currentPlayingSounds.push_back(bData->myID);
            // also initialize the offset of this sound to be the 0th sample so it starts from the beginning
            currentPlayingSoundsOffset.push_back(0);
        }
    }
}
 
//--------------------------------------------------------------
void testApp::touchDown(ofTouchEventArgs & touch){
 
    bRecording = true;
}
 
//--------------------------------------------------------------
void testApp::touchMoved(ofTouchEventArgs & touch){
 
}
 
//--------------------------------------------------------------
void testApp::touchUp(ofTouchEventArgs & touch){
     
    // done recording
    bRecording = false;
     
    // let's add the recorded sound to all of our recordings
    recordings.push_back(currentRecording);
     
    // and erase the buffer which helps us record sounds
    currentRecording.resize(0);
     
    // here we keep a circle that will be modeled by box2d
    float r = 20;
    ofxBox2dCircle circle;
    circle.setPhysics(3.0, 0.53, 0.1);
    circle.setup(box2d.getWorld(), touch.x, touch.y, r);
    circle.setData(new customData());
    circles.push_back(circle);
}
 
//--------------------------------------------------------------
void testApp::touchDoubleTap(ofTouchEventArgs & touch){
 
}
 
//--------------------------------------------------------------
void testApp::touchCancelled(ofTouchEventArgs & touch){
     
}
 
//--------------------------------------------------------------
void testApp::lostFocus(){
 
}
 
//--------------------------------------------------------------
void testApp::gotFocus(){
 
}
 
//--------------------------------------------------------------
void testApp::gotMemoryWarning(){
 
}
 
//--------------------------------------------------------------
void testApp::deviceOrientationChanged(int newOrientation){
 
}

UIImage * getUIImage()
{
    return [imagePicker getUIImage];
}

#pragma once
 
#include "ofMain.h"
#include "ofxiPhone.h"
#include "ofxiPhoneExtras.h"
 
class testApp : public ofxiPhoneApp{
     
    public:
        void setup();
        void update();
        void draw();
        void exit();
     
        void touchDown(ofTouchEventArgs & touch);
        void touchMoved(ofTouchEventArgs & touch);
        void touchUp(ofTouchEventArgs & touch);
        void touchDoubleTap(ofTouchEventArgs & touch);
        void touchCancelled(ofTouchEventArgs & touch);
 
        void lostFocus();
        void gotFocus();
        void gotMemoryWarning();
        void deviceOrientationChanged(int newOrientation);
     
    ofImage img;
    ofxiPhoneImagePicker imgPicker;
 
};

#include "testApp.h"
#import <Twitter/TWTweetComposeViewController.h>
 
//--------------------------------------------------------------
void testApp::setup(){  
 
}
 
//--------------------------------------------------------------
void testApp::update(){
    if (imgPicker.imageUpdated) {
        imgPicker.imageUpdated = false;
         
        TWTweetComposeViewController *tweetView = [[TWTweetComposeViewController alloc] init];
         
        TWTweetComposeViewControllerCompletionHandler
        completionHandler =
        ^(TWTweetComposeViewControllerResult result) {
            switch (result)
            {
                case TWTweetComposeViewControllerResultCancelled:
                    NSLog(@"Twitter Result: canceled");
                    break;
                case TWTweetComposeViewControllerResultDone:
                    NSLog(@"Twitter Result: sent");
                    break;
                default:
                    NSLog(@"Twitter Result: default");
                    break;
            }
            [ofxiPhoneGetViewController() dismissModalViewControllerAnimated:YES];
        };
        [tweetView setCompletionHandler:completionHandler];
        [tweetView addImage:imgPicker.getUIImage()];    // i added a simple "getter" to the image picker class to return the UIImage
        [tweetView setInitialText:@"Look how freaking easy it is to send a tweet using openFrameworks and iOS 5+"];
 
        [ofxiPhoneGetViewController() presentModalViewController:tweetView animated:YES];
                                    
        imgPicker.close();
 
    }
}
 
//--------------------------------------------------------------
void testApp::draw(){
     
}
 
//--------------------------------------------------------------
void testApp::exit(){
 
}
 
//--------------------------------------------------------------
void testApp::touchDown(ofTouchEventArgs & touch){
    imgPicker.openCamera();
}
 
//--------------------------------------------------------------
void testApp::touchMoved(ofTouchEventArgs & touch){
 
}
 
//--------------------------------------------------------------
void testApp::touchUp(ofTouchEventArgs & touch){
 
}
 
//--------------------------------------------------------------
void testApp::touchDoubleTap(ofTouchEventArgs & touch){
 
}
 
//--------------------------------------------------------------
void testApp::touchCancelled(ofTouchEventArgs & touch){
     
}
 
//--------------------------------------------------------------
void testApp::lostFocus(){
 
}
 
//--------------------------------------------------------------
void testApp::gotFocus(){
 
}
 
//--------------------------------------------------------------
void testApp::gotMemoryWarning(){
 
}
 
//--------------------------------------------------------------
void testApp::deviceOrientationChanged(int newOrientation){
 
}

...
 
#import <SystemConfiguration/CaptiveNetwork.h>
 
...
 
{
 
...
 
    // getting an array of supported networking interfaces
    NSArray *ifs = (id)CNCopySupportedInterfaces();
     
    // now output them 
    NSLog(@"%s: Supported interfaces: %@", __func__, ifs);
     
    // can also get info about each interface
    id info = nil;
     
    // let's loop through each interface
    for (NSString *ifnam in ifs) {
         
        // get the info for it
        info = (id)CNCopyCurrentNetworkInfo((CFStringRef)ifnam);
         
        // and output its info, such as what network SSID it is currently connected to
        NSLog(@"%s: %@ => %@", __func__, ifnam, info);
        if (info && [info count]) {
            break;
        }
         
        // release the memory
        [info release];
    }
    [ifs release];
 
...
 
}

...
 
class ofxiPhoneMapKit : public ofxiPhoneMapKitListener {
public:
 
...
 
    void selectedAnnotation(string title, string subtitle);
    void unselectedAnnotation(string title, string subtitle);
    void addAnnotation(double latitude, double longitude, string title, string subtitle);
    void removeAnnotation(double latitude, double longitude, string title, string subtitle);
    void removeAnnotation(string title, string subtitle);
 
...
 
private:
 
...
 
    vector< MKPointAnnotation * > annotations;
 
...
 
};

...
 
void ofxiPhoneMapKit::selectedAnnotation(string title, string subtitle) {
    for(std::list<ofxiPhoneMapKitListener*>::iterator it=listeners.begin(); it!=listeners.end(); ++it) {
        ofxiPhoneMapKitListener* o = *it;
        o->selectedAnnotation(title, subtitle);
    }
}
 
 
void ofxiPhoneMapKit::unselectedAnnotation(string title, string subtitle) {
    for(std::list<ofxiPhoneMapKitListener*>::iterator it=listeners.begin(); it!=listeners.end(); ++it) {
        ofxiPhoneMapKitListener* o = *it;
        o->unselectedAnnotation(title, subtitle);
    }
}
 
 
void ofxiPhoneMapKit::addAnnotation(double latitude,
                                    double longitude,
                                    string title,
                                    string subtitle)
{
    CLLocationCoordinate2D annotationCoord;
     
    annotationCoord.latitude = latitude;
    annotationCoord.longitude = longitude;
     
    MKPointAnnotation *annotationPoint = [[MKPointAnnotation alloc] init];
    annotationPoint.coordinate = annotationCoord;
    annotationPoint.title = ofxStringToNSString(title);
    annotationPoint.subtitle = ofxStringToNSString(subtitle);
    [mapView addAnnotation:annotationPoint];
    annotations.push_back(annotationPoint);
}
 
void ofxiPhoneMapKit::removeAnnotation(string title,
                                       string subtitle)
{
     
    for (vector<MKPointAnnotation *>::iterator it = annotations.begin(); it != annotations.end(); it++) {
        if ([(*it).title isEqualToString:ofxStringToNSString(title)] &&
            [(*it).subtitle isEqualToString:ofxStringToNSString(subtitle)]) {
            ofLog(OF_LOG_NOTICE, "Removing annotation\n");
            [mapView removeAnnotation:(*it)];
            [(*it) release];
            annotations.erase(it);
            break;
        }
    }
     
}
 
void ofxiPhoneMapKit::removeAnnotation(double latitude,
                                       double longitude,
                                       string title,
                                       string subtitle)
{
     
    for (vector<MKPointAnnotation *>::iterator it = annotations.begin(); it != annotations.end(); it++) {
        if ((*it).coordinate.latitude == latitude &&
            (*it).coordinate.longitude == longitude &&
            [(*it).title isEqualToString:ofxStringToNSString(title)] &&
            [(*it).subtitle isEqualToString:ofxStringToNSString(subtitle)]) {
            [mapView removeAnnotation:(*it)];
            [(*it) release];
            annotations.erase(it);
            break;
        }
    }
     
}
 
...

...
 
class ofxiPhoneMapKitListener { 
public:
    virtual ~ofxiPhoneMapKitListener() {};
    virtual void regionWillChange(bool animated) {}
    virtual void regionDidChange(bool animated) {}
    virtual void willStartLoadingMap() {}
    virtual void didFinishLoadingMap() {}
    virtual void errorLoadingMap(string errorDescription) {}
    virtual void selectedAnnotation(string title, string subtitle) {}
    virtual void unselectedAnnotation(string title, string subtitle) {}
};

...
 
class testApp : public ofxiPhoneApp, ofxiPhoneMapKitListener{
public:
 
...
 
        // additional optional callbacks for annotations
        void selectedAnnotation(string title, string subtitle);
        void unselectedAnnotation(string title, string subtitle);
 
...
 
};

...
 
//--------------------------------------------------------------
void testApp::selectedAnnotation(string title, string subtitle){
    printf("testApp::selectedAnnotation | title: %s, subtitle: %s\n", title.c_str(), subtitle.c_str());
}
 
//--------------------------------------------------------------
void testApp::unselectedAnnotation(string title, string subtitle){
    printf("testApp::unselectedAnnotation | title: %s, subtitle: %s\n", title.c_str(), subtitle.c_str());
}
 
...

mapKit.addAnnotation(coreLocation.getLatitude(), coreLocation.getLongitude(), "This is the Title", "I'm the subtitle...");

#pragma once
 
#include "ofMain.h"
#include "ofxCvMain.h"
 
class testApp : public ofBaseApp{
 
public:
         
    // redeclaration of functions (declared in base class)
    void setup();
    void update();
    void draw();
 
    void keyPressed(int key);
 
    ofVideoGrabber camera;
     
    ofxCvColorImage im_color;
    ofxCvGrayscaleImage im_red, im_green, im_blue;
    ofxCvGrayscaleImage im_gray;
    ofxCvGrayscaleImage im_value;
     
 
    int imgWidth, imgHeight;
     
    bool bShowBlended;
};

#include "testApp.h"
 
// here we "define" the methods we "declared" in the "testApp.h" file
 
// i get called once
void testApp::setup(){
     
    // do some initialization
    imgWidth = 320;
    imgHeight = 240;
     
    bShowBlended = false;
     
    // set the size of the window
    ofSetWindowShape(imgWidth * 6, imgHeight);
     
    // the rate at which the program runs (FPS)
    ofSetFrameRate(30);
     
    // setup the camera
    camera.initGrabber(imgWidth, imgHeight);
    im_color.allocate(imgWidth, imgHeight);
    im_red.allocate(imgWidth, imgHeight);
    im_green.allocate(imgWidth, imgHeight);
    im_blue.allocate(imgWidth, imgHeight);
    im_gray.allocate(imgWidth, imgHeight);
    im_value.allocate(imgWidth, imgHeight);
}
 
// i get called in a loop that runs until the program ends
void testApp::update(){
    camera.update();
     
    if(camera.isFrameNew())
    {
        // copy the pixels from the camera object into an ofxCvColorImage object
        im_color.setFromPixels(camera.getPixels(), imgWidth, imgHeight);
         
        im_gray = im_color;
         
        // get each color channel
        im_color.convertToGrayscalePlanarImages(im_red, im_green, im_blue);
         
        im_color.convertRgbToHsv();
        im_color.convertToGrayscalePlanarImage(im_value, 2);
    }
}
 
// i also get called in a loop that runs until the program ends
void testApp::draw(){
    // background values go to 0
    ofBackground(0);
     
    // draw the camera
    ofSetColor(255, 255, 255);
    camera.draw(imgWidth * 0,0);
     
    if(bShowBlended)
    {
        // blending mode for adding pictures together
        ofEnableAlphaBlending();
        ofEnableBlendMode(OF_BLENDMODE_ADD);
         
        // full red energy
        ofSetColor(255, 0, 0);
        im_red.draw(imgWidth * 1,0);
         
        // full green energy
        ofSetColor(0, 255, 0);
         
        // draw using an offset from the center of the screen determined by the mouse position
        im_green.draw(imgWidth * 1 + (mouseX - ofGetScreenWidth()/2) / 10.0,0);
         
        // full blue energy
        ofSetColor(0, 0, 255);
         
        // offset just like above, but 2x as much
        im_blue.draw(imgWidth * 1 + (mouseX - ofGetScreenWidth()/2) / 5.0,0);
         
        ofDisableAlphaBlending();
    }
    else
    {
        ofSetColor(255, 0, 0);
        im_red.draw(imgWidth * 1,0);
         
        ofSetColor(0, 255, 0);
        im_green.draw(imgWidth * 2,0);
         
        ofSetColor(0, 0, 255);
        im_blue.draw(imgWidth * 3,0);
    }
     
    ofSetColor(255, 255, 255);
    im_gray.draw(imgWidth * 4, 0);
    im_value.draw(imgWidth * 5, 0);
}
 
void testApp::keyPressed(int key)
{
    switch (key) {
        case 's':
            camera.videoSettings();
            break;
             
        // press space to switch between modes    
        case ' ':
            bShowBlended = !bShowBlended;
            break;
        default:
            break;
    }
}

#pragma once
 
#include "ofMain.h"
#include "ofxOpenCv.h"
 
class testApp : public ofBaseApp{
 
public:
    void setup();
    void update();
    void draw();    
      
    float                   alpha;
    float                   sum;
    ofVideoGrabber          camera;
 
    ofxCvColorImage         color_img;
 
    ofxCvGrayscaleImage     gray_img;
    ofxCvGrayscaleImage     gray_previous_img;
    ofxCvGrayscaleImage     gray_diff;
 
    ofVideoPlayer           video;
 
    vector<ofxCvGrayscaleImage> previous_imgs;
 
    int                     img_width, img_height;
};

#include "testApp.h"
 
using namespace cv;
 
//--------------------------------------------------------------
void testApp::setup(){
 
    // keep variables for our image size
    img_width = 320;
    img_height = 240;
     
    // value for our first order linear filter
    // this controls how much we mix in previous results
    // the larger the value, the larger the weight of the 
    // previous result.  this is a very essential and basic
    // technique in digital signal processing also known as a 
    // low pass filter.
    alpha = 0.5;
     
    // change the window to hold enough space for 2 movies (1 row x 2 columns of movies)
    ofSetWindowShape(img_width * 2, img_height);
     
    ofSetFrameRate(30);
     
    // initialize our camera with a resolution of 320z240
    camera.initGrabber(img_width, img_height);
     
    // load a movie in and set it to loop, and then start it (play())
    video.loadMovie("sunra_pink.mov");
    video.setLoopState(OF_LOOP_NORMAL);
    video.play();
     
    sum = 0;
     
    // these are (wrappers for) opencv image containers 
    // we'll use for image processing
    // we are going to find the difference between successive frames
    color_img.allocate(img_width, img_height);
    gray_img.allocate(img_width, img_height);
    gray_previous_img.allocate(img_width, img_height);
    gray_diff.allocate(img_width, img_height);
    previous_imgs.push_back(gray_previous_img);
    previous_imgs.push_back(gray_previous_img);
    previous_imgs.push_back(gray_previous_img);
     
}
 
//--------------------------------------------------------------
void testApp::update(){
    // background to black
    ofBackground(0);
     
    // update the camera
    camera.update();
     
    if (camera.isFrameNew()) {
        // set the color image (opencv container) to the camera image
        color_img.setFromPixels(camera.getPixels(), img_width, img_height);
        // convert to grayscale
        gray_img = color_img;
        // calculate the difference image
        gray_diff = gray_img;
        // compute the absolute difference with the previous frame's grayscale image
        gray_diff.absDiff(previous_imgs[0]);
         
        Mat diff_mat(gray_diff.getCvImage());
        Scalar s1 = mean(diff_mat);
         
         
        // store the current grayscale image for the next iteration of update()
        previous_imgs.push_back(gray_img);
        if (previous_imgs.size() > 10) {
            previous_imgs.erase(previous_imgs.begin());
        }
         
        // let's threshold the difference image,
        // all values less than 10 are 0, all values above 10 become 255
        //gray_diff.threshold(10);
         
        // here we will find the sum and then average of all the pixels in the difference image
        // this will be used for a simple measure of "motion" 
        // we use a low-pass filter, a first order filter which combines the current 
        // value with the previous one, using a linear weighting.
        sum = (alpha) * sum + 
        (1 - alpha) * s1[0] / 10.0f;//cvSum(gray_diff.getCvImage()).val[0] / (float)img_width / (float)img_height / 10.0;
         
         
        // let's change the speed of our movie based on the motion value we calculated
        video.setSpeed(sum);
        video.update();
    }
     
     
}
 
//--------------------------------------------------------------
void testApp::draw(){
    ofEnableAlphaBlending();
    ofEnableBlendMode(OF_BLENDMODE_ADD);
     
    color_img.draw(0, 0, img_width, img_height);
    gray_diff.draw(0, 0, img_width, img_height);
 
    ofDisableAlphaBlending();
     
    video.draw(img_width, 0);
     
    // draw the sum of the motion pixels divided by the number of motion pixels 
    // (average of difference values)
    char buf[256];
    sprintf(buf, "%f", sum);
    ofDrawBitmapString(buf, 20, 20);
}

#pragma once
 
#include "ofMain.h"
#include "ofxCvMain.h"
 
using namespace cv;
 
class testApp : public ofBaseApp{
 
public:
         
    // redeclaration of functions (declared in base class)
    void setup();
    void setupFeatures();
     
    void update();
    void draw();
 
    void keyPressed(int key);
     
    int width, height;
    float scalar;
     
    ofVideoGrabber camera;
 
    ofxCvColorImage cv_color_img;
    ofxCvGrayscaleImage cv_luminance_img;
     
    Mat mat_image;
     
    unsigned int current_detector; 
    vector<string> feature_detectors;
     
    cv::Ptr<FeatureDetector> feature_detector;
    vector<KeyPoint> keypoints;
};

#include "testApp.h"
 
// here we "define" the methods we "declared" in the "testApp.h" file
 
// i get called once
void testApp::setup(){
     
    scalar = 1.0f;
    width = 640;
    height = 480;
     
    camera.initGrabber(width, height);
     
    cv_color_img.allocate(width, height);
    cv_luminance_img.allocate(width, height);
     
    feature_detectors.push_back("SURF");
    feature_detectors.push_back("DynamicSURF");
    feature_detectors.push_back("PyramidSURF");
    feature_detectors.push_back("GridSURF");
    feature_detectors.push_back("SIFT");
    feature_detectors.push_back("STAR");
    feature_detectors.push_back("DynamicSTAR");
    feature_detectors.push_back("PyramidSTAR");
    feature_detectors.push_back("GridSTAR");
    feature_detectors.push_back("FAST");
    feature_detectors.push_back("DynamicFAST");
    feature_detectors.push_back("PyramidFAST");
    feature_detectors.push_back("GridFAST");
    feature_detectors.push_back("GFTT");
    feature_detectors.push_back("PyramidGFTT");
    feature_detectors.push_back("MSER");
    feature_detectors.push_back("PyramidMSER");
    feature_detectors.push_back("HARRIS");
    feature_detectors.push_back("PyramidHARRIS");
     
    current_detector = 0;
    feature_detector = FeatureDetector::create(feature_detectors[current_detector]);
     
    ofSetFrameRate(60.0f);
    ofSetWindowShape(width * scalar, height * scalar);
}
 
// i get called in a loop that runs until the program ends
void testApp::update(){
    camera.update();
    if (camera.isFrameNew()) {
        cv_color_img.setFromPixels(camera.getPixelsRef());
        cv_color_img.convertRgbToHsv();
        cv_color_img.convertToGrayscalePlanarImage(cv_luminance_img, 2);
         
        mat_image = Mat(cv_luminance_img.getCvImage());
         
        keypoints.clear();
        feature_detector->detect(mat_image, keypoints);
    }
}
 
// i also get called in a loop that runs until the program ends
void testApp::draw(){
    ofBackground(0);
     
    ofPushMatrix();
    ofScale(scalar, scalar);
     
    ofSetColor(255, 255, 255);
    camera.draw(0, 0);
     
    ofNoFill();
    ofSetColor(200, 100, 100);
    vector<KeyPoint>::iterator it = keypoints.begin();
    while(it != keypoints.end())
    {
        ofPushMatrix();
        float radius = it->size/2;
        ofTranslate(it->pt.x - radius, it->pt.y - radius, 0);
        ofRotate(it->angle, 0, 0, 1);
        ofRect(0, 0, radius, radius);
        ofPopMatrix();
        it++;
    }
    ofPopMatrix();
     
    ofSetColor(255, 255, 255);
    string draw_string = ofToString(current_detector+1) + string("/") + 
                        ofToString(feature_detectors.size()) + string(": ") +
                        feature_detectors[current_detector];
    ofDrawBitmapString(draw_string, 20, 20);
    draw_string = string("# of features: ") + ofToString(keypoints.size());
    ofDrawBitmapString(draw_string, 20, 35);
    draw_string = string("fps: ") + ofToString(ofGetFrameRate());
    ofDrawBitmapString(draw_string, 20, 50);
}
 
void testApp::keyPressed(int key){
    if(key == 'n')
    {
        current_detector = (current_detector + 1) % feature_detectors.size();
        feature_detector = FeatureDetector::create(feature_detectors[current_detector]);
    }
}

/*
*  Created by Parag K. Mital - http://pkmital.com 
*  Contact: parag@pkmital.com
*
*  Copyright 2011 Parag K. Mital. All rights reserved.
* 
*   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 _TEST_APP
#define _TEST_APP
 
#include "ofMain.h"
 
#include "pkmImageFeatureDetector.h"
 
#include "ofxOpenCv.h"
 
const int CAM_WIDTH = 320;
const int CAM_HEIGHT = 240;
const int SCREEN_WIDTH = CAM_WIDTH*2;
const int SCREEN_HEIGHT = CAM_HEIGHT + 75;
 
class testApp : public ofBaseApp {
 
    public:
 
    ~testApp();
    void setup();
      
    void update();
    void draw();
    void drawKeypoints(vector<KeyPoint> keypts);
 
    void keyPressed  (int key);
    void mouseMoved(int x, int y );
    void mouseDragged(int x, int y, int button);
    void mousePressed(int x, int y, int button);
    void mouseReleased(int x, int y, int button);
    void windowResized(int w, int h);
     
    ofVideoGrabber          camera;
     
    ofxCvColorImage         color_img, color_roi_img;
    ofxCvGrayscaleImage     gray_search_img, 
                            gray_template_img;
     
    float                   x_start, 
                            x_end, 
                            y_start, 
                            y_end;
     
    cv::Point2f             low_pass_bounding_box[4],
                            prev_pass_bounding_box[4];
     
    float                   alpha;
     
    bool                    choosing_img, 
                            chosen_img;
     
    pkmImageFeatureDetector detector;
     
    vector<cv::KeyPoint>    img_template_keypoints,
                            img_search_keypoints;
     
};
#endif

/*
 *  Created by Parag K. Mital - http://pkmital.com 
 *  Contact: parag@pkmital.com
 *
 *  Copyright 2011 Parag K. Mital. All rights reserved.
 * 
 *  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 "testApp.h"
//--------------------------------------------------------------
testApp::~testApp(){
}
void testApp::setup(){
     
    // init video input
    camera.initGrabber(CAM_WIDTH,CAM_HEIGHT);
    camera.setUseTexture(true);
     
    // window setup
    ofSetWindowShape(SCREEN_WIDTH, SCREEN_HEIGHT);
    ofSetVerticalSync(true);
    ofSetFrameRate(60);
    ofBackground(0,0,0);
     
    // allocate stuff
    color_img.allocate(CAM_WIDTH, CAM_HEIGHT);
    gray_search_img.allocate(CAM_WIDTH, CAM_HEIGHT);
     
    alpha = 0.6;
     
    choosing_img = false;
    chosen_img = false;
     
}
 
//--------------------------------------------------------------
void testApp::update(){
     
    camera.update();
    if(camera.isFrameNew())
    {
        // get camera img into iplimage
        color_img.setFromPixels(camera.getPixels(), CAM_WIDTH, CAM_HEIGHT);
        color_img.convertRgbToHsv();
        if (chosen_img) {
            color_img.convertToGrayscalePlanarImage(gray_search_img, 2);
            detector.setImageSearch(gray_search_img.getCvImage());
            detector.update();
             
            img_search_keypoints = detector.getImageSearchKeypoints();
             
            ofCircle(detector.dst_corners[0].x, detector.dst_corners[0].y, 10);
             
            low_pass_bounding_box[0] = detector.dst_corners[0] * (1-alpha) + prev_pass_bounding_box[0] * alpha;
            low_pass_bounding_box[1] = detector.dst_corners[1] * (1-alpha) + prev_pass_bounding_box[1] * alpha;
            low_pass_bounding_box[2] = detector.dst_corners[2] * (1-alpha) + prev_pass_bounding_box[2] * alpha;
            low_pass_bounding_box[3] = detector.dst_corners[3] * (1-alpha) + prev_pass_bounding_box[3] * alpha;
             
            prev_pass_bounding_box[0] = low_pass_bounding_box[0];
            prev_pass_bounding_box[1] = low_pass_bounding_box[1];
            prev_pass_bounding_box[2] = low_pass_bounding_box[2];
            prev_pass_bounding_box[3] = low_pass_bounding_box[3];
        }
    } 
}
 
//--------------------------------------------------------------
void testApp::draw(){
    ofBackground(0,0,0);
     
    ofSetColor(255, 255, 255);
    // camera image
    camera.draw(0, 0);
     
    if (chosen_img) {
        ofSetColor(200, 100, 100);
        drawKeypoints(img_search_keypoints);
         
         
        ofPushMatrix();
        ofTranslate(CAM_WIDTH, 0, 0);
        ofSetColor(255, 255, 255);
        gray_template_img.draw(0, 0);
        ofSetColor(200, 100, 100);
        drawKeypoints(img_template_keypoints);
        ofPopMatrix();
         
        ofSetColor(200, 200, 200);
         
        ofLine(low_pass_bounding_box[0].x, low_pass_bounding_box[0].y,
               low_pass_bounding_box[1].x, low_pass_bounding_box[1].y);
         
        ofLine(low_pass_bounding_box[2].x, low_pass_bounding_box[2].y,
               low_pass_bounding_box[1].x, low_pass_bounding_box[1].y);
         
        ofLine(low_pass_bounding_box[2].x, low_pass_bounding_box[2].y,
               low_pass_bounding_box[3].x, low_pass_bounding_box[3].y);
         
        ofLine(low_pass_bounding_box[0].x, low_pass_bounding_box[0].y,
               low_pass_bounding_box[3].x, low_pass_bounding_box[3].y);
         
    }
     
     
    // draw a rectanlge around the current selection
    if (choosing_img) {
        int x = mouseX;
        int y = mouseY;
         
        ofNoFill();
        ofRect(x_start < x ? x_start : x, 
               y_start < y ? y_start : y, 
               abs(x_start - x), 
               abs(y_start - y));
         
    }
     
     
}
 
void testApp::drawKeypoints(vector<KeyPoint> keypts)
{
    vector<KeyPoint>::iterator it = keypts.begin();
    while(it != keypts.end())
    {
        ofPushMatrix();
        float radius = it->size/2;
        ofTranslate(it->pt.x - radius, it->pt.y - radius, 0);
        ofRotate(it->angle, 0, 0, 1);
        ofRect(0, 0, radius, radius);
        ofPopMatrix();
        it++;
    }
 
}
 
 
//--------------------------------------------------------------
void testApp::keyPressed  (int key){
     
    switch (key){           
        case 's':
            camera.videoSettings();
            break;
        case 'n':
        {
            detector.changeDetector();
            if(chosen_img)
               img_template_keypoints = detector.getImageTemplateKeypoints();
            break;
        }
        case '1':
            break;
        case '2':
            break;
             
        case 'b':
            break;
             
    }
}
 
//--------------------------------------------------------------
void testApp::mouseMoved(int x, int y ){
}
 
//--------------------------------------------------------------
void testApp::mouseDragged(int x, int y, int button){
}
 
//--------------------------------------------------------------
void testApp::mousePressed(int x, int y, int button){
     
    // start a rectangle selection
    if(!choosing_img)
    {
        choosing_img = true;
        x_start = x;
        y_start = y;
    }
}
 
//--------------------------------------------------------------
void testApp::mouseReleased(int x, int y, int button){
     
    // end the rectangle selection
    if (choosing_img) {
        choosing_img = false;
        x_end = x;
        y_end = y;
         
        if(x_start > x_end)
            std::swap(x_start, x_end);
        if(y_start > y_end)
            std::swap(y_start, y_end);
         
        int w = x_end - x_start;
        int h = y_end - y_start;
         
         
        cvSetImageROI(color_img.getCvImage(), 
                      cvRect(x_start, 
                             y_start, 
                             w, h));
         
        if (color_roi_img.bAllocated) {
            gray_template_img.clear();
            color_roi_img.clear();
        }
        gray_template_img.allocate(w, h);
        color_roi_img.allocate(w, h);
        color_roi_img = color_img;
        color_roi_img.convertToGrayscalePlanarImage(gray_template_img, 2);
        cvResetImageROI(color_img.getCvImage());
 
        detector.setImageTemplate(gray_template_img.getCvImage());
         
        img_template_keypoints = detector.getImageTemplateKeypoints();
         
        chosen_img = true;
    }
     
}
 
//--------------------------------------------------------------
void testApp::windowResized(int w, int h){
     
}