Todavia Limpiando el código, documentando

city.cpp

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

city.h

@@ -12,11 +12,46 @@
 class City {
 public:
     QVector<DoublePoint> *geometry;
+    
+    /// \fn City()
+    /// \~English
+    /// \brief default constructor
+    /// \~Spanish
+    /// \brief default constructor
+    ///
     City() {};
+
+    /// \fn pushPoint(double x, double y)
+    /// \~English
+    /// \brief push a point to the vector of points
+    /// \~Spanish
+    /// \brief añadir un punto al final del vector de puntos
+    ///
     void pushPoint(double x, double y);
 
-    virtual int getSize() { return geometry->size(); }
-    QVector<DoublePoint> *getGeometry() { return geometry; }
+    /// \fn getSize()
+    /// \~English
+    /// \brief get the size of the vector that contains the points
+    /// \~Spanish
+    /// \brief devuelve el tamaño del vector de puntos
+    ///
+    virtual int getSize() const { return geometry->size(); }
+
+    /// \fn QVector<DoublePoint> *getGeometry()
+    /// \~English
+    /// \brief get a pointer to the vector of points
+    /// \~Spanish
+    /// \brief devuelve un puntero al vector de puntos
+    ///
+    QVector<DoublePoint> *getGeometry() const { return geometry; }
+    
+
+    /// \fn ~City()
+    /// \~English
+    /// \brief destructor
+    /// \~Spanish
+    /// \brief destructor
+    ///    
     ~City() {delete geometry; }
 };
 

country.cpp

@@ -54,8 +54,9 @@ bool Country::readInfoFromJSON(const QString &fileName) {
             }
         }
         else {
+            // for every city
             for (int i = 0; i <geometryArray.size() ; i++) {
-
+                // for every point in the city's polygon
                 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(),
@@ -75,4 +76,5 @@ bool Country::readInfoFromJSON(const QString &fileName) {
 
         ctr++;
     }
+    return true;
 }

doublepoint.h

@@ -19,8 +19,12 @@ public:
     /// \fn DoublePoint(double xp, double yp)
     /// \~English
     /// \brief constructor that sets the coordinates
+    /// \param xp value for x
+    /// \param yp value for y
     /// \~Spanish
     /// \brief constructor que setea las coordenadas
+    /// \param xp valor para coordenada x
+    /// \param yp valor para coordenada y
     ///
     DoublePoint(double xp, double yp) { x = xp; y = yp; }
 };

gispoi.cpp

@@ -1,12 +1,5 @@
 #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(

gispoi.h

@@ -113,7 +113,6 @@ public:
              << lon << endl;
     }
 
-
     /// \fn print()
     /// \~English
     /// \brief Given two objects A and B of class GISPOI, uses their

main.cpp

@@ -1,11 +1,16 @@
+#define QT_NO_DEBUG_OUTPUT
+
+
 #include "mainwindow.h"
 #include <QApplication>
 #include <cmath>
 #include <cassert>
 #include <fstream>
+
 using namespace std;
 
 
+
 // Function unitTests:
 // Some unit tests for the distance function
 
@@ -102,6 +107,7 @@ int main(int argc, char *argv[])
     MainWindow w;
     w.show();
 
+    cout << "Welcome to PR map!!!!" << endl;
     // 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 

mainwindow.cpp

@@ -47,12 +47,11 @@ 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);
+void MainWindow::drawLine(const GISPOI &poi01, const GISPOI &poi02) {
+    myMap->drawLine(poi01, poi02);
 }
 
