Merge branch 'dev' of pixhawk.ethz.ch:qgroundcontrol into dev

qgroundcontrol.pri

@@ -86,7 +86,8 @@ macx {
     DEPENDENCIES_PRESENT += osgearth
     # Include osgEarth libraries
     LIBS += -losgViewer \
-            -losgEarth
+            -losgEarth \
+            -losgEarthUtil
     DEFINES += QGC_OSGEARTH_ENABLED
     }
 
@@ -228,7 +229,8 @@ linux-g++-64 {
     DEPENDENCIES_PRESENT += osgearth
     # Include osgEarth libraries
     LIBS += -losgViewer \
-            -losgEarth
+            -losgEarth \
+            -losgEarthUtil
     DEFINES += QGC_OSGEARTH_ENABLED
     }
 

src/input/Freenect.cc

 #include "Freenect.h"
 
+#include <cmath>
 #include <string.h>
 #include <QDebug>
 
@@ -8,7 +9,12 @@ Freenect::Freenect()
     , device(NULL)
     , tiltAngle(0)
 {
-
+    for (int i = 0; i < 2048; ++i)
+    {
+        float v = static_cast<float>(i) / 2048.0f;
+        v = powf(v, 3.0f) * 6.0f;
+        gammaTable[i] = static_cast<unsigned short>(v * 6.0f * 256.0f);
+    }
 }
 
 Freenect::~Freenect()
@@ -102,14 +108,33 @@ QSharedPointer<QByteArray>
 Freenect::getRgbData(void)
 {
     QMutexLocker locker(&rgbMutex);
-    return QSharedPointer<QByteArray>(new QByteArray(rgb, FREENECT_RGB_SIZE));
+    return QSharedPointer<QByteArray>(
+            new QByteArray(rgb, FREENECT_RGB_SIZE));
 }
 
 QSharedPointer<QByteArray>
-Freenect::getDepthData(void)
+Freenect::getRawDepthData(void)
 {
     QMutexLocker locker(&depthMutex);
-    return QSharedPointer<QByteArray>(new QByteArray(depth, FREENECT_DEPTH_SIZE));
+    return QSharedPointer<QByteArray>(
+            new QByteArray(depth, FREENECT_DEPTH_SIZE));
+}
+
+QSharedPointer<QByteArray>
+Freenect::getDistanceData(void)
+{
+    QMutexLocker locker(&distanceMutex);
+    return QSharedPointer<QByteArray>(
+            new QByteArray(reinterpret_cast<char *>(distance),
+                           FREENECT_FRAME_PIX * sizeof(float)));
+}
+
+QSharedPointer<QByteArray>
+Freenect::getColoredDepthData(void)
+{
+    QMutexLocker locker(&coloredDepthMutex);
+    return QSharedPointer<QByteArray>(
+            new QByteArray(coloredDepth, FREENECT_RGB_SIZE));
 }
 
 int
@@ -149,8 +174,7 @@ Freenect::FreenectThread::run(void)
 }
 
 void
-Freenect::rgbCallback(freenect_device* device, freenect_pixel* rgb,
-                      unsigned int timestamp)
+Freenect::rgbCallback(freenect_device* device, freenect_pixel* rgb, uint32_t timestamp)
 {
     Freenect* freenect = static_cast<Freenect *>(freenect_get_user(device));
 
@@ -159,12 +183,65 @@ Freenect::rgbCallback(freenect_device* device, freenect_pixel* rgb,
 }
 
 void
-Freenect::depthCallback(freenect_device* device, void* depth,
-                        unsigned int timestamp)
+Freenect::depthCallback(freenect_device* device, freenect_depth* depth, uint32_t timestamp)
 {
     Freenect* freenect = static_cast<Freenect *>(freenect_get_user(device));
     freenect_depth* data = reinterpret_cast<freenect_depth *>(depth);
 
-    QMutexLocker locker(&freenect->depthMutex);
+    QMutexLocker depthLocker(&freenect->depthMutex);
     memcpy(freenect->depth, data, FREENECT_DEPTH_SIZE);
+
+    QMutexLocker distanceLocker(&freenect->distanceMutex);
+    for (int i = 0; i < FREENECT_FRAME_PIX; ++i)
+    {
+        freenect->distance[i] =
+                100.f / (-0.00307f * static_cast<float>(data[i]) + 3.33f);
+    }
+
+    QMutexLocker coloredDepthLocker(&freenect->coloredDepthMutex);
+    unsigned short* src = reinterpret_cast<unsigned short *>(data);
+    unsigned char* dst = reinterpret_cast<unsigned char *>(freenect->coloredDepth);
+    for (int i = 0; i < FREENECT_FRAME_PIX; ++i)
+    {
+        unsigned short pval = freenect->gammaTable[src[i]];
+        unsigned short lb = pval & 0xFF;
+        switch (pval >> 8)
+        {
+        case 0:
+            dst[3 * i] = 255;
+            dst[3 * i + 1] = 255 - lb;
+            dst[3 * i + 2] = 255 - lb;
+            break;
+        case 1:
+            dst[3 * i] = 255;
+            dst[3 * i + 1] = lb;
+            dst[3 * i + 2] = 0;
+            break;
+        case 2:
+            dst[3 * i] = 255 - lb;
+            dst[3 * i + 1] = 255;
+            dst[3 * i + 2] = 0;
+            break;
+        case 3:
+            dst[3 * i] = 0;
+            dst[3 * i + 1] = 255;
+            dst[3 * i + 2] = lb;
+            break;
+        case 4:
+            dst[3 * i] = 0;
+            dst[3 * i + 1] = 255 - lb;
+            dst[3 * i + 2] = 255;
+            break;
+        case 5:
+            dst[3 * i] = 0;
+            dst[3 * i + 1] = 0;
+            dst[3 * i + 2] = 255 - lb;
+            break;
+        default:
+            dst[3 * i] = 0;
+            dst[3 * i + 1] = 0;
+            dst[3 * i + 2] = 0;
+            break;
+        }
+    }
 }

src/input/Freenect.h

@@ -17,16 +17,16 @@ public:
     bool process(void);
 
     QSharedPointer<QByteArray> getRgbData(void);
-    QSharedPointer<QByteArray> getDepthData(void);
+    QSharedPointer<QByteArray> getRawDepthData(void);
+    QSharedPointer<QByteArray> getDistanceData(void);
+    QSharedPointer<QByteArray> getColoredDepthData(void);
 
     int getTiltAngle(void) const;
     void setTiltAngle(int angle);
 
 private:
-    static void rgbCallback(freenect_device* device, freenect_pixel* rgb,
-                            unsigned int timestamp);
-    static void depthCallback(freenect_device* device, void* depth,
-                              unsigned int timestamp);
+    static void rgbCallback(freenect_device* device, freenect_pixel* rgb, uint32_t timestamp);
+    static void depthCallback(freenect_device* device, freenect_depth* depth, uint32_t timestamp);
 
     freenect_context* context;
     freenect_device* device;
@@ -53,9 +53,18 @@ private:
     char depth[FREENECT_DEPTH_SIZE];
     QMutex depthMutex;
 
+    float distance[FREENECT_FRAME_PIX];
+    QMutex distanceMutex;
+
+    char coloredDepth[FREENECT_RGB_SIZE];
+    QMutex coloredDepthMutex;
+
     // accelerometer data
     short ax, ay, az;
     double dx, dy, dz;
+
+    // gamma map
+    unsigned short gammaTable[2048];
 };
 
 #endif // FREENECT_H

