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

Go to the documentation of this file.

/*
 * MapArea.cc
 * Copyright (C) Eduardo Wiputra 2009 <ewiputra@users.sourceforge.net>
 *
 * MapArea.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.
 *
 * MapArea.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 <gdkmm.h>
#include <iostream>
#include <iomanip>
#include <string>

#include "MapArea.h"
#include "uvsim/guidance/FlightPlan.h"
#include "uvsim/guidance/GeoCoord.h"

namespace uvsim
{
MapArea::MapArea(BaseObjectType* cobject,
                 const Glib::RefPtr<Gtk::Builder>& glade)
        : Gtk::DrawingArea(cobject), m_glade(glade), m_zoom(1), m_panUD(0), m_panLR(0),
        relative_originX(0), relative_originY(0), relative_endX(0), relative_endY(0), scaleX(1), scaleY(1),
        image(Gdk::Pixbuf::create_from_file(std::string(DATADIR)+="/images/Map.png")),
        cr(get_window()->create_cairo_context()),
        flightPlan(m_pMainWindow->m_guide.getFlightPlan())
{
    double temp; //Variable to store temporary value

    //Input origin (top-left corner) and end (bottom-right corner)
    std::cout << "Constructing MapArea" << std::endl;
    std::cout << "Enter the Abscissa of the top-left corner of the map: ";
    std::cin >> relative_originX;
    std::cout << "Enter the Ordinate of the top-left corner of the map: ";
    std::cin >> relative_originY;
    std::cout << "Enter the Abscissa of the bottom-right corner of the map: ";
    std::cin >> relative_endX;
    std::cout << "Enter the Ordinate of the bottom-right corner of the map: ";
    std::cin >> relative_endY;

    //Loads the map such that the north will be pointing up
    if (relative_originX < relative_endX && relative_originY > relative_endY)
    {
        //Condition where the north is initially pointing up
        image = image->Gdk::Pixbuf::rotate_simple(Gdk::PIXBUF_ROTATE_NONE);
    }
    else if (relative_originX < relative_endX && relative_originY < relative_endY)
    {
        //Condition where the north is initially pointing to the right
        image = image->Gdk::Pixbuf::rotate_simple(Gdk::PIXBUF_ROTATE_COUNTERCLOCKWISE);
        //Swaps the ordinate between origin and end
        temp = relative_originY;
        relative_originY = relative_endY;
        relative_endY = temp;
    }
    else if (relative_originX > relative_endX && relative_originY < relative_endY)
    {
        //Condition where the north is pointing down
        image = image->Gdk::Pixbuf::rotate_simple(Gdk::PIXBUF_ROTATE_UPSIDEDOWN);
        //Swaps the coordinate between origin and end
        temp = relative_originX;
        relative_originX = relative_endX;
        relative_endX = temp;
        temp = relative_originY;
        relative_originY = relative_endY;
        relative_endY = temp;
    }
    else if (relative_originX > relative_endX && relative_originY > relative_endY)
    {
        //Condition where the north is pointing left
        image = image->Gdk::Pixbuf::rotate_simple(Gdk::PIXBUF_ROTATE_CLOCKWISE);
        //Swaps the abscissa between origin and end
        temp = relative_originX;
        relative_originX = relative_endX;
        relative_endX = temp;
    }

    add_events( Gdk::POINTER_MOTION_MASK | Gdk::POINTER_MOTION_HINT_MASK |
                Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK );
    m_glade->get_widget_derived("mainWindow", m_pMainWindow);
}

bool MapArea::on_expose_event(GdkEventExpose* event)
{
    drawInitial();
}

bool MapArea::on_motion_notify_event(GdkEventMotion* event)
{
    double relative_y_map;
    //Compute the scale of map
    scaleX = abs(relative_endX - relative_originX) / image->get_width(); //horizontal
    scaleY = abs(relative_endY - relative_originY) / image->get_height(); //vertical

    //Transform the coordinate of the window to the coordinate of the map
    //so it will be consistent with zooming and panning
    relative_x = relative_originX + 1 / m_zoom * (event->x + m_panLR) * scaleX;
    relative_y = relative_originY + 1 / m_zoom * (event->y + m_panUD) * scaleY;
    relative_y_map = relative_originY - 1 / m_zoom * (event->y + m_panUD) * scaleY;
    std::cout << "x: " << relative_x << " y: " << relative_y_map << std::endl;
}

bool MapArea::on_button_press_event(GdkEventButton* event)
{
    std::cout << "Waypoint Added" << std::endl;
    //Load the flightPlan from MainWindow
    flightPlan = m_pMainWindow->m_guide.getFlightPlan();
    //Add the new coordinate that is just clicked in the map to the flightPlan
    flightPlan->push_back(GeoCoord(relative_x, relative_y, 190));
    //Copy the flightPlan data to the vector<GeoCoord> of waypoint
    waypoint = *flightPlan;
    //Print the flightPlan list
    std::cout << *flightPlan << std::endl;
    draw(waypoint); //Draw the waypoint
}

void MapArea::drawInitial()
{
    double height = image -> get_height(); //Height of the image
    double width = image -> get_width(); //Width of the image
    double height_window = this->get_height(); //Height of the window
    double width_window = this->get_width(); //Width of the window

    scaleX = abs(relative_endX - relative_originX) / width;
    scaleY = abs(relative_endY - relative_originY) / height;

    this->get_window()->draw_pixbuf(this->get_style()->get_black_gc(),
                                    image->Gdk::Pixbuf::scale_simple(width * m_zoom, height * m_zoom,
                                                                     Gdk::INTERP_NEAREST),
                                    m_panLR,m_panUD,0,0, width_window,
                                    height_window,Gdk::RGB_DITHER_NORMAL,0,0); //Load the image

    flightPlan = m_pMainWindow->m_guide.getFlightPlan();
    waypoint = *flightPlan;
    draw(waypoint);
}

void MapArea::draw(std::vector<GeoCoord> waypoint)
{
    int counter; //Loop Counter

    for (counter = 0; counter < waypoint.size(); counter++)
    {
        cr = get_window()->create_cairo_context();
        cr->set_source_rgb(0.0,0.0,0.0);//Black
        cr->set_line_width(3);
        //Draw the circle represented the waypoints.
        //The center is transformed back from coordinate of the map to the drawing area
        cr->arc(((waypoint[counter].m_Latitude - relative_originX) / scaleX * m_zoom - m_panLR),
                ((waypoint[counter].m_Longitude - relative_originY) / scaleY * m_zoom -  m_panUD),
                1, 0, 2 * M_PI);
        //Draw the line connecting waypoints.
        //The coordinate is transformed back from coordinate of the map to the drawing area
        cr->move_to(((waypoint[counter].m_Latitude - relative_originX) / scaleX * m_zoom - m_panLR),
                    ((waypoint[counter].m_Longitude - relative_originY) / scaleY * m_zoom - m_panUD));
        //Draw the line until the last waypoint.
        //The coordinate is transformed back from coordinate of the map to the drawing area
        if ((counter + 1) != waypoint.size())
        {
            cr->line_to(((waypoint[counter + 1].m_Latitude - relative_originX) / scaleX * m_zoom - m_panLR),
                        ((waypoint[counter + 1].m_Longitude - relative_originY) / scaleY * m_zoom - m_panUD));
        }
        cr->stroke();
    }
}

void MapArea::drawRedCircle(std::vector<GeoCoord> waypoint)
{
    int counter; //Loop Counter

    for (counter = 0; counter < waypoint.size(); counter++)
    {
        cr = get_window()->create_cairo_context();
        cr->set_source_rgb(1.0,0.0,0.0); //Red
        cr->set_line_width(5);
        //Draw the red circle around every waypoint.
        //The coordinate is transformed back from coordinate of map to drawing area
        cr->arc(((waypoint[counter].m_Latitude - relative_originX) / scaleX * m_zoom - m_panLR),
                ((waypoint[counter].m_Longitude - relative_originY) / scaleY * m_zoom -  m_panUD),
                5, 0, 2 * M_PI);
        cr->stroke();
    }
}

void MapArea::drawRedCircle(GeoCoord waypoint)
{
    cr = get_window()->create_cairo_context();
    cr->set_source_rgb(1.0,0.0,0.0);//Red
    cr->set_line_width(5);
    //Draw the red circle around a waypoint.
    //The coordinate is transfromed back from coordinate of map to drawing area
    cr->arc(((waypoint.m_Latitude - relative_originX) / scaleX * m_zoom - m_panLR),
            ((waypoint.m_Longitude - relative_originY) / scaleY *  m_zoom -  m_panUD),
            5, 0, 2 * M_PI);
    cr->stroke();
}

}
// vim:ts=2:sw=2

---