-MainWindow::~MainWindow()
-{
+MainWindow::~MainWindow() {
     delete ui;
     if (myMap != NULL) delete myMap;
 }

mainwindow.h

@@ -13,17 +13,61 @@ class MainWindow : public QMainWindow
     Q_OBJECT
 
 public:
-    explicit MainWindow(QWidget *parent = 0);
+	// data members, I will declare as public for now
     Map *myMap;
+
+	/// \fn MainWindow(QWidget *parent = 0)
+    /// \~English
+    /// \brief default constructor
+    /// \param parent a pointer to this object's parent
+    /// \~Spanish
+    /// \brief constructor por defecto
+    /// \param parent puntero al padre de este objeto
+    ///
+    explicit MainWindow(QWidget *parent = 0);
+
+	/// \fn void drawPoints(GISPOI* gisLocations, unsigned int size)
+    /// \~English
+    /// \brief receives an array of points and its size, assigns it o
+    ///        an array inside the myMap object.
+    /// \param gisLocations an array of GISPOI objects in which we would
+    ///                     like to draw points
+    /// \param size size of the array
+    /// \~Spanish
+    /// \brief recibe un arreglo de puntos y su tamañano y lo asigna
+    ///        a un arreglo dentro del objeto myMap.
+    /// \param gisLocations un arreglo de objetos de clase GISPOI en los que 
+    ///                     deseamos que aparezcan dibujados puntos.
+    /// \param size tamaño del array
+    ///
     void drawPoints(GISPOI* gisLocations, unsigned int size);
-    void drawLine(const GISPOI &city01, const GISPOI &city02);
+
+	/// \fn void drawLine(const GISPOI &city01, const GISPOI &city02)
+    /// \~English
+    /// \brief receives reference to two objects of class GISPOIO and 
+    ///        registers that a segment shall be painted between them in the map.
+    /// \param poi01 one of the two GISPOI object ends of the segment  
+    /// \param poi02 the other of the two GISPOI object ends of the segment
+    /// \~Spanish
+    /// \brief recibe referencia a dos objetos de clase GISPOI y registra que 
+    ///        que se pintará una linea entre ellos dentro del mapa.
+    /// \param poi01 una de los puntos que unirá la línea
+    /// \param poi02 el otro de los extremos que unirá el segmento
+    ///
+    void drawLine(const GISPOI &poi01, const GISPOI &poi02);
+
+	/// \fn ~MainWindow()
+    /// \~English
+    /// \brief destructor
+    /// \~Spanish
+    /// \brief destructor
+    ///
     ~MainWindow();
 
 private:
     Ui::MainWindow *ui;
 
 protected:
-    void paintEventOLD(QPaintEvent *event);
 };
 
 #endif // MAINWINDOW_H

map.cpp

@@ -45,28 +45,38 @@ unsigned int qpASize = 0;
 
 void Map::paintEvent(QPaintEvent *) {
 
-    // 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());
 
 
+    // Creating the arrays that will hold the points for the cities
     if (qpASize == 0) {
-        //qDebug() << "creating the arrays " << qpArraySize;
         for (int i = 0; i < 100; i++) {
             qpA[i] = new QPoint[20000];
         }
     }
 
+    // the QPainter is the 'canvas' to which we will draw
+    // the QPen is the pen that will be used to draw to the 'canvas
     QPainter *p = new QPainter(this);
     QPen myPen;
 
+    myPen.setWidth(1);
+    myPen.setColor(QColor(0x100000));
+    myPen.setBrush(QBrush(Qt::black));
+
+    p->setPen(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;
+    // Computing the factors by which we'll scale the x and y coordinates.
+
+    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));
@@ -74,11 +84,6 @@ void Map::paintEvent(QPaintEvent *) {
     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;

map.h

@@ -4,7 +4,6 @@
 #include <QWidget>
 #include <QMap>
 #include <QRgb>
-// #include <census.h>
 #include <country.h>
 #include <gispoi.h>
 #include <QVector>
@@ -45,6 +44,12 @@ public:
             QPair<const GISPOI *, const GISPOI *> (&city01, &city02));
     }
     
+    /// \fn ~Map)()
+    /// \~English
+    /// \brief destructor
+    /// \~Spanish
+    /// \brief destructor
+    ///
     ~Map();
 signals:
 
@@ -57,6 +62,17 @@ private:
     QVector < QPair<const GISPOI *,const GISPOI *> > cityLines;
 
 protected:
+
+    /// \fn paintEvent(QPaintEvent *event);
+    /// \~English
+    /// \brief function that is called every time the map widget 
+    ///        generates a paint event. It draws the polygons and lines
+    ///        of the map.
+    /// \~Spanish
+    /// \brief función que se invoca cada vez que el widget genera un
+    ///        evento de pintar. Dibuja los polígonos y las lineas en el
+    ///        mapa.
+    ///
     void paintEvent(QPaintEvent *event);
 
 public slots: