/home/jgoppert/Projects/uvsim/uvsim/src/apps/MainWindow.cc

Go to the documentation of this file.

/*
 * MainWindow.cc
 * Copyright (C) Eduardo Wiputra 2009 <ewiputra@users.sourceforge.net>
 *
 * MainWindow.cc 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.
 *
 * MainWindow.cc 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/>.
 */
#include <iostream>
#include <fstream>
#include <string>
#include "MainWindow.h"
#include "uvsim/guidance/GeoCoord.h"
#include "uvsim/control/ControlComm.h"
#include "uvsim/systems/UgvSystem.h"
#include <uvsim/utilities/RealtimeThread.h>

namespace uvsim
{

int keyDown; //Value of keyboard's keys that are pressed
int setCounter = 0; //Counter to which waypoint is the closest
int orderCounter = 0; //Counter on whether the mouse has been clicked or not

MainWindow::MainWindow(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& glade)
        : Gtk::Window(cobject), m_glade(glade), ManualButton("Manual Button is Off"), AutomaticButton("Automatic Button is Off")
{
    std::cout << "Constructing MainWindow" << std::endl;

    // Setup Gui
    show_all();
    m_glade->get_widget_derived("mapArea", m_pMapArea); //Get widget "mapArea"
    m_glade->get_widget_derived("hudDisplay", m_HUDView); //Get widget "hudDisplay"
    m_glade->get_widget_derived("3DView", m_ThreeDView); //Get widget "3DView"
    m_glade->get_widget("Commands", m_Commands); //Get widget "Commands"
    m_glade->get_widget("About", m_About); //Get widget "About"
    m_glade->get_widget("OffControl", m_OffControl); //Get widget Radio Button "Off"
    m_glade->get_widget("AutomaticControl", m_AutomaticControl); //Get widget Radio Button "Automatic"
    m_glade->get_widget("ManualControl", m_ManualControl); //Get widget Radio Button "Manual"

    //Connect widget to each function
    m_Commands->signal_activate().connect(sigc::mem_fun(*this, &MainWindow::Commands));
    m_About->signal_activate().connect(sigc::mem_fun(*this, &MainWindow::About));
    m_OffControl->signal_pressed().connect(sigc::mem_fun(*this, &MainWindow::offControl));
    m_AutomaticControl->signal_pressed().connect(sigc::mem_fun(*this, &MainWindow::automaticControl));
    m_ManualControl->signal_pressed().connect(sigc::mem_fun(*this, &MainWindow::manualControl));

    /*  m_glade->get_widget("Mapm_pMapArea->m_zoom", m_Mapm_pMapArea->m_zoom);
        m_glade->get_widget("button1", m_Button1);
        m_glade->get_widget("button2", m_Button2);
        m_glade->get_widget("button3", m_Button3);
        m_glade->get_widget("button4", m_Button4);
        m_pMapArea->m_zoom->signal_value_changed().connect(sigc::mem_fun(*this, &MainWindow::on_Scroll1));
        m_Button1->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::on_Button1));
        m_Button2->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::on_Button2));
        m_Button3->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::on_Button3));
        m_Button4->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::on_Button4));*/

    add_events(Gdk::POINTER_MOTION_MASK | Gdk::POINTER_MOTION_HINT_MASK |
               Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK);

    show_all();
}

void MainWindow::Commands()
{
    //Create message dialog
    Gtk::MessageDialog command_dialog(*this,
                                      "\tKeyboard Commands\n---------------------------------------------\nArrow Keys\tPanning\n+\t\t\tZooming In\n-\t\t\tZooming Out\nA or a\t\tAdding Waypoints\nM or m\t\tMoving Waypoints\nD or d\t\tDeleting Waypoints\nJ or j\t\tRolling Left\nL or l\t\tRolling Right\nK or k\t\tPitching Up\nI or i\t\tPitching Down\nU or u\t\tYawing Left\nO or o\t\tYawing Right",false, Gtk::MESSAGE_INFO, Gtk::BUTTONS_OK, true);
    command_dialog.run();
}

void MainWindow::About()
{
    //Create message dialog
    Gtk::MessageDialog about_dialog(*this,
                                    "\t\tUVsim GUI\n\n\n\n\t\tVersion 0.0.0\n\n\t\tPurdue University", false,
                                    Gtk::MESSAGE_INFO, Gtk::BUTTONS_OK, true);
    about_dialog.run();
}

void MainWindow::offControl()
{
    std::cout << "Control off " << std::endl;
    //ManualButton = "Manual Button is Off";
    //AutomaticButton = "Automatic Button is Off";
    if (m_ugvSystem.getControlThread() != NULL)
    {
        std::cout<<"Destructor"<<std::endl;
        delete m_ugvSystem.getControlThread();
        m_ugvSystem.setControlThread(NULL);
    }
}

void MainWindow::automaticControl()
{
    std::cout << "Automatic Control On " << std::endl;
    // Create and start thread if it isn't allocated
    if (m_ugvSystem.getControlThread() == NULL)
    {
        m_ugvSystem.setControlThread(new ControlThread("/dev/rfcomm1",7,0,true));
        m_ugvSystem.getControlThread()->start();
    }

    // Set to Auto mode
    m_ugvSystem.getControlThread()->setControlMode(AUTO);
}

void MainWindow::manualControl()
{
    std::cout << "Manual Control On " << std::endl;
    //ManualButton = "Manual Button is On ";
    //AutomaticButton = "Automatic Button is Off";

    // Create and start thread if it isn't allocated
    if (m_ugvSystem.getControlThread() == NULL)
    {
        m_ugvSystem.setControlThread(new ControlThread("/dev/rfcomm1",7,0,true));
        m_ugvSystem.getControlThread()->start();
    }

    // Set to manual mode
    m_ugvSystem.getControlThread()->setControlMode(MANUAL);
}

bool MainWindow::on_key_press_event(GdkEventKey* event)
{
    if (event->keyval == GDK_Escape)
    {
        Gtk::Main::quit(); //If Esc is pressed, the program will quit
    }
    else
    {
        keyDown = event->keyval; //The value of key pressed in keyboard
        keyboardInput(keyDown);
    }
    return true;
}

void MainWindow::keyboardInput(int keyDown)
{
    double height = (m_pMapArea->image)->get_height(); //Height of image
    double width = (m_pMapArea->image)->get_width(); //Width of image
    double height_window = m_pMapArea->get_height(); //Height of map area
    double width_window = m_pMapArea->get_width(); //Width of map areclass ControlThread : public RealtimeThread { virtual void loop(); }a
    double panLRMax = width * m_pMapArea->m_zoom - width_window; // Maximum left-right pan
    double panUDMax = height * m_pMapArea->m_zoom - height_window; //Maximum up-down pan
    double panLRsize = width / width_window / m_pMapArea->m_zoom * 10; //Left-right pan size
    double panUDsize = height / height_window / m_pMapArea->m_zoom * 10; //Up-down pan size
    int counter; //Loop counter
    std::vector<GeoCoord> waypoint; //Vector of waypoint from class GeoCoord

    //Force panLRMax and panUDMax to be 0 if they were less than 0
    if (panLRMax < 0)
    {
        panLRMax = 0;
    }
    if (panUDMax < 0)
    {
        panUDMax = 0;
    }

    //Get the flightplan data
    flightPlan = m_guide.getFlightPlan();
    waypoint = *flightPlan;

    //void MainWindow::on_Scroll1()
    if (keyDown == GDK_plus)
    {
        //"+" is pressed on the keyboard.
//      m_pMapArea->m_zoom = (m_Mapm_pMapArea->m_zoom->Gtk::Range::get_adjustment())->get_value();
        if (m_pMapArea->m_zoom <= 5)
        {
            //For zooming less than or equal to 5
            m_pMapArea->m_zoom = m_pMapArea->m_zoom + 0.1;
        }
        else
        {
            //For zooming greater than 5
            m_pMapArea->m_zoom = 5;
        }
        std::cout << "Zoom Level: " << m_pMapArea->m_zoom << std::endl;
        m_pMapArea->drawInitial(); //Draw the entire mapArea
    }

    if (keyDown == GDK_minus)
    {
        //"-" is pressed on the keyboard.
        if (m_pMapArea->m_zoom > 1)
        {
            //For zooming greater than 1
            m_pMapArea->m_zoom = m_pMapArea->m_zoom - 0.1;
        }
        else
        {
            //For zooming less than or equal to 1
            m_pMapArea->m_zoom = 1;
        }
        std::cout << "Zoom Level: " << m_pMapArea->m_zoom << std::endl;
        m_pMapArea->drawInitial();
    }

//void MainWindow::on_Button1()class ControlThread : public RealtimeThread { virtual void loop(); }
    if (keyDown == GDK_Right)
    {
        //Right arrow is pressed on the keyboard
        if (m_pMapArea->m_panLR >= (panLRMax * 0.95))
        {
            //Set the left-right pan equals to its maximum when
            //it becomes greater than or equal to 95% of its maximum
            m_pMapArea->m_panLR = panLRMax;
        }
        else if (m_pMapArea->m_panLR >= (panLRMax * 0.90))
        {
            //Set the left-right pan to increase by 20% of its size when it reaches 90% of its maximum
            m_pMapArea->m_panLR = m_pMapArea->m_panLR + panLRsize * 0.2;
        }
        else
        {
            //Set the left-right pan to increase by its size if it is still less than 90% of its maximum
            m_pMapArea->m_panLR = m_pMapArea->m_panLR + panLRsize;
        }
        if (m_pMapArea->m_panLR >= panLRMax)
        {
            //Forces the left-right pan to equal to its maximum
            //if it becomes greater than or equal to its maximum
            m_pMapArea->m_panLR = panLRMax;
        }
        std::cout << "Pan Right: " << m_pMapArea->m_panLR << std::endl;
        m_pMapArea->drawInitial();
    }

//void MainWindow::on_Button2()
    if (keyDown == GDK_Left)
    {
        //Left arrow is pressed on the keyboard
        if (m_pMapArea->m_panLR <= panLRMax * 0.05)
        {
            //Within 5% of maximum left-right pan, set left-right pan equals to 0
            m_pMapArea->m_panLR = 0;
        }
        else if (m_pMapArea->m_panLR <= panLRMax * 0.1)
        {
            //Within 10% of maximum left-right pan, set the decrement to be 20% of its size
            m_pMapArea->m_panLR = m_pMapArea->m_panLR - panLRsize * 0.2 ;
        }
        else
        {
            //If greater than 10% of maximum left-right pan, set the decrement to be its size
            m_pMapArea->m_panLR = m_pMapArea->m_panLR - panLRsize;
        }
        //Forces the left-right pan to equal to 0 when it gets within 5% of its maximum
        if (m_pMapArea->m_panLR <= panLRMax * 0.05)
        {
            m_pMapArea->m_panLR = 0;
        }
        std::cout << "Pan Left: " << m_pMapArea->m_panLR << std::endl;
        m_pMapArea->drawInitial();
    }

//void MainWindow::on_Button3()
    if (keyDown == GDK_Up)
    {
        //Up arrow is pressed on the keyboard
        if (m_pMapArea->m_panUD < panUDMax * 0.05)
        {
            //Within 5% of maximum up-down pan, set the up-down pan equals to 0
            m_pMapArea->m_panUD = 0;
        }
        else if (m_pMapArea->m_panUD <= panUDMax * 0.1)
        {
            //Within 10% of maximum up-down pan, set the decrement to be 20% of its size
            m_pMapArea->m_panUD = m_pMapArea->m_panUD - panUDsize * 0.2;
        }
        else
        {
            //If greater than 10% of maximum up-down pan, set the decrement to be its size
            m_pMapArea->m_panUD = m_pMapArea->m_panUD - panUDsize;
        }
        //Forces the up-down pan to equal to 0 when it gets within 5% of class ControlThread : public RealtimeThread { virtual void loop(); }its maximum
        if (m_pMapArea->m_panUD < panUDMax * 0.05)
        {
            m_pMapArea->m_panUD = 0;
        }
        std::cout << "Pan Up: " << m_pMapArea->m_panUD << std::endl;
        m_pMapArea->drawInitial();
    }

//void MainWindow::on_Button4()
    if (keyDown == GDK_Down)
    {
        //Down arrow is pressed on the keyboard
        if (m_pMapArea->m_panUD >= (panUDMax * 0.95))
        {
            //Set the up-down pan equals to its maximum whenclass ControlThread : public RealtimeThread { virtual void loop(); }
            //it becomes greater than or equal to 95% of its maximum
            m_pMapArea->m_panUD = panUDMax;
        }
        else if (m_pMapArea->m_panUD >= (panUDMax * 0.90))
        {
            //Set the up-down pan to increase by 20% of its size when it reachhes 90% of its maximum
            m_pMapArea->m_panUD = m_pMapArea->m_panUD + panUDsize * 0.2;
        }
        else
        {
            //Set the up-down pan to increase by its size if it is still less than 90% of its maximum
            m_pMapArea->m_panUD = m_pMapArea->m_panUD + panUDsize;
        }
        if (m_pMapArea->m_panUD >= panUDMax)
        {
            //Forces the up-down pan to equal to its maximum
            //if it becomes greater than or equal to its maximumclass ControlThread : public RealtimeThread { virtual void loop(); }
            m_pMapArea->m_panUD = panUDMax;
        }
        std::cout << "Pan Down: " << m_pMapArea->m_panUD << std::endl;
        m_pMapArea->drawInitial();
    }


    if ((keyDown == GDK_M || keyDown == GDK_m || keyDown == GDK_D ||
            keyDown == GDK_d || keyDown == GDK_A || keyDown == GDK_a) && waypoint.size() != 0)
    {
        //Draw red circle among all waypoints when "M", "m", "D", "d", "A", or "a" is pressed.
        m_pMapArea->drawRedCircle(waypoint);
    }

    if (keyDown == GDK_K || keyDown == GDK_k)
    {
        //Increases pitch angle when "K" or "k" is pressed
        m_HUDView->pitchangle = m_HUDView->pitchangle + 1;
        if (m_HUDView->pitchangle >= 360)
        {
            //Resets back to to within 0 to 359 when it gets to 360
            m_HUDView->pitchangle = -360 + m_HUDView->pitchangle;
        }
        m_HUDView->drawTopPart(); //Only redraw the top part of HUD which is the center circle and inside
        std::cout << "Pitching: " << m_HUDView->pitchangle << std::endl;
    }

    if (keyDown == GDK_I || keyDown == GDK_i)
    {
        //Decreases pitch angle when "I" or "i" is pressed
        m_HUDView->pitchangle = m_HUDView->pitchangle - 1;
        if (m_HUDView->pitchangle <= -360)
        {
            //Resets back to within 0 to 359 when it gets to -360
            m_HUDView->pitchangle = -360 - m_HUDView->pitchangle;
        }
        m_HUDView->drawTopPart();
        std::cout << "Pitching: " << m_HUDView->pitchangle << std::endl;
    }

    if (keyDown == GDK_J || keyDown == GDK_j)
    {
        //Increases Right banking when "J" or "j" is pressed
        m_HUDView->rolldegree = m_HUDView->rolldegree + 1;
        if (m_HUDView->rolldegree >= 360)
        {
            //Resets back to 0 to 359 when it gets to 360
            m_HUDView->rolldegree = m_HUDView->rolldegree - 360;
        }
        m_HUDView->drawTopPart();
        std::cout << "Rolling: " << m_HUDView->rolldegree << std::endl;
    }

    if (keyDown == GDK_L || keyDown == GDK_l)
    {
        //Increases Left banking when "L" or "l" is pressed
        m_HUDView->rolldegree = m_HUDView->rolldegree - 1;
        if (m_HUDView->rolldegree <= -360)
        {
            //Resets back to 0 to 359 when it gets to -360
            m_HUDView->rolldegree = -(m_HUDView->rolldegree + 360);
        }
        m_HUDView->drawTopPart();
        std::cout << "Rolling: " << m_HUDView->rolldegree << std::endl;
    }

    if (keyDown == GDK_O || keyDown == GDK_o)
    {
        //Increases Yawing to the right when "O" or "o" is pressed
        if (m_HUDView->yaw < 45)
        {
            m_HUDView->yaw = m_HUDView->yaw + 1;
        }
        else
        {
            //Sets the maximum right yawing to be 45
            m_HUDView->yaw = 45;
        }
//        m_HUDView->heading++;class ControlThread : public RealtimeThread { virtual void loop(); }
        m_HUDView->drawBottomPart(); //Redraw the bottom part which includes yaw bar and yaw ball
        std::cout << "Yawing: " << m_HUDView->yaw << std::endl;
    }

    if (keyDown == GDK_U || keyDown == GDK_u)
    {
        //Increases Yawing to the left when "U" or "u" is pressed
        if (m_HUDView->yaw > -45)
        {
            m_HUDView->yaw = m_HUDView->yaw - 1;
        }
        else
        {
            //Sets the maximum left-yawing to be -45
            m_HUDView->yaw = -45;
        }
//        m_HUDView->heading--;
        m_HUDView->drawBottomPart();
        std::cout << "Yawing: " << m_HUDView->yaw << std::endl;
    }
}

bool MainWindow::on_button_press_event(GdkEventButton *event)
{
    double height = (m_pMapArea->image)->get_height(); //Height of the image
    double width = (m_pMapArea->image)->get_width(); //Width of the imageclass ControlThread : public RealtimeThread { virtual void loop(); }
    double height_window = m_pMapArea->get_height(); //Height of HUD drawing area
    double width_window = m_pMapArea->get_width(); //Width of HUD drawing area
    double relative_x; //Transformed abssisca from window to map
    double relative_y; //Transformed ordinate from window to map
    double scaleX = m_pMapArea->scaleX; //Ratio between width of image and difference in Latitude of map
    double scaleY = m_pMapArea->scaleY; //Ratio between height of image and difference in Longitude of map
    double distance; //Distance between newly clicked and selected waypoints
    double minimumdistance; //The minimum distance between newly clicked and selected waypoints
    int counter; //Counter for loop
    std::vector<GeoCoord> waypoint; //Vector Waypoint from class GeoCoord

    //Get the flightPlan data and assign it to waypoint
    flightPlan = m_guide.getFlightPlan();
    waypoint = *flightPlan;

    //Transform the coordinate from window to map
    relative_x = m_pMapArea->relative_originX + 1 / (m_pMapArea->m_zoom)
                 * (event->x + m_pMapArea->m_panLR) * scaleX;
    relative_y = m_pMapArea->relative_originY + 1 / (m_pMapArea->m_zoom)
                 * (event->y + m_pMapArea->m_panUD) * scaleY;
    if ((keyDown == GDK_A || keyDown == GDK_a) && orderCounter == 0 && waypoint.size() != 0)
    {
        //"A" or "a" is pressed once and orderCounter = 0
        for (counter = 0 ; counter < (waypoint.size() - 1); counter++)
        {
            //Check distance between clicked waypoint and all waypoint
            distance = calculateDistance(relative_x, relative_y,
                                         waypoint[counter].m_Latitude, waypoint[counter].m_Longitude);
            if (counter == 0)
            {
                //Initialize setCounter to be 0 and minimumdistance to be the distance
                //between clicked waypoint and the first waypoint
                setCounter = counter;
                minimumdistance = distance;
            }
            if (distance < minimumdistance && distance <= 5)
            {
                //Set minimum if the distance is less than the minimumdistance and still less than 5
                minimumdistance = distance;
                setCounter = counter;
            }

        }

        flightPlan->pop_back();//Throw away the newly clicked waypoint
        waypoint = *flightPlan; //Copy the new flightPlan to waypoint
        m_pMapArea->drawInitial(); //Redraw the mapArea
        m_pMapArea->drawRedCircle(waypoint[setCounter]);//Draw red cclass ControlThread : public RealtimeThread { virtual void loop(); }ircle around the selected waypoint
        orderCounter = 1;

    }
    else if ((keyDown == GDK_A) || (keyDown == GDK_a) && orderCounter == 1 && waypoint.size() != 0)
    {
        //"A" or "a" is still in effect but the orderCounter = 1
        std::cout << "Adding (" << relative_x << ", " << relative_y << ", " << "190) after ("
                  << waypoint[setCounter].m_Latitude << ", " << waypoint[setCounter].m_Longitude
                  << ", " << waypoint[setCounter].m_Altitude << ")" << std::endl;
        flightPlan->pop_back();
        //Assign Latitude and longitude of waypoint number setCounter
        //to the current x- and y- coordinate of the map
        waypoint[setCounter].m_Latitude = relative_x;
        waypoint[setCounter].m_Longitude = relative_y;
        //Insert that new waypoint after the previously selected waypoint
        flightPlan->insert(flightPlan->begin() + setCounter + 1, waypoint[setCounter]);
        //Copy the new flightPlan to waypoint
        waypoint = *flightPlan;
        m_pMapArea->drawInitial();

        orderCounter = 0;//Reset the orderCounter
        keyDown = 0;//Reset current keyboard's key
    }


    if ((keyDown == GDK_M || keyDown == GDK_m) && orderCounter == 0 && waypoint.size() != 0)
    {
        //"M" or "m" is pressed once
        for (counter = 0 ; counter < (waypoint.size() - 1); counter++)
        {
            distance = calculateDistance(relative_x, relative_y,
                                         waypoint[counter].m_Latitude, waypoint[counter].m_Longitude);
            if (counter == 0)
            {
                setCounter = counter;
                minimumdistance = distance;
            }
            if (distance < minimumdistance && distance <= 5)
            {
                minimumdistance = distance;
                setCounter = counter;
            }

        }
        flightPlan->pop_back();
        waypoint = *flightPlan;
        m_pMapArea->drawInitial();
        m_pMapArea->drawRedCircle(waypoint[setCounter]);
        orderCounter = 1;

    }
    else if ((keyDown == GDK_M) || (keyDown == GDK_m) && orderCounter == 1 && waypoint.size() != 0)
    {
        //"M" or "m" is still in effect but orderCounter = 1
        std::cout << "Moving (" << waypoint[setCounter].m_Latitude << ", " << waypoint[setCounter].m_Longitude
                  << ", " << waypoint[setCounter].m_Altitude << ") to ("
                  << relative_x << ", " << relative_y << ", 190)" << std::endl;
        flightPlan->pop_back();
        waypoint[setCounter].m_Latitude = relative_x;
        waypoint[setCounter].m_Longitude = relative_y;
        //Replace waypoint at setCounter to be the newly selected coordinate
        flightPlan->at(setCounter) = waypoint[setCounter];
        waypoint = *flightPlan;
        m_pMapArea->drawInitial();

        orderCounter = 0;
        keyDown = 0;
    }

    if ((keyDown == GDK_D) || (keyDown == GDK_d) && waypoint.size() != 0)
    {
        //"D" or "d" is pressed
        std::cout << "Deleting (" << waypoint[setCounter].m_Latitude << ", " << waypoint[setCounter].m_Longitude
                  << ", " << waypoint[setCounter].m_Altitude << ")" << std::endl;
        for (counter = 0 ; counter < (waypoint.size()- 1) ; counter++)
        {
            distance = calculateDistance(relative_x, relative_y,
                                         waypoint[counter].m_Latitude, waypoint[counter].m_Longitude);
            if (counter == 0)
            {
                setCounter = counter;
                minimumdistance = distance;
            }
            if (distance < minimumdistance && distance <= 5)
            {
                minimumdistance = distance;
                setCounter = counter;
            }

        }
        flightPlan->pop_back();
        flightPlan->erase(flightPlan->begin() + setCounter,
                          flightPlan->begin() + setCounter + 1);//Erase that waypoint
        waypoint = *flightPlan;
        m_pMapArea->drawInitial();

        keyDown = 0;
    }

    std::cout <<*flightPlan << std::endl;

    return true;
}

double MainWindow::calculateDistance(double x1, double y1, double x2, double y2)
{
    double distance; //Distance between two points
    distance = sqrt(pow((x2 - x1), 2) + pow((y2 - y1), 2));
    return (distance);
}

}


// vim:ts=4:sw=4

---