src/ui/MainWindow.cc

@@ -47,7 +47,7 @@ This file is part of the QGROUNDCONTROL project
 #include "GAudioOutput.h"
 
 #ifdef QGC_OSG_ENABLED
-#include "QMap3D.h"
+#include "Q3DWidgetFactory.h"
 #endif
 
 // FIXME Move
@@ -136,8 +136,8 @@ void MainWindow::buildWidgets()
     protocolWidget    = new XMLCommProtocolWidget(this);
     dataplotWidget    = new QGCDataPlot2D(this);
     #ifdef QGC_OSG_ENABLED
-    //_3DWidget         = Q3DWidgetFactory::get(QGC_MAP3D_OSGEARTH);
-    _3DWidget = new QMap3D(this);
+    _3DWidget         = Q3DWidgetFactory::get("PIXHAWK");
+    //_3DWidget = Q3DWidgetFactory::get("MAP3D");
     #endif
 
     // Dock widgets
@@ -672,7 +672,7 @@ void MainWindow::loadPixhawkView()
     clearView();
     // Engineer view, used in EMAV2009
 
-        #ifdef QGC_OSG_ENABLED
+#ifdef QGC_OSG_ENABLED
     // 3D map
     if (_3DWidget)
     {

src/ui/MainWindow.h

@@ -63,10 +63,6 @@ This file is part of the QGROUNDCONTROL project
 #include "HSIDisplay.h"
 #include "QGCDataPlot2D.h"
 #include "QGCRemoteControlView.h"
-#ifdef QGC_OSG_ENABLED
-//#include "Q3DWidget.h"
-#include "QMap3D.h"
-#endif
 
 #include "LogCompressor.h"
 
@@ -167,7 +163,7 @@ protected:
     QPointer<XMLCommProtocolWidget> protocolWidget;
     QPointer<QGCDataPlot2D> dataplotWidget;
     #ifdef QGC_OSG_ENABLED
-    QPointer<QMap3D> _3DWidget;
+    QPointer<QWidget> _3DWidget;
     #endif
     // Dock widgets
     QPointer<QDockWidget> controlDockWidget;

src/ui/map3D/Imagery.h

+/*=====================================================================
+
+QGroundControl Open Source Ground Control Station
+
+(c) 2009, 2010 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
+
+This file is part of the QGROUNDCONTROL project
+
+    QGROUNDCONTROL 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.
+
+    QGROUNDCONTROL 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 QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
+
+======================================================================*/
+
+/**
+ * @file
+ *   @brief Definition of the class Imagery.
+ *
+ *   @author Lionel Heng <hengli@student.ethz.ch>
+ *
+ */
+
+#ifndef IMAGERY_H
+#define IMAGERY_H
+
+#include <QScopedPointer>
+#include <QString>
+
+#include "TextureCache.h"
+
+class Imagery
+{
+public:
+    enum ImageryType
+    {
+        GOOGLE_MAP = 0,
+        GOOGLE_SATELLITE = 1,
+        SWISSTOPO_SATELLITE = 2,
+        SWISSTOPO_SATELLITE_3D = 3
+    };
+
+    Imagery();
+
+    void setImageryType(ImageryType type);
+    void setOffset(double xOffset, double yOffset);
+
+    void prefetch2D(double windowWidth, double windowHeight,
+                    double zoom, double xOrigin, double yOrigin,
+                    double viewXOffset, double viewYOffset,
+                    const QString& utmZone);
+    void draw2D(double windowWidth, double windowHeight,
+                double zoom, double xOrigin, double yOrigin,
+                double viewXOffset, double viewYOffset,
+                const QString& utmZone);
+
+    void prefetch3D(double radius, double tileResolution,
+                    double xOrigin, double yOrigin,
+                    double viewXOffset, double viewYOffset,
+                    const QString& utmZone, bool useHeightModel);
+    void draw3D(double radius, double tileResolution,
+                double xOrigin, double yOrigin,
+                double viewXOffset, double viewYOffset,
+                const QString& utmZone, bool useHeightModel);
+
+    bool update(void);
+
+private:
+    void imageBounds(int tileX, int tileY, double tileResolution,
+                     double& x1, double& y1, double& x2, double& y2,
+                     double& x3, double& y3, double& x4, double& y4) const;
+    void tileBounds(double tileResolution,
+                    double minUtmX, double minUtmY,
+                    double maxUtmX, double maxUtmY, const QString& utmZone,
+                    int& minTileX, int& minTileY,
+                    int& maxTileX, int& maxTileY,
+                    int& zoomLevel) const;
+
+    double tileXToLongitude(int tileX, int numTiles) const;
+    double tileYToLatitude(int tileY, int numTiles) const;
+    int longitudeToTileX(double longitude, int numTiles) const;
+    int latitudeToTileY(double latitude, int numTiles) const;
+
+    void UTMtoTile(double northing, double easting, const QString& utmZone,
+                   double tileResolution, int& tileX, int& tileY,
+                   int& zoomLevel) const;
+    QChar UTMLetterDesignator(double latitude) const;
+
+    void LLtoUTM(double latitude, double longitude,
+                 double& utmNorthing, double& utmEasting,
+                 QString& utmZone) const;
+    void UTMtoLL(double utmNorthing, double utmEasting, const QString& utmZone,
+                 double& latitude, double& longitude) const;
+
+    QString getTileLocation(int tileX, int tileY, int zoomLevel,
+                            double tileResolution) const;
+
+    QScopedPointer<TextureCache> textureCache;
+
+    ImageryType currentImageryType;
+
+    double xOffset;
+    double yOffset;
+};
+
+#endif // IMAGERY_H

src/ui/map3D/Pixhawk3DWidget.h

@@ -37,9 +37,8 @@
 #include <osgEarth/MapNode>
 #endif
 
-#ifdef QGC_OSG_ENABLED
 #include "ImageWindowGeode.h"
-#endif
+
 #ifdef QGC_LIBFREENECT_ENABLED
 #include "Freenect.h"
 #endif
@@ -59,10 +58,6 @@ public:
     explicit Pixhawk3DWidget(QWidget* parent = 0);
     ~Pixhawk3DWidget();
 
-    void buildLayout(void);
-
-    double getTime(void) const;
-
 public slots:
     void setActiveUAS(UASInterface* uas);
 
@@ -70,10 +65,13 @@ private slots:
     void showGrid(int state);
     void showTrail(int state);
     void showWaypoints(int state);
+    void selectVehicleModel(int index);
     void recenter(void);
     void toggleFollowCamera(int state);
 
 protected:
+    QVector< osg::ref_ptr<osg::Node> > findVehicleModels(void);
+    void buildLayout(void);
     virtual void display(void);
     virtual void keyPressEvent(QKeyEvent* event);
     virtual void mousePressEvent(QMouseEvent* event);
@@ -90,10 +88,7 @@ private:
 
     osg::ref_ptr<osg::Node> createTarget(void);
     osg::ref_ptr<osg::Group> createWaypoints(void);
-
-#ifdef QGC_LIBFREENECT_ENABLED
-    osg::ref_ptr<osg::Geode> createRGBD(void);
-#endif
+    osg::ref_ptr<osg::Geode> createRGBD3D(void);
 
     void setupHUD(void);
     void resizeHUD(void);
@@ -121,6 +116,7 @@ private:
     osg::ref_ptr<osg::Vec3Array> trailVertices;
     QVarLengthArray<osg::Vec3, 10000> trail;
 
+    osg::ref_ptr<osg::Node> vehicleModel;
     osg::ref_ptr<osg::Geometry> hudBackgroundGeometry;
     osg::ref_ptr<osgText::Text> statusText;
     osg::ref_ptr<ImageWindowGeode> rgb2DGeode;
@@ -137,13 +133,14 @@ private:
     osg::ref_ptr<osg::Geode> targetNode;
     osg::ref_ptr<osg::PositionAttitudeTransform> targetPosition;
     osg::ref_ptr<osg::Group> waypointsNode;
+    osg::ref_ptr<osg::Geode> rgbd3DNode;
 #ifdef QGC_LIBFREENECT_ENABLED
-    osg::ref_ptr<osg::Geode> rgbdNode;
     QScopedPointer<Freenect> freenect;
 #endif
     QSharedPointer<QByteArray> rgb;
-    QSharedPointer<QByteArray> depth;
-    unsigned short gammaLookup[2048];
+    QSharedPointer<QByteArray> coloredDepth;
+
+    QVector< osg::ref_ptr<osg::Node> > vehicleModels;
 
     QPushButton* targetButton;
 

src/ui/map3D/PixhawkCheetahGeode.cc

@@ -59358,6 +59358,7 @@ osg::ref_ptr<osg::Geode>
 PixhawkCheetahGeode::create(float red, float green, float blue)
 {
     osg::ref_ptr<osg::Geode> geode(new osg::Geode());
+    geode->setName("Pixhawk Bravo");
     osg::ref_ptr<osg::Geometry> geometry(new osg::Geometry());
     geode->addDrawable(geometry.get());
 

src/ui/map3D/Q3DWidget.cc

@@ -35,10 +35,6 @@ This file is part of the QGROUNDCONTROL project
 #include <osg/LineWidth>
 #include <osg/MatrixTransform>
 
-static const float KEY_ROTATE_AMOUNT = 5.0f;
-static const float KEY_MOVE_AMOUNT   = 10.0f;
-static const float KEY_ZOOM_AMOUNT   = 5.0f;
-
 Q3DWidget::Q3DWidget(QWidget* parent)
     : QGLWidget(parent)
     , root(new osg::Group())

src/ui/map3D/Q3DWidgetFactory.cc

@@ -32,16 +32,21 @@ This file is part of the QGROUNDCONTROL project
 #include "Q3DWidgetFactory.h"
 
 #include "Pixhawk3DWidget.h"
+#include "QMap3D.h"
 
-QPointer<Q3DWidget>
+QPointer<QWidget>
 Q3DWidgetFactory::get(const std::string& type)
 {
     if (type == "PIXHAWK")
     {
-        return QPointer<Q3DWidget>(new Pixhawk3DWidget);
+        return QPointer<QWidget>(new Pixhawk3DWidget);
+    }
+    else if (type == "MAP3D")
+    {
+        return QPointer<QWidget>(new QMap3D);
     }
     else
     {
-        return QPointer<Q3DWidget>(new Q3DWidget);
+        return QPointer<QWidget>(new Q3DWidget);
     }
 }

src/ui/map3D/Q3DWidgetFactory.h

@@ -50,7 +50,7 @@ public:
      * @return A smart pointer to the Q3DWidget instance.
      */
 
-    static QPointer<Q3DWidget> get(const std::string& type);
+    static QPointer<QWidget> get(const std::string& type);
 };
 
 #endif // Q3DWIDGETFACTORY_H

src/ui/map3D/Texture.cc

+/*=====================================================================
+
+QGroundControl Open Source Ground Control Station
+
+(c) 2009, 2010 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
+
+This file is part of the QGROUNDCONTROL project
+
+    QGROUNDCONTROL 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.
+
+    QGROUNDCONTROL 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 QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
+
+======================================================================*/
+
+/**
+ * @file
+ *   @brief Definition of the class Texture.
+ *
+ *   @author Lionel Heng <hengli@student.ethz.ch>
+ *
+ */
+
+#include <osg/LineWidth>
+
+#include "Texture.h"
+
+Texture::Texture()
+    : _is3D(false)
+{
+    texture2D->setFilter(osg::Texture::MIN_FILTER, osg::Texture::NEAREST);
+    texture2D->setFilter(osg::Texture::MAG_FILTER, osg::Texture::NEAREST);
+    GLuint id;
+    glGenTextures(1, &id);
+    t->setID(id);
+    glBindTexture(GL_TEXTURE_2D, id);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+}
+
+const QString&
+Texture::getSourceURL(void) const
+{
+    return sourceURL;
+}
+
+void
+Texture::setId(unsigned int _id)
+{
+    id = _id;
+}
+
+void
+Texture::sync(const WebImagePtr& image)
+{
+    state = static_cast<State>(image->getState());
+
+    if (image->getState() != WebImage::UNINITIALIZED &&
+        (sourceURL != image->getSourceURL() ||
+         _is3D != image->is3D()))
+    {
+        sourceURL = image->getSourceURL();
+        _is3D = image->is3D();
+    }
+
+    if (image->getState() == WebImage::READY && image->getSyncFlag())
+    {
+        image->setSyncFlag(false);
+
+        if (image->getWidth() != imageWidth ||
+            image->getHeight() != imageHeight)
+        {
+            imageWidth = image->getWidth();
+            textureWidth = 32;
+            while (textureWidth < imageWidth)
+            {
+                textureWidth *= 2;
+            }
+            imageHeight = image->getHeight();
+            textureHeight = 32;
+            while (textureHeight < imageHeight)
+            {
+                textureHeight *= 2;
+            }
+
+            maxU = static_cast<double>(imageWidth)
+                   / static_cast<double>(textureWidth);
+            maxV = static_cast<double>(imageHeight)
+                   / static_cast<double>(textureHeight);
+
+            osg::ref_ptr<osg::Image> image;
+            image->setImage(textureWidth, textureHeight, 8, 3, GL_RGBA, GL_UNSIGNED_BYTES, NULL, osg::Image::USE_NEW_DELETE);
+
+            texture2D->
+            glBindTexture(GL_TEXTURE_2D, id);
+            glTexImage2D(GL_TEXTURE_2D, 0, 3, textureWidth, textureHeight,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+        }
+
+        glBindTexture(GL_TEXTURE_2D, id);
+        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, imageWidth, imageHeight,
+                        GL_RGBA, GL_UNSIGNED_BYTE, image->getImageData());
+
+        heightModel = image->getHeightModel();
+    }
+}
+
+osg::ref_ptr<osg::Geometry>
+Texture::draw(float x1, float y1, float x2, float y2,
+              bool smoothInterpolation) const
+{
+    return draw(x1, y1, x2, y1, x2, y2, x1, y2, smoothInterpolation);
+}
+
+osg::ref_ptr<osg::Geometry>
+Texture::draw(float x1, float y1, float x2, float y2,
+              float x3, float y3, float x4, float y4,
+              bool smoothInterpolation) const
+{
+    osg::ref_ptr<osg::Geometry> geometry(new osg::Geometry);
+    osg::ref_ptr<osg::StateSet> stateset(new osg::StateSet);
+
+    if (state == REQUESTED)
+    {
+        osg::ref_ptr<osg::Vec2Array> vertices(new osg::Vec2Array);
+        vertices->push_back(osg::Vec2(x1, y1));
+        vertices->push_back(osg::Vec2(x2, y2));
+        vertices->push_back(osg::Vec2(x3, y3));
+        vertices->push_back(osg::Vec2(x4, y4));
+
+        geometry->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::LINES,
+                                                      0, vertices->size()));
+
+        geometry->setVertexArray(vertices);
+
+        osg::ref_ptr<osg::Vec4Array> color(new osg::Vec4Array);
+        color->push_back(osg::Vec4(0.0f, 0.0f, 1.0f, 1.0f));
+        geometry->setColorArray(color);
+        geometry->setColorBinding(osg::Geometry::BIND_OVERALL);
+        
+        return geometry;
+    }
+
+    stateset->setTextureAttributeAndModes(id, texture2D);
+
+    float dx, dy;
+    if (smoothInterpolation)
+    {
+        texture2D->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR);
+        texture2D->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
+        dx = 1.0f / (2.0f * textureWidth);
+        dy = 1.0f / (2.0f * textureHeight);
+    }
+    else
+    {
+        texture2D->setFilter(osg::Texture::MIN_FILTER, osg::Texture::NEAREST);
+        texture2D->setFilter(osg::Texture::MAG_FILTER, osg::Texture::NEAREST);
+        dx = 0.0f;
+        dy = 0.0f;
+    }
+
+    glColor3f(1.0f, 1.0f, 1.0f);
+    if (!_is3D)
+    {
+        osg::ref_ptr<osg::Vec2Array> tc = new osg::Vec2Array;
+
+        geometry->setTexCoordArray(id, tc);
+        tc->push_back(osg::Vec2(dx, maxV - dy));
+        tc->push_back(osg::Vec2(maxU - dx, maxV - dy));
+        tc->push_back(osg::Vec2(maxU - dx, dy));
+        tc->push_back(osg::Vec2(dx, dy));
+
+        glBegin(GL_QUADS);
+        glTexCoord2f(dx, maxV - dy);
+        glVertex3f(x1, y1, 0.0f);
+        glTexCoord2f(maxU - dx, maxV - dy);
+        glVertex3f(x2, y2, 0.0f);
+        glTexCoord2f(maxU - dx, dy);
+        glVertex3f(x3, y3, 0.0f);
+        glTexCoord2f(dx, dy);
+        glVertex3f(x4, y4, 0.0f);
+        glEnd();
+    }
+    else
+    {
+        float scaleX = 1.0f / static_cast<float>(heightModel.size() - 1);
+
+        for (int32_t i = 0; i < heightModel.size() - 1; ++i)
+        {
+            float scaleI = scaleX * static_cast<float>(i);
+
+            float scaleY =
+                    1.0f / static_cast<float>(heightModel[i].size() - 1);
+
+            float x1i = x1 + scaleI * (x4 - x1);
+            float x1f = x2 + scaleI * (x3 - x2);
+            float x2i = x1i + scaleX * (x4 - x1);
+            float x2f = x1f + scaleX * (x3 - x2);
+
+            for (int32_t j = 0; j < heightModel[i].size() - 1; ++j)
+            {
+                float scaleJ = scaleY * static_cast<float>(j);
+
+                float y1i = y1 + scaleJ * (y2 - y1);
+                float y1f = y4 + scaleJ * (y3 - y4);
+                float y2i = y1i + scaleY * (y2 - y1);
+                float y2f = y1f + scaleY * (y3 - y4);
+
+                float nx1 = x1i + scaleJ * (x1f - x1i);
+                float nx2 = x1i + (scaleJ + scaleY) * (x1f - x1i);
+                float nx3 = x2i + (scaleJ + scaleY) * (x2f - x2i);
+                float nx4  = x2i + scaleJ * (x2f - x2i);
+                float ny1 = y1i + scaleI * (y1f - y1i);
+                float ny2 = y2i + scaleI * (y2f - y2i);
+                float ny3 = y2i + (scaleI + scaleX) * (y2f - y2i);
+                float ny4 = y1i + (scaleI + scaleX) * (y1f - y1i);
+
+                glBegin(GL_QUADS);
+                glTexCoord2f(dx + scaleJ * (maxU - dx * 2.0f),
+                             dy + (1.0f - scaleI) * (maxV - dy * 2.0f));
+                glVertex3f(nx1, ny1, -static_cast<float>(heightModel[i][j]));
+                glTexCoord2f(dx + (scaleJ + scaleY) * (maxU - dx * 2.0f),
+                             dy + (1.0f - scaleI) * (maxV - dy * 2.0f));
+                glVertex3f(nx2, ny2, -static_cast<float>(heightModel[i][j + 1]));
+                glTexCoord2f(dx + (scaleJ + scaleY) * (maxU - dx * 2.0f),
+                             dy + (1.0f - scaleI - scaleX) * (maxV - dy * 2.0f));
+                glVertex3f(nx3, ny3, -static_cast<float>(heightModel[i + 1][j + 1]));
+                glTexCoord2f(dx + scaleJ * (maxU - dx * 2.0f),
+                             dy + (1.0f - scaleI - scaleX) * (maxV - dy * 2.0f));
+                glVertex3f(nx4, ny4, -static_cast<float>(heightModel[i + 1][j]));
+
+                glEnd();
+            }
+        }
+    }
+}
+
+bool
+Texture::is3D(void) const
+{
+    return _is3D;
+}

