Initial commit

README.md

@@ -0,0 +1,134 @@
+# PR Map
+
+
+
+### Objectives
+Throughout this exercise the students will practice:
+
+* reading a text file sequentially 
+* repetition and control structures
+* creating and manipulating an array of objects
+* writing functions to process arrays of objects
+* passing arrays of objects as parameters
+* modular programming
+
+### Concepts
+
+Working with arrays of objects is a very common task in C++ programs. Once you have read information about the objects from a file and/or the user, you must relly on your algorithmic and C++ skills to invoke the proper methods and functions in order to correctly process the data.
+
+In this lab, we will be working with *georeferenced* data about the cities in Puerto Rico.  When a data is georeferenced* it simply means that it has an associated location in pyhsical space. Typically this **location** means latitude and longitude coordinates.  For example, the following is part of file that contains georeferenced data for some Puertorrican cities:
+
+
+```
+Arroyo 17.9658 -66.0614
+Bayamon 18.3833 -66.15
+Caguas 18.2342 -66.0486
+Dorado 18.4589 -66.2678
+Fajardo 18.3258 -65.6525
+```
+
+As you saw in class, **classes** are the most common way that C++ programmers encapsulate data that is associated to an entity. For example, in the case of the georeferenced points, a practical way to encapsulate the information about each city would be to implement a **GeoreferencedPointOfInterest** class that contains at least data members for: the name of the city, its latitude and longitude.  The **GPOI** class would also need to implement methods to access, modify, and perform computations on its properties. 
+
+### The GPOI class
+
+In this lab, you are provided a **GPOI** class with the following interface:
+
+* `GISPOI()`: the default constructor
+
+* `GISPOI(QString s, double latitude, double longitude)`:  constructor that accepts name, longitude and latitude.
+
+* `double getLat()`, `double getLon()`:  getters for the latutide, longitude.
+
+* ` QString getName()`:  getter for the name.
+
+* `void setAll(string s, double a, double b)`: setter for all the properties (at once)
+
+* `double odDistance(const GISPOI &B) const`: given B, another GPOI object, returns the *orthodromic* distance (or the closest distance) between the invoking GPOI and B.
+
+
+### Exercise 0 - Download and understand the code
+
+1. Download _______.
+
+2. Open the .pro file. Build the program and run it. In its current state, the program simply displays a map of Puerto Rico. This map is provided so that you can viualize the results of your program.
+
+    When you complete this program, it will need some text input from the user. Thus, we need to specify in *Qt Creator* that we expect this program to run in a **terminal**, i.e. not on the QtCreator window. To do this, please click of the `Projects` button on the left part of the *QtCreator* window. Then choose `Run` on the tab near the top of the window. Then make sure that the checkbox `Run in terminal` is checked.
+
+3. Build the program just to determine if there are any outstanding **errors**. You may see some warnings which are due to the fact that some of the functions are incomplete (you will complete throughout this lab.)
+
+3. Open the `main.cpp` file. This is the file where you will be writing your code. This file contains the following functions:
+
+    1. `void printArrayOfCities(GISPOI A[], int size)`: Given A, an array of GISPOI objects and its size, prints all the cities in the array. You may use this function as part of your debugging.
+    
+    2. `int countLinesInFile(ifstream &file)`: Given a reference to the object that represents a file, this function counts and returns the number of lines in the file. 
+
+    3. `void readFileToArray(ifstream &file, GISPOI A[], int numOfCities)`: Given the ifstream object of a file, an array of cities and the number of records to read from the file, this function reads the values from the file and populates the array with objects. **THIS IS A FUNCTION THAT YOU WILL IMPLEMENT**
+
+    4. `void maxDistances(GISPOI A[], int size, int &idxCityA, int &idxCityB)` : Given A, the array of cities, determines the farthest two cities. Returns (by reference) the indices of the two cities in the array. **THIS IS A FUNCTION THAT YOU WILL IMPLEMENT**
+
+    5. `void minDistances(GISPOI A[], int size, int &idxCityA, int &idxCityB)`: Given A, the array of cities, determines the closest two cities. Returns (by reference) the indices of the two cities in the array. **THIS IS A FUNCTION THAT YOU WILL IMPLEMENT**
+
+    5. `double cycleDistance(GISPOI A[], int size, int P[])`: Given the array of cities, the size of the array and a array (P) with a permutation of the integers [0, size-1] computes and returns the distance to travel the cycle of cities A[P[0]] $\rightarrow$ A[P[1]] $\rightarrow$ .... $\rightarrow$ A[P[size-1]]. 
+
+        For example, if the cities read from the file where Mayaguez, Ponce, Yauco and San Juan (in that order) and the permutation $P$ is $left\(3, 1, 0, 2\right)$, the function should compute the distance of a cycle from San Juan $\rightarrow$ Ponce $\rightarrow$ Mayaguez $\rightarrow$ Yauco $\rightarrow$ San Juan.
+
+
+        **THIS IS A FUNCTION THAT YOU WILL IMPLEMENT**
+
+There is one additional function that you need to know:
+
+1. `void MainWindow::drawLine(const GISPOI &city01, const GISPOI &city02)`: Given (a reference to) two GISPOI objects, paints a line between them.
+
+2. `void drawPoints(GISPOI* gisLocations, unsigned int size);`: Given an array of GISPOI objects and their size, displays their locations as points in the map.
+
+### Exercise 1 - read the georeferenced points into an array
+
+Remember that you will only be changing code in the `main.cpp` file. Your first task will be to add code to read the entire contents of a file into an array of GISPOI objects.
+
+1. In the main function, add the necessary instructions to open the file that contains the georeferenced city information. The file is `pr10.txt` in the data directory. You need to provide the complete path to the file as a parameter to the `open()`  method of your `ifstream` object. As always, when using files you should verify if the entered name is a file that can be succefully opened for reading.
+
+2. Invoke the `int countLinesInFile(ifstream &inFile)` function to obtain the number of lines in the file. You may print out the number obtained so that you can validate is your program is working correctly.
+
+3. **Dynamically** create an array as big as the number of lines in the file.
+
+3. Modify the `void readFileToArray(ifstream &file, GISPOI A[], int numOfCities)` function so that it reads all the lines in the file to the objects in the array. 
+
+1. In the main function invoke the `readFileToArray` function, passing the reference to the file, the array you created in step ???, and its size.
+
+1. After invoking `readFileToArray` you may invoke `void printArrayOfCities(GISPOI A[], int size)` to print the names and georeferences of the points read from the file. 
+
+1. Ask the user for the name of the text file that contains data in the following format: CityName Latitude Longitude. Here are example files: cities.txt, calif.txt, and pr.txt. 
+
+1. Invoke the method `drawPoints(GISPOI* gisLocations, unsigned int size)` on the `w` object as follows so that a point will be shown in the map for each city: `w.drawPoints(A, size)` (*assuming that A is your array*). You should obtain something similar to the next figure. 
+
+    ![](http://demo05.cloudimage.io/s/resize/400/i.imgur.com/7AneJpf.png) 
+
+
+
+### Exercise 2 - the max and min functions
+
+Once we have the information of georeferenced cities in an array of objects, we can start processing them in many interesting ways. We will start with some basic operations.
+
+1. Read the documentation and implement the function `void maxDistances(GISPOI A[], int size, int &idxCityA, int &idxCityB)`. Invoke the function from `main()`. 
+
+1. Use the `void drawLine(const GISPOI &city01, const GISPOI &city02)` method of the `w` object to paint a line connecting the two farthest cities.  Notice that the second and third parameters of this method are ** references to the objects that represent the cities** (not their indices in the array).
+
+1. Read the documentation and implement the function `void minDistances(GISPOI A[], int size, int &idxCityA, int &idxCityB)`. Invoke the function from `main()`. 
+
+1. Use the `void drawLine(const GISPOI &city01, const GISPOI &city02)` method of the `w` object to paint a line connecting the two closest cities. 
+
+
+
+### Exercise 3 - compute the cycle distance
+
+1. Read the documentation and implement the function `double cycleDistance(GISPOI A[], int size, int P[])`. Invoke the function from `main()` as indicated in the comments inside the main function:
+
+    1. First with $P = \left(0, 2, 4, 6, 8, 1, 3, 5, 7, 9\right)$
+    2. Then with $P = \left(0, 3, 6, 9, 1, 4, 7, 2, 5, 8\right)$ 
+
+
+### Exercise 4 - more fun
+
+1. Change your code so that it now opens the `pr.txt` file.  Validate your results and wonder at your great achievement.
+
+### Deliverables

census.cpp

@@ -0,0 +1,49 @@
+#include "census.h"
+#include <QFile>
+#include <QJsonDocument>
+#include <QJsonArray>
+#include <QJsonObject>
+#include <qDebug>
+
+
+///
+/// \brief
+/// Census::readDataFromFile - Populates the Census object with data from a file.
+/// at the end we should have Map with (key,value) = (city name, some metric).
+/// \param fileName: name of the JSON file
+/// \return true if the file was openned and read
+///
+bool Census::readDataFromFile(QString fileName) {
+    QFile loadFile(fileName);
+
+    if (!loadFile.open(QIODevice::ReadOnly)) {
+        qWarning("Couldn't open save file.");
+        return false;
+    }
+
+    QByteArray saveData = loadFile.readAll();
+    QJsonDocument loadDoc(QJsonDocument::fromJson(saveData));
+    QJsonArray topLevelArray = loadDoc.array();
+
+    int ctr = 1;
+
+    minValue = maxValue = topLevelArray[0].toObject()["percent_change"].toDouble();
+
+    foreach(QJsonValue obj, topLevelArray) {
+        double value = obj.toObject()["percent_change"].toDouble();
+        (*this)[obj.toObject()["city"].toString()] =  value;
+        if (value > maxValue) maxValue = value;
+        if (value < minValue) minValue = value;
+
+        ctr++;
+    }
+
+    Census::iterator it = this->begin();
+
+    for (; it != this->end(); ++it)
+        qDebug() << it.key() << it.value();
+
+    factor = 128.0 / (maxValue - minValue) ;
+
+}
+

census.h

@@ -0,0 +1,19 @@
+#ifndef CENSUS_H
+#define CENSUS_H
+
+#include <QString>
+#include <QMap>
+
+///
+/// \brief The Census class
+///
+class Census : public QMap<QString, double> {
+
+public:
+    bool readDataFromFile(QString fileName);
+    double minValue, maxValue, factor, negFactor;
+};
+
+
+
+#endif // CENSUS_H

city.cpp

@@ -0,0 +1,8 @@
+#include "city.h"
+
+
+
+void City::pushPoint(double x, double y) {
+    geometry->push_back(DoublePoint(x,y));
+
+}

city.h

@@ -0,0 +1,23 @@
+#ifndef CITY_H
+#define CITY_H
+
+#include <doublepoint.h>
+#include <QVector>
+
+///
+/// \brief The City class
+///        This is merely a vector of points, i.e. the points that make up the
+///        polygon of the city.
+
+class City {
+public:
+    QVector<DoublePoint> *geometry;
+    City() {};
+    void pushPoint(double x, double y);
+
+    virtual int getSize() { return geometry->size(); }
+    QVector<DoublePoint> *getGeometry() { return geometry; }
+    ~City() {delete geometry; }
+};
+
+#endif // CITY_H

country.cpp

@@ -0,0 +1,99 @@
+#include "country.h"
+#include <QFile>
+#include <QDebug>
+#include <QJsonArray>
+#include <QJsonObject>
+#include <QJsonDocument>
+
+void Country::limits(){
+    QMap<QString,City*>::iterator it = Cities.begin();
+
+
+
+
+    minX = maxX = Cities.begin().value()->geometry->at(0).x;
+    minY = maxY = Cities.begin().value()->geometry->at(0).y;
+
+    for (it = Cities.begin() + 1; it != Cities.end(); ++it) {
+
+        City *c = it.value();
+
+        for (int i = 0; i < c->getSize(); i++) {
+            if (c->geometry->at(i).x != 0.0) {
+            if (c->geometry->at(i).x > maxX ) maxX = c->geometry->at(i).x;
+            if (c->geometry->at(i).y > maxY ) maxY = c->geometry->at(i).y;
+            if (c->geometry->at(i).x < minX ) minX = c->geometry->at(i).x;
+            if (c->geometry->at(i).y < minY ) minY = c->geometry->at(i).y;
+            }
+        }
+    }
+    qDebug() << minX << minY << maxX << maxY ;
+}
+
+void Country::topLeft(QString &st, DoublePoint &p ) {
+    QMap<QString,City*>::iterator it = Cities.begin();
+    st = it.key();
+    p.x = it.value()->getGeometry()->at(0).x;
+    p.y = it.value()->getGeometry()->at(0).y;
+
+    qDebug() << p.x << ". " << p.y;
+    for (it = Cities.begin(); it != Cities.end(); ++it) {
+        QVector<DoublePoint> *geometry = it.value()->getGeometry();
+        for (int i = 0; i < geometry->size(); i++) {
+            if (geometry->at(i).x > p.x && geometry->at(i).y < p.y)  {
+                p.x = geometry->at(i).x;
+                p.y = geometry->at(i).y;
+                st = it.key();
+            }
+        }
+
+    }
+}
+unsigned long  *colorMap;
+bool Country::readInfoFromJSON(QString fileName) {
+    QFile loadFile(fileName);
+
+    if (!loadFile.open(QIODevice::ReadOnly)) {
+        qWarning("Couldn't open save file.");
+        return false;
+    }
+
+    QByteArray saveData = loadFile.readAll();
+    QJsonDocument loadDoc(QJsonDocument::fromJson(saveData));
+    QJsonArray topLevelArray = loadDoc.array();
+
+    int ctr = 1;
+    foreach(QJsonValue obj, topLevelArray) {
+        QVector<DoublePoint> *points = new QVector<DoublePoint>;
+        QJsonArray geometryArray = obj.toObject()["geometry"].toObject()["coordinates"].toArray();
+        QString polyType = obj.toObject()["geometry"].toObject()["type"].toString();
+        if (polyType == "Polygon") {
+            for (int i = 0; i < geometryArray[0].toArray().size(); i++) {
+                points->push_back(DoublePoint(
+                                geometryArray[0].toArray()[i].toArray()[0].toDouble(),
+                                geometryArray[0].toArray()[i].toArray()[1].toDouble()));
+            }
+        }
+        else {
+            for (int i = 0; i <geometryArray.size() ; i++) {
+
+                for (int j = 0; j < geometryArray[i].toArray()[0].toArray().size(); j++) {
+                    points->push_back(DoublePoint(
+                                          geometryArray[i].toArray()[0].toArray()[j].toArray()[0].toDouble(),
+                                          geometryArray[i].toArray()[0].toArray()[j].toArray()[1].toDouble()));
+
+                }
+                // I will push a 0,0 between each polygon of a multipolygon to distinguish
+                points->push_back(DoublePoint(0,0));
+            }
+        }
+
+        QString cityName = obj.toObject()["properties"].toObject()["city"].toString();
+
+        qDebug() << "Storing: " << cityName;
+        Cities[cityName] = new City;
+        Cities[cityName]->geometry = points;
+
+        ctr++;
+    }
+}

country.h

@@ -0,0 +1,26 @@
+#ifndef COUNTRY_H
+#define COUNTRY_H
+
+#include <doublepoint.h>
+#include <city.h>
+#include <QMap>
+
+
+///
+/// \brief The Country class
+///        A map of (city name, city structure)
+///
+class Country {
+public:
+    QMap<QString,City*> Cities;
+
+    double minX, minY, maxX, maxY;
+    Country() {}
+    bool readInfoFromJSON(QString fileName);
+    void topLeft(QString &st, DoublePoint &p );
+    void limits();
+    QMap<QString,City*> getCities() { return Cities;}
+    //~Country() { delete Cities; }
+};
+
+#endif // COUNTRY_H

doublepoint.cpp

@@ -0,0 +1,3 @@
+#include "doublepoint.h"
+
+

doublepoint.h

@@ -0,0 +1,14 @@
+#ifndef DOUBLEPOINT_H
+#define DOUBLEPOINT_H
+
+class DoublePoint {
+public:
+    double x, y;
+    DoublePoint() {x = 0; y = 0;}
+    DoublePoint(double a, double b) {
+        x = a; y = b;
+    }
+
+};
+
+#endif // DOUBLEPOINT_H

gispoi.cpp

@@ -0,0 +1,16 @@
+#include "gispoi.h"
+
+GISPOI::GISPOI()
+{
+}
+
+// Function odDistance(A,B)
+// Given two objects A and B of type GISPOI, uses their longitudes and
+// latitudes to compute and return their orthodromic distance in kilometers.
+
+double GISPOI::odDistance(const GISPOI &B) const {
+    return EARTH_RADIUS * acos(
+        sin( deg2rad( getLat() ) ) * sin( deg2rad( B.getLat() ) ) +
+        cos( deg2rad( getLat() ) ) * cos( deg2rad( B.getLat() ) ) *
+        cos( deg2rad( getLon() ) - deg2rad(B.getLon()) ) );
+}

gispoi.h

@@ -0,0 +1,56 @@
+#ifndef GISPOI_H
+#define GISPOI_H
+#include <QString>
+#include <iostream>
+#include <QDebug>
+#include <cmath>
+#include "doublepoint.h"
+using namespace std;
+
+const double EARTH_RADIUS =  6372.8;
+const double TWOPI = 2 * acos(-1);
+
+inline double deg2rad(double deg) {
+    return deg/360.0 * TWOPI;
+}
+
+
+class GISPOI
+{
+private:
+    QString name;
+    double lat, lon;
+
+public:
+    GISPOI();
+    GISPOI(QString s, double latitude, double longitude) 
+        {name = s; lat = latitude; lon = longitude;}
+
+    double getLat()   const {return lat;}
+    double getLon()   const {return lon;}
+    QString getName() const {return name;}
+    
+    void setAll(QString s, double latitude, double longitude)
+        {name = s; lat = latitude; lon = longitude;}
+    void setAll(string s, double latitude, double longitude) 
+        {name = QString::fromStdString(s); lat = latitude; lon = longitude;}
+    
+    void print() {
+        qDebug() << name << " " << lat  << " "
+             << lon << endl;
+    }
+
+    double odDistance(const GISPOI &B) const;
+// Function odDistance(A,B)
+// Given two objects A and B of type GISPOI, uses their longitudes and
+// latitudes to compute and return their orthodromic distance in kilometers.
+
+ 
+
+};
+
+
+
+
+
+#endif // GISPOI_H

main.cpp

@@ -0,0 +1,132 @@
+#include "mainwindow.h"
+#include <QApplication>
+#include <cmath>
+#include <cassert>
+#include <fstream>
+using namespace std;
+
+
+// Function unitTests:
+// Some unit tests for the distance function
+
+// void unitTests(){
+//     GISPOI ny(    "NewYork",   40.7142,  -74.0064 );
+//     GISPOI london("London",    51.50,    -0.1167 );
+//     GISPOI la(    "LA",        34.0522,  -118.2428);
+
+//     assert(abs( ny.odDistance(london) - 5576.74) < 10);
+//     assert(abs( ny.odDistance(la) -     3940.14) < 10);
+//     assert(abs( ny.odDistance(ny) -           0) < 100);
+
+//     cout << "Passed all unit tests...\n";
+// }
+
+// Function printArrayOfCities(A, size):
+// Given A, an array of GISPOI objects and its size, prints
+// all the cities in the array.
+
+void printArrayOfCities(GISPOI A[], int size) {
+    for (int i = 0; i < size; i++)
+        A[i].print();
+}
+
+// Function countLinesInFile(f)
+// Given a reference to the object that represents a file, this function
+// counts and returns the number of lines in the file.
+
+int countLinesInFile(ifstream &file) {
+    string dummy;
+    int ctr = 0;
+
+    while( getline(file,dummy)) ctr++;
+
+    // 'reset' the file, so that it can be reread from the start
+    file.clear();
+    file.seekg(0, ios::beg) ;
+    return ctr;
+}
+
+// Function readFileToArray(file, A, numCities):
+// Given the ifstream object of a file, an (empty) array of cities
+// and the number of records to read from the file, this function
+// reads the values from the file and populates the array with
+// objects.
+
+void readFileToArray(ifstream &file, GISPOI A[], int numOfCities) {
+    // your code here
+    cout << "Reading the file and storing in array of cities.."
+            "(your job)" << endl;
+
+}
+
+// Function maxDistances(A, size, idxCityA, idxCityB):
+// Given the array of cities, determines the farthest two cities.
+// Returns (by reference) the indices of the two cities in the array.
+
+void maxDistances(GISPOI A[], int size, int &idxCityA, int &idxCityB){
+    // your code here
+}
+
+
+// Function minDistances(A, size, idxCityA, idxCityB):
+// Given the array of cities, determines the closest two cities.
+// Returns (by reference) the indices of the two cities in the array.
+void minDistances(GISPOI A[], int size, int &idxCityA, int &idxCityB){
+    // your code here
+    cout << "Computing the two closest cities..." <<
+            "(your job)" << endl;
+}
+
+
+// Function cycleDistance (A, size, P):
+// Given the array of cities, the size of the array and a array (P) with a
+// permutation of the integers [0, size-1] computes and returns the distance
+// to travel the cycle of cities A[P[0]] -- A[P[1]] -- .... -- A[P[size-1]]
+
+double cycleDistance(GISPOI A[], int size, int P[]){
+    // your code here
+    return 0.0;
+}
+
+
+// The main program can be summarized with this pseudocode:
+// 1. Reads the contents of the file to an array of structures.
+// 2. Computes the cities with max distance.
+// 3. Computes the cities with min distance.
+// 4. Computes the total distance of traveling the cities in a certain order.
+
+
+int main(int argc, char *argv[])
+{
+    QApplication a(argc, argv);
+    MainWindow w;
+    w.show();
+
+    // open the file and check its validity
+    // you need to use inFile.open(fileName.c_str()) instead of inFile.open(fileName)
+    // since the open method expects a c-type string instead of a c++ string object 
+
+    // count the number of lines in the file
+
+    // create an array of GISPOI objects with exactly as many elements as there
+    // are lines in the file.
+
+    // read the data from the file into the array of structures
+
+
+    // paint the points onto the map window
+
+    // Here: Put the code to invoke the max distance function and show a line
+    // in the map between those two cities.
+
+
+    // Here: Put the code to invoke the min distance function and show a line
+    // in the map between those two cities.
+
+
+    // Here: Put the code to compute the cycle distance using these permutation
+    // P = {0, 2, 4, 6, 8, 1, 3, 5, 7, 9}
+    // P = {0, 3, 6, 9, 1, 4, 7, 2, 5, 8}
+
+    return a.exec();
+}

mainwindow.cpp

@@ -0,0 +1,60 @@
+#include "mainwindow.h"
+#include "ui_mainwindow.h"
+#include <QPainter>
+#include <QPen>
+#include <QCoreApplication>
+//#include <QJsonDocument>
+#include <QFile>
+#include <QDebug>
+//#include <QJsonArray>
+//#include <QJsonObject>
+#include <QDesktopWidget>
+#include <QVector>
+#include <QPoint>
+#include <string>
+#include <QPolygon>
+#include <census.h>
+#include <city.h>
+#include <country.h>
+#include <doublepoint.h>
+#include <gispoi.h>
+
+using namespace std;
+
+
+Country PR;
+
+MainWindow::MainWindow(QWidget *parent) :
+    QMainWindow(parent),
+    ui(new Ui::MainWindow)
+{
+
+    srand(time(NULL));
+    myMap = new Map(this);
+    myMap->show();
+
+    ui->setupUi(this);
+
+    // just hidding the toolbars to have a bigger drawing area.
+    QList<QToolBar *> toolbars = this->findChildren<QToolBar *>();
+    foreach(QToolBar *t, toolbars) t->hide();
+    QList<QStatusBar *> statusbars = this->findChildren<QStatusBar *>();
+    foreach(QStatusBar *t, statusbars) t->hide();
+
+    resize(myMap->width(), myMap->height());
+}
+
+void MainWindow::drawPoints(GISPOI* gisLocations, unsigned int size) {
+    myMap->drawPoints(gisLocations, size);
+}
+
+void MainWindow::drawLine(const GISPOI &city01, const GISPOI &city02) {
+    myMap->drawLine(city01, city02);
+}
+
+MainWindow::~MainWindow()
+{
+    delete ui;
+    if (myMap != NULL) delete myMap;
+}
+

mainwindow.h

@@ -0,0 +1,29 @@
+#ifndef MAINWINDOW_H
+#define MAINWINDOW_H
+
+#include <QMainWindow>
+#include <census.h>
+#include "map.h"
+namespace Ui {
+class MainWindow;
+}
+
+class MainWindow : public QMainWindow
+{
+    Q_OBJECT
+
+public:
+    explicit MainWindow(QWidget *parent = 0);
+    Map *myMap;
+    void drawPoints(GISPOI* gisLocations, unsigned int size);
+    void drawLine(const GISPOI &city01, const GISPOI &city02);
+    ~MainWindow();
+
+private:
+    Ui::MainWindow *ui;
+
+protected:
+    void paintEventOLD(QPaintEvent *event);
+};
+
+#endif // MAINWINDOW_H

mainwindow.ui

@@ -0,0 +1,24 @@
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>MainWindow</string>
+  </property>
+  <widget class="QMenuBar" name="menuBar" />
+  <widget class="QToolBar" name="mainToolBar" />
+  <widget class="QWidget" name="centralWidget" />
+  <widget class="QStatusBar" name="statusBar" />
+ </widget>
+ <layoutDefault spacing="6" margin="11" />
+ <pixmapfunction></pixmapfunction>
+ <resources/>
+ <connections/>
+</ui>

map.cpp

@@ -0,0 +1,206 @@
+#include "map.h"
+#include <QDebug>
+#include <QDesktopWidget>
+#include <QPainter>
+#include <QPen>
+
+Map::Map(QWidget *parent) :
+    QWidget(parent)
+{
+    srand(time(NULL));
+
+
+    myCountry = new Country;
+    myCountry->readInfoFromJSON("/Users/rarce/Dropbox/CCOM3033/2014S/qt/prMap/data/cityLimitsPR.json");
+
+    cityColorMap = NULL;
+    gisLocations = NULL;
+    drawRoutes = false;
+
+    qDebug() << "Computing limits...";
+    myCountry->limits();
+
+    QDesktopWidget widget;
+    QRect mainScreenSize = widget.availableGeometry(widget.primaryScreen());
+
+    double diffX = myCountry->maxX - myCountry->minX > 0 ? myCountry->maxX - myCountry->minX : myCountry->minX - myCountry->maxX;
+    double diffY = myCountry->maxY - myCountry->minY > 0 ? myCountry->maxY - myCountry->minY : myCountry->minY - myCountry->maxY;
+
+    if (diffX > diffY) resize(mainScreenSize.width() * 0.5 , 0.5 * mainScreenSize.width()*(diffY/diffX));
+    else               resize(mainScreenSize.width() * 0.5,  0.5 * mainScreenSize.width()*(diffX/diffY));
+}
+
+
+Map::~Map() {
+    if (myCountry    != NULL)    delete myCountry;
+    if (cityColorMap != NULL)    delete cityColorMap;
+    if (gisLocations != NULL)    delete [] gisLocations;
+}
+
+QPoint **qpA = new QPoint*[100];
+unsigned int qpASize = 0;
+
+void Map::paintEvent(QPaintEvent *event) {
+
+    // the QPainter is the 'canvas' to which we will draw
+    // the QPen is the pen that will be used to draw to the 'canvas'
+
+    this->setWindowTitle("PR Visualization");
+    QDesktopWidget widget;
+    QRect mainScreenSize = widget.availableGeometry(widget.primaryScreen());
+
+
+    if (qpASize == 0) {
+        //qDebug() << "creating the arrays " << qpArraySize;
+        for (int i = 0; i < 100; i++) {
+            qpA[i] = new QPoint[20000];
+        }
+    }
+
+    QPainter *p = new QPainter(this);
+    QPen myPen;
+
+    double factorX, factorY;
+
+    double diffX = myCountry->maxX - myCountry->minX > 0 ? myCountry->maxX - myCountry->minX : myCountry->minX - myCountry->maxX;
+    double diffY = myCountry->maxY - myCountry->minY > 0 ? myCountry->maxY - myCountry->minY : myCountry->minY - myCountry->maxY;
+
+    if (diffX > diffY) resize(mainScreenSize.width() * 0.5 , 0.5 * mainScreenSize.width()*(diffY/diffX));
+    else               resize(mainScreenSize.width() * 0.5,  0.5 * mainScreenSize.width()*(diffX/diffY));
+
+    factorX = this->width()  / diffX;
+    factorY = this->height() / diffY;
+
+    myPen.setWidth(1);
+    myPen.setColor(QColor(0x100000));
+    myPen.setBrush(QBrush(Qt::black));
+
+    p->setPen(myPen);
+
+    int colorCtr = 0;
+    QMap<QString,City*>::iterator it;
+    unsigned int randColor;
+    int cityCounter = 0;
+
+    for (it = myCountry->Cities.begin() ; it != myCountry->Cities.end(); ++it) {
+        City *c = it.value();
+
+        int x1 ,y1, x2, y2;
+        x1 = factorX * (c->getGeometry()->at(0).x - myCountry->minX);
+        y1 = height() - factorY*(c->getGeometry()->at(0).y - myCountry->minY)  ;
+
+        DoublePoint p1 = c->getGeometry()->at(0);
+        DoublePoint p2;
+        int ctr = 0;
+
+        QPoint *qp = qpA[cityCounter];
+        QPoint *qpBegin = qp;
+
+        // if no color map provided, we'll just color every city white.
+        randColor = 0xffffff;
+
+        if (cityColorMap)
+            randColor = (cityColorMap->find(it.key()) == cityColorMap->end()) ?
+                        0xffffff : (*cityColorMap)[it.key()];
+
+
+
+        for(int i = 0; i < c->getSize() + 1; i++) {
+            p2 = c->getGeometry()->at((i+1)%c->getSize());
+
+            x2 = factorX * (p2.x - myCountry->minX);
+            y2 = height() - factorY*(p2.y - myCountry->minY)  ;
+
+            if (p2.x != 0 && p1.x != 0) {
+                qp->setX(x2);
+                qp->setY(y2);
+                ctr++;
+                qp++;
+            }
+            else if (p2.x == 0) {
+                QPolygon yourPoly;
+                for (int i = 0; i < ctr; i++) yourPoly.push_back(qpBegin[i]);
+                QPainterPath tmpPath;
+                tmpPath.addPolygon(yourPoly);
+
+
+                    p->fillPath(tmpPath,QBrush(randColor));
+
+                p->drawPolygon(qpBegin,ctr);
+                ctr = 0;
+                qpBegin = qp;
+            }
+
+            x1 = x2;
+            y1 = y2;
+            p1 = p2;
+
+        }
+
+        QPolygon yourPoly;
+        for (int i = 0; i < ctr; i++) yourPoly.push_back(qpBegin[i]);
+        QPainterPath *tmpPath = new QPainterPath;
+        tmpPath->addPolygon(yourPoly);
+
+        p->fillPath(*tmpPath,QBrush(randColor));
+
+        p->drawPolygon(qpBegin,ctr,Qt::WindingFill);
+
+
+
+
+
+        delete tmpPath;
+        colorCtr++;
+        cityCounter++;
+    }
+    qpASize = cityCounter;
+
+
+    // Draw the city centers
+    int circleRadius = (this->height() > this->width()) ? this->width()/20 : this->height()/20 ;
+
+    int cX, cY, pX, pY;
+    cX = cY = pX = pY = -1;
+
+    qDebug() << "gisLocations:" << gisLocations << endl;
+
+    if(gisLocations) {
+        myPen.setWidth(2);
+        myPen.setColor(QColor(0x100000));
+        myPen.setBrush(QBrush(Qt::black));
+
+        p->setPen(myPen);
+        for (int i = 0; i < numLocations; i++) {
+            qDebug() << "name from locations:" << gisLocations[i].getName();
+
+            cX = factorX * (gisLocations[i].getLon() - myCountry->minX);
+            cY = height() - factorY*(gisLocations[i].getLat() - myCountry->minY);
+            p->setBrush(Qt::SolidPattern);
+            p->setBrush(QBrush(0xff0000));
+
+            p->drawEllipse(cX, cY, circleRadius, circleRadius);
+            p->setBrush(Qt::NoBrush);
+            if (drawRoutes && pX > 0) {
+                p->drawLine(pX+circleRadius/2,pY+circleRadius/2,cX+circleRadius/2,cY+circleRadius/2);
+            }
+            pX = cX; pY = cY;
+        }
+    }
+
+    for (QPair<const GISPOI *, const GISPOI *> linePair: this->cityLines) {
+//        qDebug() << "A line from " << linePair.first->getName() << " to " << linePair.second->getName() << endl;
+        cX = factorX * (linePair.first->getLon() - myCountry->minX);
+        cY = height() - factorY*(linePair.first->getLat()  - myCountry->minY);
+        pX = factorX * (linePair.second->getLon() - myCountry->minX);
+        pY = height() - factorY*(linePair.second->getLat()  - myCountry->minY);
+        p->drawLine(pX+circleRadius/2,pY+circleRadius/2,cX+circleRadius/2,cY+circleRadius/2);
+    }
+
+    delete p;
+}
+
+
+void Map::drawLine(const GISPOI &city01, const GISPOI &city02) {
+    this->cityLines.push_back(QPair<const GISPOI *, const GISPOI *> (&city01, &city02));
+}

map.h

@@ -0,0 +1,40 @@
+#ifndef MAP_H
+#define MAP_H
+
+#include <QWidget>
+#include <QMap>
+#include <QRgb>
+#include <census.h>
+#include <country.h>
+#include <gispoi.h>
+#include <QVector>
+#include <QPair>
+
+class Map : public QWidget
+{
+    Q_OBJECT
+public:
+    explicit Map(QWidget *parent = 0);
+    void setColorMap(QMap<QString,QRgb> *colorMap) {cityColorMap = colorMap;}
+    void drawPoints(GISPOI *v, unsigned int size) {gisLocations = v; numLocations = size;}
+    void setDrawRoutes(bool r) {drawRoutes = r;}
+    void drawLine(const GISPOI &city01, const GISPOI &city02);
+    ~Map();
+signals:
+
+private:
+    Country *myCountry;
+    QMap<QString,QRgb> *cityColorMap;
+    GISPOI *gisLocations;
+    QVector < QPair<const GISPOI *,const GISPOI *> > cityLines;
+    unsigned int numLocations;
+    bool drawRoutes;
+
+protected:
+    void paintEvent(QPaintEvent *event);
+
+public slots:
+
+};
+
+#endif // MAP_H

prMap.pro

@@ -0,0 +1,32 @@
+#-------------------------------------------------
+#
+# Project created by QtCreator 2014-04-21T21:57:04
+#
+#-------------------------------------------------
+
+QT       += core gui
+
+greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
+
+TARGET = prMap
+TEMPLATE = app
+
+
+SOURCES += main.cpp\
+        mainwindow.cpp \
+    census.cpp \
+    city.cpp \
+    country.cpp \
+    doublepoint.cpp \
+    map.cpp \
+    gispoi.cpp
+
+HEADERS  += mainwindow.h \
+    census.h \
+    city.h \
+    country.h \
+    doublepoint.h \
+    map.h \
+    gispoi.h
+
+FORMS    += mainwindow.ui