src/ui/map3D/Texture.h

+/*=====================================================================
+
+QGroundControl Open Source Ground Control Station
+
+(c) 2009, 2010 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
+
+This file is part of the QGROUNDCONTROL project
+
+    QGROUNDCONTROL 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.
+
+    QGROUNDCONTROL 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 QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
+
+======================================================================*/
+
+/**
+ * @file
+ *   @brief Definition of the class Texture.
+ *
+ *   @author Lionel Heng <hengli@student.ethz.ch>
+ *
+ */
+
+#ifndef TEXTURE_H
+#define TEXTURE_H
+
+#if (defined __APPLE__) & (defined __MACH__)
+#include <OpenGL/gl.h>
+#else
+#include <GL/gl.h>
+#endif
+#include <inttypes.h>
+#include <osg/ref_ptr>
+#include <osg/Geometry>
+#include <QSharedPointer>
+
+#include "WebImage.h"
+
+class Texture
+{
+public:
+    Texture();
+
+    const QString& getSourceURL(void) const;
+
+    void setId(unsigned int _id);
+
+    void sync(const WebImagePtr& image);
+
+    osg::ref_ptr<osg::Geometry> draw(float x1, float y1, float x2, float y2,
+                                     bool smoothInterpolation) const;
+    osg::ref_ptr<osg::Geometry> draw(float x1, float y1, float x2, float y2,
+                                     float x3, float y3, float x4, float y4,
+                                     bool smoothInterpolation) const;
+
+    bool is3D(void) const;
+
+private:
+    enum State
+    {
+        UNINITIALIZED = 0,
+        REQUESTED = 1,
+        READY = 2
+    };
+
+    State state;
+    QString sourceURL;
+    unsigned int id;
+    osg::ref_ptr<osg::Texture2D> texture2D;
+
+    int32_t textureWidth;
+    int32_t textureHeight;
+
+    int32_t imageWidth;
+    int32_t imageHeight;
+
+    bool _is3D;
+    QVector< QVector<int32_t> > heightModel;
+
+    float maxU;
+    float maxV;
+};
+
+typedef QSharedPointer<Texture> TexturePtr;
+
+#endif // TEXTURE_H

src/ui/map3D/TextureCache.cc

+/*=====================================================================
+
+QGroundControl Open Source Ground Control Station
+
+(c) 2009, 2010 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
+
+This file is part of the QGROUNDCONTROL project
+
+    QGROUNDCONTROL 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.
+
+    QGROUNDCONTROL 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 QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
+
+======================================================================*/
+
+/**
+ * @file
+ *   @brief Definition of the class TextureCache.
+ *
+ *   @author Lionel Heng <hengli@student.ethz.ch>
+ *
+ */
+
+#include "TextureCache.h"
+
+TextureCache::TextureCache(uint32_t _cacheSize)
+    : cacheSize(_cacheSize)
+    , imageCache(new WebImageCache(0, cacheSize))
+{
+    for (uint32_t i = 0; i < cacheSize; ++i)
+    {
+        TexturePtr t(new Texture);
+        t->setId(i);
+
+        textures.push_back(t);
+    }
+}
+
+TexturePtr
+TextureCache::get(const QString& tileURL, bool useHeightModel)
+{
+    QPair<TexturePtr, int32_t> p1 = lookup(tileURL, useHeightModel);
+    if (!p1.first.isNull())
+    {
+        return p1.first;
+    }
+
+    QPair<WebImagePtr, int32_t> p2 =
+            imageCache->lookup(tileURL, useHeightModel);
+    if (!p2.first.isNull())
+    {
+        textures[p2.second]->sync(p2.first);
+        p1 = lookup(tileURL, useHeightModel);
+
+        return p1.first;
+    }
+
+    return TexturePtr();
+}
+
+void
+TextureCache::sync(void)
+{
+    if (requireSync())
+    {
+        for (int32_t i = 0; i < textures.size(); ++i)
+        {
+            textures[i]->sync(imageCache->at(i));
+        }
+    }
+}
+
+QPair<TexturePtr, int32_t>
+TextureCache::lookup(const QString& tileURL, bool useHeightModel)
+{
+    for (int32_t i = 0; i < textures.size(); ++i)
+    {
+        if (textures[i]->getSourceURL() == tileURL &&
+            textures[i]->is3D() == useHeightModel)
+        {
+            return qMakePair(textures[i], i);
+        }
+    }
+
+    return qMakePair(TexturePtr(), -1);
+}
+
+bool
+TextureCache::requireSync(void) const
+{
+    for (uint32_t i = 0; i < cacheSize; ++i)
+    {
+        if (imageCache->at(i)->getSyncFlag())
+        {
+            return true;
+        }
+    }
+    return false;
+}

src/ui/map3D/TextureCache.h

+/*=====================================================================
+
+QGroundControl Open Source Ground Control Station
+
+(c) 2009, 2010 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
+
+This file is part of the QGROUNDCONTROL project
+
+    QGROUNDCONTROL 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.
+
+    QGROUNDCONTROL 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 QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
+
+======================================================================*/
+
+/**
+ * @file
+ *   @brief Definition of the class TextureCache.
+ *
+ *   @author Lionel Heng <hengli@student.ethz.ch>
+ *
+ */
+
+#ifndef TEXTURECACHE_H
+#define TEXTURECACHE_H
+
+#include <QVector>
+
+#include "Texture.h"
+#include "WebImageCache.h"
+
+class TextureCache
+{
+public:
+    explicit TextureCache(uint32_t cacheSize);
+
+    TexturePtr get(const QString& tileURL, bool useHeightModel = false);
+
+    void sync(void);
+
+private:
+    QPair<TexturePtr, int32_t> lookup(const QString& tileURL,
+                                      bool useHeightModel);
+
+    bool requireSync(void) const;
+
+    uint32_t cacheSize;
+    QVector<TexturePtr> textures;
+
+    QScopedPointer<WebImageCache> imageCache;
+};
+
+#endif // TEXTURECACHE_H

src/ui/map3D/WebImage.cc

+/*=====================================================================
+
+QGroundControl Open Source Ground Control Station
+
+(c) 2009, 2010 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
+
+This file is part of the QGROUNDCONTROL project
+
+    QGROUNDCONTROL 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.
+
+    QGROUNDCONTROL 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 QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
+
+======================================================================*/
+
+/**
+ * @file
+ *   @brief Definition of the class WebImage.
+ *
+ *   @author Lionel Heng <hengli@student.ethz.ch>
+ *
+ */
+
+#include "WebImage.h"
+
+#include <QFile>
+#include <QGLWidget>
+
+WebImage::WebImage()
+    : state(WebImage::UNINITIALIZED)
+    , sourceURL("")
+    , image(0)
+    , lastReference(0)
+    , _is3D(false)
+    , syncFlag(false)
+{
+
+}
+
+void
+WebImage::clear(void)
+{
+    image.reset();
+    sourceURL.clear();
+    state = WebImage::UNINITIALIZED;
+    lastReference = 0;
+    heightModel.clear();
+}
+
+WebImage::State
+WebImage::getState(void) const
+{
+    return state;
+}
+
+void
+WebImage::setState(State state)
+{
+    this->state = state;
+}
+
+const QString&
+WebImage::getSourceURL(void) const
+{
+    return sourceURL;
+}
+
+void
+WebImage::setSourceURL(const QString& url)
+{
+    sourceURL = url;
+}
+
+const uint8_t*
+WebImage::getImageData(void) const
+{
+    return image->scanLine(0);
+}
+
+const QVector< QVector<int32_t> >&
+WebImage::getHeightModel(void) const
+{
+    return heightModel;
+}
+
+bool
+WebImage::setData(const QByteArray& data)
+{
+    QImage tempImage;
+    if (tempImage.loadFromData(data))
+    {
+        if (image.isNull())
+        {
+            image.reset(new QImage);
+        }
+        *image = QGLWidget::convertToGLFormat(tempImage);
+
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+bool
+WebImage::setData(const QString& filename)
+{
+    QImage tempImage;
+    if (tempImage.load(filename))
+    {
+        if (image.isNull())
+        {
+            image.reset(new QImage);
+        }
+        *image = QGLWidget::convertToGLFormat(tempImage);
+
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+bool
+WebImage::setData(const QString& imageFilename, const QString& heightFilename)
+{
+    QFile heightFile(heightFilename);
+
+    QImage tempImage;
+    if (tempImage.load(imageFilename) && heightFile.open(QIODevice::ReadOnly))
+    {
+        if (image.isNull())
+        {
+            image.reset(new QImage);
+        }
+        *image = QGLWidget::convertToGLFormat(tempImage);
+
+        QDataStream heightDataStream(&heightFile);
+
+        // read in width and height values for height map
+        char header[8];
+        heightDataStream.readRawData(header, 8);
+
+        int32_t height = *(reinterpret_cast<int32_t *>(header));
+        int32_t width = *(reinterpret_cast<int32_t *>(header + 4));
+
+        char buffer[height * width * sizeof(int32_t)];
+        heightDataStream.readRawData(buffer, height * width * sizeof(int32_t));
+
+        heightModel.clear();
+        for (int32_t i = 0; i < height; ++i)
+        {
+            QVector<int32_t> scanline;
+            for (int32_t j = 0; j < width; ++j)
+            {    
+                int32_t n = *(reinterpret_cast<int32_t *>(buffer
+                                                          + (i * height + j)
+                                                          * sizeof(int32_t)));
+                scanline.push_back(n);
+            }
+            heightModel.push_back(scanline);
+        }
+
+        heightFile.close();
+
+        _is3D = true;
+
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+int32_t
+WebImage::getWidth(void) const
+{
+    return image->width();
+}
+
+int32_t
+WebImage::getHeight(void) const
+{
+    return image->height();
+}
+
+int32_t
+WebImage::getByteCount(void) const
+{
+    return image->byteCount();
+}
+
+bool
+WebImage::is3D(void) const
+{
+    return _is3D;
+}
+
+uint64_t
+WebImage::getLastReference(void) const
+{
+    return lastReference;
+}
+
+void
+WebImage::setLastReference(uint64_t value)
+{
+    lastReference = value;
+}
+
+bool
+WebImage::getSyncFlag(void) const
+{
+    return syncFlag;
+}
+
+void
+WebImage::setSyncFlag(bool onoff)
+{
+    syncFlag = onoff;
+}

src/ui/map3D/WebImage.h

+/*=====================================================================
+
+QGroundControl Open Source Ground Control Station
+
+(c) 2009, 2010 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
+
+This file is part of the QGROUNDCONTROL project
+
+    QGROUNDCONTROL 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.
+
+    QGROUNDCONTROL 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 QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
+
+======================================================================*/
+
+/**
+ * @file
+ *   @brief Definition of the class WebImage.
+ *
+ *   @author Lionel Heng <hengli@student.ethz.ch>
+ *
+ */
+
+#ifndef WEBIMAGE_H
+#define WEBIMAGE_H
+
+#include <inttypes.h>
+#include <QImage>
+#include <QScopedPointer>
+#include <QSharedPointer>
+
+class WebImage
+{
+public:
+    WebImage();
+
+    void clear(void);
+
+    enum State
+    {
+        UNINITIALIZED = 0,
+        REQUESTED = 1,
+        READY = 2
+    };
+
+    State getState(void) const;
+    void setState(State state);
+
+    const QString& getSourceURL(void) const;
+    void setSourceURL(const QString& url);
+
+    const uint8_t* getImageData(void) const;
+    const QVector< QVector<int32_t> >& getHeightModel(void) const;
+    bool setData(const QByteArray& data);
+    bool setData(const QString& filename);
+    bool setData(const QString& imageFilename, const QString& heightFilename);
+
+    int32_t getWidth(void) const;
+    int32_t getHeight(void) const;
+    int32_t getByteCount(void) const;
+
+    bool is3D(void) const;
+
+    uint64_t getLastReference(void) const;
+    void setLastReference(uint64_t value);
+
+    bool getSyncFlag(void) const;
+    void setSyncFlag(bool onoff);
+
+private:
+    State state;
+    QString sourceURL;
+    QScopedPointer<QImage> image;
+    QVector< QVector<int32_t> > heightModel;
+    uint64_t lastReference;
+    bool _is3D;
+    bool syncFlag;
+};
+
+typedef QSharedPointer<WebImage> WebImagePtr;
+
+#endif // WEBIMAGE_H

src/ui/map3D/WebImageCache.cc

+/*=====================================================================
+
+QGroundControl Open Source Ground Control Station
+
+(c) 2009, 2010 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
+
+This file is part of the QGROUNDCONTROL project
+
+    QGROUNDCONTROL 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.
+
+    QGROUNDCONTROL 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 QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
+
+======================================================================*/
+
+/**
+ * @file
+ *   @brief Definition of the class WebImageCache.
+ *
+ *   @author Lionel Heng <hengli@student.ethz.ch>
+ *
+ */
+
+#include "WebImageCache.h"
+
+#include <QNetworkReply>
+#include <QPixmap>
+
+WebImageCache::WebImageCache(QObject* parent, uint32_t _cacheSize)
+    : QObject(parent)
+    , cacheSize(_cacheSize)
+    , currentReference(0)
+    , networkManager(new QNetworkAccessManager)
+{
+    for (uint32_t i = 0; i < cacheSize; ++i)
+    {
+        WebImagePtr image(new WebImage);
+
+        webImages.push_back(image);
+    }
+
+    connect(networkManager.data(), SIGNAL(finished(QNetworkReply*)),
+            this, SLOT(downloadFinished(QNetworkReply*)));
+}
+
+QPair<WebImagePtr, int32_t>
+WebImageCache::lookup(const QString& url, bool useHeightModel)
+{
+    QPair<WebImagePtr, int32_t> cacheEntry;
+
+    for (int32_t i = 0; i < webImages.size(); ++i)
+    {
+        if (webImages[i]->getState() != WebImage::UNINITIALIZED &&
+            webImages[i]->getSourceURL() == url &&
+            webImages[i]->is3D() == useHeightModel)
+        {
+            cacheEntry.first = webImages[i];
+            cacheEntry.second = i;
+            break;
+        }
+    }
+
+    if (cacheEntry.first.isNull())
+    {
+        for (int32_t i = 0; i < webImages.size(); ++i)
+        {
+            // get uninitialized image
+            if (webImages[i]->getState() == WebImage::UNINITIALIZED)
+            {
+                cacheEntry.first = webImages[i];
+                cacheEntry.second = i;
+                break;
+            }
+            // get oldest image
+            else if (webImages[i]->getState() == WebImage::READY &&
+                     (cacheEntry.first.isNull() ||
+                      webImages[i]->getLastReference() <
+                      cacheEntry.first->getLastReference()))
+            {
+                cacheEntry.first = webImages[i];
+                cacheEntry.second = i;
+            }
+        }
+
+        if (cacheEntry.first.isNull())
+        {
+            return qMakePair(WebImagePtr(), -1);
+        }
+        else
+        {
+            if (cacheEntry.first->getState() == WebImage::READY)
+            {
+                cacheEntry.first->clear();
+            }
+            cacheEntry.first->setSourceURL(url);
+            cacheEntry.first->setLastReference(currentReference);
+            ++currentReference;
+            cacheEntry.first->setState(WebImage::REQUESTED);
+
+            if (url.left(4).compare("http") == 0)
+            {
+                networkManager->get(QNetworkRequest(QUrl(url)));
+            }
+            else
+            {
+                bool success;
+
+                if (useHeightModel)
+                {
+                    QString heightURL = url;
+                    heightURL.replace("color", "dom");
+                    heightURL.replace(".jpg", ".txt");
+
+                    success = cacheEntry.first->setData(url, heightURL);
+                }
+                else
+                {
+                    success = cacheEntry.first->setData(url);
+                }
+
+                if (success)
+                {
+                    cacheEntry.first->setSyncFlag(true);
+                    cacheEntry.first->setState(WebImage::READY);
+                }
+                else
+                {
+                    cacheEntry.first->setState(WebImage::UNINITIALIZED);
+                }
+            }
+
+            return cacheEntry;
+        }
+    }
+    else
+    {
+        if (cacheEntry.first->getState() == WebImage::READY)
+        {
+            cacheEntry.first->setLastReference(currentReference);
+            ++currentReference;
+            return cacheEntry;
+        }
+        else
+        {
+            return qMakePair(WebImagePtr(), -1);
+        }
+    }
+}
+
+WebImagePtr
+WebImageCache::at(int32_t index) const
+{
+    return webImages[index];
+}
+
+void
+WebImageCache::downloadFinished(QNetworkReply* reply)
+{
+    reply->deleteLater();
+
+    if (reply->error() != QNetworkReply::NoError)
+    {
+        return;
+    }
+    QVariant attribute = reply->attribute(QNetworkRequest::RedirectionTargetAttribute);
+    if (attribute.isValid())
+    {
+        return;
+    }
+
+    WebImagePtr image;
+    foreach(image, webImages)
+    {
+        if (reply->url().toString() == image->getSourceURL())
+        {
+            image->setData(reply->readAll());
+            image->setSyncFlag(true);
+            image->setState(WebImage::READY);
+
+            return;
+        }
+    }
+}

src/ui/map3D/WebImageCache.h

+/*=====================================================================
+
+QGroundControl Open Source Ground Control Station
+
+(c) 2009, 2010 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
+
+This file is part of the QGROUNDCONTROL project
+
+    QGROUNDCONTROL 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.
+
+    QGROUNDCONTROL 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 QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
+
+======================================================================*/
+
+/**
+ * @file
+ *   @brief Definition of the class WebImageCache.
+ *
+ *   @author Lionel Heng <hengli@student.ethz.ch>
+ *
+ */
+
+#ifndef WEBIMAGECACHE_H
+#define WEBIMAGECACHE_H
+
+#include <QNetworkAccessManager>
+#include <QObject>
+#include <QPair>
+
+#include "WebImage.h"
+
+class WebImageCache : public QObject
+{
+    Q_OBJECT
+
+public:
+    WebImageCache(QObject* parent, uint32_t cacheSize);
+
+    QPair<WebImagePtr, int32_t> lookup(const QString& url,
+                                       bool useHeightModel);
+
+    WebImagePtr at(int32_t index) const;
+
+private Q_SLOTS:
+    void downloadFinished(QNetworkReply* reply);
+
+private:
+    uint32_t cacheSize;
+
+    QVector<WebImagePtr> webImages;
+    uint64_t currentReference;
+
+    QScopedPointer<QNetworkAccessManager> networkManager;
+};
+
+#endif // WEBIMAGECACHE_H