tcViewportWidget.cpp

   1 /***************************************************************************
   2  *   This file is part of Tecorrec.                                        *
   3  *   Copyright 2008 James Hogan <james@albanarts.com>                      *
   4  *                                                                         *
   5  *   Tecorrec is free software: you can redistribute it and/or modify      *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation, either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   Tecorrec is distributed in the hope that it will be useful,           *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with Tecorrec.  If not, write to the Free Software Foundation,  *
  17  *   Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.   *
  18  ***************************************************************************/
  19
  20 /**
  21  * @file tcViewportWidget.cpp
  22  * @brief OpenGL viewport widget.
  23  */
  24
  25 #include "tcViewportWidget.h"
  26 #include <tcObserver.h>
  27 #include <tcGlobe.h>
  28 #include <Vector.h>
  29 #include <glVector.h>
  30
  31 #include <QMouseEvent>
  32
  33 #include <cmath>
  34
  35 /*
  36  * Constructors + destructor
  37  */
  38
  39 /// Primary constructor.
  40 tcViewportWidget::tcViewportWidget(QWidget* parent)
  41 : QGLWidget(parent)
  42 , m_observer(new tcObserver())
  43 , m_globe(0)
  44 , m_mouseInteracting(false)
  45 , m_mousePos()
  46 , m_mouseIntersecting(false)
  47 , m_mouseCoord()
  48 , m_mouseSlicing(false)
  49 , m_sliced(false)
  50 {
  51   setMouseTracking(true);
  52 }
  53
  54 /// Destructor.
  55 tcViewportWidget::~tcViewportWidget()
  56 {
  57   delete m_observer;
  58 }
  59
  60 /*
  61  * Modifiers
  62  */
  63
  64 /// Set the globe object.
  65 void tcViewportWidget::setGlobe(tcGlobe* globe)
  66 {
  67   m_globe = globe;
  68   tcGeo pos( 7.03227 * M_PI/180, 45.92093 * M_PI/180);
  69   m_observer->setFocus(pos, globe->radiusAt(pos));
  70 }
  71
  72 /*
  73  * Accessors
  74  */
  75
  76 /// Find the coordinates under the mouse.
  77 tcGeo tcViewportWidget::geoAt(float x, float y, bool* ok)
  78 {
  79   maths::Vector<2,double> screenXy(x / width(), 1.0 - y / height());
  80   maths::Vector<3,double> obs = m_observer->position();
  81   maths::Vector<3,double> ray = m_observer->ray(screenXy, (double)width() / height());
  82   double r = m_globe->meanRadius();
  83   double ro = obs*ray;
  84   double roro = ro*ro;
  85   bool intersecting = false;
  86   // find intersection P of ray and globe
  87   // given globe radius r, observer O, ray R, where |R|=1
  88   // globe: P*P = r*r
  89   // line:  P = O + t*R
  90   //        (O+t*R)*(O+t*R) = r*r
  91   //        O*O + 2*O*t*R + t*t*R*R = r*r
  92   //        O*O + 2*O*t*R + t*t - r*r = 0
  93   // quadratic in parameter t
  94   // a = 1, b = 2*RO c = O*O-r*r RO = O*R
  95   // t = (-b +- sqrt(b*b - 4ac)) / 2a
  96   //   = (-2RO +- sqrt(4*RO*RO - 4*O*O + 4*r*r)) / 2
  97   //   = (-2*RO +- 2*sqrt(RO*RO - O*O + r*r)) / 2
  98   //   = RO += sqrt(RO*RO - O*O + r*r)
  99   double discriminant = roro - obs.sqr() + r*r;
 100   if (discriminant >= 0.0)
 101   {
 102     discriminant = sqrt(discriminant);
 103     double t = -ro - discriminant;
 104     if (t > 0.0)
 105     {
 106       obs += ray*t;
 107       obs /= r; // should now be normalized
 108       intersecting = true;
 109     }
 110   }
 111   else
 112   {
 113     // Hmm, doesn't work
 114 #if 0
 115     // mouse is outside of globe
 116     // use closest point on outline circle of globe
 117     // sphere             P*P=r*r
 118     // tangential circle: P*(P-O) = 0
 119     //                    P*P - P*O = 0
 120     //                    r*r - P*O = 0
 121     // line:              P/s = O + tR
 122     //                    P = s(O + tR) (s>0)
 123     //                    r*r - s(O + tR)O = 0
 124     //                    r*r - s(OO + tRO) = 0
 125     //                    s(OO + tRO) = r*r
 126     //                    s = r*r/(OO+tRO)
 127     //                    t = (r*r/s - OO)/RO
 128     //
 129     //                    (sO + tsR)(sO + tsR - O) = 0
 130     //                    (O + tR)(sO + tsR - O) = 0
 131     //                    sOO + tsRO + tsOR + ttsRR - OO - tRO = 0
 132     //                    sOO + 2tsRO + tts - OO - tRO = 0
 133     //                    s(OO + 2tRO + tt) = OO - tRO
 134     //                    substitute s=rr/(OO+tRO)
 135     //                    rr/(OO+tRO)(OO + 2tRO + tt) = OO - tRO
 136     //                    rr(OO + 2tRO + tt) = (OO - tRO)(OO+tRO)
 137     //                    rrOO + 2rrtRO + rrtt = OO*OO - ttRO*RO
 138     //                    tt(rr + RO*RO) + t(2rrRO) + (rrOO - OO*OO)
 139     // a = rr + RO*RO, b = 2rrRO, c = rr00 - OO*OO
 140     // t = (-2rrRO +- sqrt(4rrrrRO*RO - 4(rr + RO*RO)(rr00 - OO*OO))) / 2(rr + RO*RO)
 141     // t = (-rrRO +- sqrt(rrrrRO*RO - (rr + RO*RO)(rr00 - OO*OO))) / (rr + RO*RO)
 142     double rr = r*r;
 143     double oo = obs*obs;
 144     double oooo = oo*oo;
 145     double discriminant = rr*rr*roro - (rr + roro)*(rr*oo - oo*oo);
 146     if (discriminant >= 0)
 147     {
 148       discriminant = sqrt(discriminant);
 149       double t = (-rr*ro + discriminant) / (rr + roro);
 150       double s = rr/(oo + t*ro);
 151       if (t >= 0.0)
 152       {
 153         obs += ray*t;
 154         obs /= s;
 155         obs /= r; // should now be normalized
 156         obs.normalize();
 157         intersecting = true;
 158       }
 159     }
 160 #endif
 161   }
 162   if (0 != ok)
 163   {
 164     *ok = intersecting;
 165   }
 166   if (intersecting)
 167   {
 168     return tcGeo(obs, true);
 169   }
 170   else
 171   {
 172     return tcGeo();
 173   }
 174 }
 175
 176 /*
 177  * Elevation modification slots
 178  */
 179
 180 /// Go to flat elevation mode.
 181 void tcViewportWidget::setElevationFlat()
 182 {
 183   if (0 != m_globe)
 184   {
 185     m_globe->setElevationMode(tcGlobe::NoElevation);
 186     m_observer->setFocusAltitude(m_globe->radiusAt(m_observer->focus()));
 187     updateGL();
 188   }
 189 }
 190
 191 /// Go to raw SRTM elevation mode.
 192 void tcViewportWidget::setElevationRaw()
 193 {
 194   if (0 != m_globe)
 195   {
 196     m_globe->setElevationMode(tcGlobe::RawElevation);
 197     m_observer->setFocusAltitude(m_globe->radiusAt(m_observer->focus()));
 198     updateGL();
 199   }
 200 }
 201
 202 /// Go to corrected elevation mode.
 203 void tcViewportWidget::setElevationCorrected()
 204 {
 205   if (0 != m_globe)
 206   {
 207     m_globe->setElevationMode(tcGlobe::CorrectedElevation);
 208     m_observer->setFocusAltitude(m_globe->radiusAt(m_observer->focus()));
 209     updateGL();
 210   }
 211 }
 212
 213 /// Set the level of correction applied to the elevation data.
 214 void tcViewportWidget::setElevationCorrection(int correction)
 215 {
 216   if (0 != m_globe)
 217   {
 218     m_globe->setElevationCorrection((float)correction/100);
 219     m_observer->setFocusAltitude(m_globe->radiusAt(m_observer->focus()));
 220     updateGL();
 221   }
 222 }
 223
 224 /// Set the elevation data set name.
 225 void tcViewportWidget::setElevationDataSet(const QString& name)
 226 {
 227   if (0 != m_globe)
 228   {
 229     m_globe->setElevationDataSet(name);
 230     m_observer->setFocusAltitude(m_globe->radiusAt(m_observer->focus()));
 231     updateGL();
 232   }
 233 }
 234
 235 /*
 236  * Rendering
 237  */
 238
 239 void tcViewportWidget::initializeGL()
 240 {
 241   glClearColor(0.0, 0.3, 0.7, 0.0);
 242 }
 243
 244 void tcViewportWidget::resizeGL(int w, int h)
 245 {
 246   glViewport(0, 0, (GLint)w, (GLint)h);
 247
 248   double aspect = (double)w / h;
 249   m_observer->setupProjection(aspect);
 250 }
 251
 252 void tcViewportWidget::paintGL()
 253 {
 254   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 255   glEnable(GL_DEPTH_TEST);
 256   glEnable(GL_CULL_FACE);
 257
 258   glEnable(GL_BLEND);
 259   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 260
 261
 262   m_observer->setupModelView();
 263
 264   if (m_sliced)
 265   {
 266     m_globe->render(m_observer, m_slice);
 267   }
 268   else
 269   {
 270     m_globe->render(m_observer);
 271   }
 272
 273   float meanRadius = m_globe->meanRadius();
 274
 275   glLineWidth(3);
 276   double spotlightExtent = m_observer->range()*0.4;
 277   // Draw a spotlight for the mouse
 278   if (m_mouseIntersecting)
 279   {
 280     maths::Vector<3,double> vec = m_mouseCoord;
 281     float altitude = m_globe->altitudeAt(m_mouseCoord);
 282     glBegin(GL_LINES);
 283     {
 284       glColor4f(1.0f, 1.0f, 0.0f, 1.0f);
 285       glVertex3(vec*meanRadius);
 286       glVertex3(vec*(meanRadius + altitude));
 287     }
 288     {
 289       glColor4f(1.0f, 0.0f, 1.0f, 1.0f);
 290       glVertex3(vec*(meanRadius + altitude));
 291       glColor4f(1.0f, 1.0f, 1.0f, 0.0f);
 292       glVertex3(vec*(meanRadius + altitude + spotlightExtent));
 293     }
 294     glEnd();
 295   }
 296   // Draw a spotlight for the focus
 297   {
 298     maths::Vector<3,double> vec = m_observer->focus();
 299     float altitude = m_globe->altitudeAt(m_observer->focus());
 300     glBegin(GL_LINES);
 301     {
 302       glColor4f(1.0f, 1.0f, 0.0f, 1.0f);
 303       glVertex3(vec*meanRadius);
 304       glVertex3(vec*(meanRadius + altitude));
 305     }
 306     {
 307       glColor4f(0.0f, 1.0f, 1.0f, 1.0f);
 308       glVertex3(vec*(meanRadius + altitude));
 309       glColor4f(1.0f, 1.0f, 1.0f, 0.0f);
 310       glVertex3(vec*(meanRadius + altitude + spotlightExtent));
 311     }
 312     glEnd();
 313   }
 314   glLineWidth(1);
 315
 316   // Draw a fence around the selected region
 317   for (int i = 0; i < 2; ++i)
 318   {
 319     tcGeo coord;
 320     tcGeo ending;
 321     float colour[4] = {1.0f, 0.5f, 1.0f, 1.0f};
 322     if (0 == i && m_mouseSlicing && m_mouseIntersecting)
 323     {
 324       coord = m_mouseCoord;
 325       ending = m_mouseStartCoord;
 326     }
 327     else if (1 == i && m_sliced)
 328     {
 329       coord = m_slice[0];
 330       ending = m_slice[1];
 331       colour[0] = 0.0f;
 332       colour[3] = 0.5f;
 333     }
 334     else
 335     {
 336       continue;
 337     }
 338
 339     tcGeo delta = ending - coord;
 340     int nlon = 2 + fabs(delta.lon())*10*meanRadius / m_observer->range();
 341     int nlat = 2 + fabs(delta.lat())*10*meanRadius / m_observer->range();
 342     double dlon = delta.lon() / nlon;
 343     double dlat = delta.lat() / nlat;
 344
 345     glDisable(GL_CULL_FACE);
 346     glBegin(GL_TRIANGLE_STRIP);
 347     for (int i = 0; i <= nlon*2 + nlat*2; ++i)
 348     {
 349       float radius = m_globe->radiusAt(coord);
 350       maths::Vector<3,double> coordVec = coord;
 351       glColor4fv(colour);
 352       glVertex3(coordVec*radius);
 353       glColor4f(1.0f, 1.0f, 1.0f, 0.0f);
 354       glVertex3(coordVec*(radius + m_observer->range()*0.1));
 355
 356       if (i < nlon)
 357       {
 358         coord.setLon(coord.lon() + dlon);
 359       }
 360       else if (i < nlon + nlat)
 361       {
 362         coord.setLat(coord.lat() + dlat);
 363       }
 364       else if (i < nlon + nlat + nlon)
 365       {
 366         coord.setLon(coord.lon() - dlon);
 367       }
 368       else
 369       {
 370         coord.setLat(coord.lat() - dlat);
 371       }
 372     }
 373     glEnd();
 374     glEnable(GL_CULL_FACE);
 375   }
 376
 377 }
 378
 379 /*
 380  * Mouse events
 381  */
 382
 383 void tcViewportWidget::mouseMoveEvent(QMouseEvent* event)
 384 {
 385   if (m_mouseInteracting)
 386   {
 387     QPointF dpos = event->posF() - m_mousePos;
 388     m_mousePos = event->posF();
 389
 390     // Pan the scene, adjust the observer focus
 391     m_observer->moveFocusRelative(dpos.x() / height(), dpos.y() / width());
 392     m_observer->setFocusAltitude(m_globe->radiusAt(m_observer->focus()));
 393   }
 394
 395   QString mouseDescription;
 396   bool ok;
 397   m_mouseCoord = geoAt(event->posF().x(), event->posF().y(), &ok);
 398   m_mouseIntersecting = ok;
 399   if (ok)
 400   {
 401     mouseDescription = m_mouseCoord.describe() + " " + tr("%1 m","metres")
 402                                                           .arg(m_globe->altitudeAt(m_mouseCoord));
 403     emit mouseGeoChanged(m_mouseCoord);
 404   }
 405   else
 406   {
 407     mouseDescription = tr("--");
 408   }
 409   emit mouseGeoTextChanged(tr("Focus: %1 %2, Mouse: %3")
 410                                 .arg(m_observer->focus().describe())
 411                                 .arg(tr("%1 m","metres")
 412                                         .arg(m_globe->altitudeAt(m_observer->focus())))
 413                                 .arg(mouseDescription));
 414
 415   if (m_mouseInteracting || m_mouseSlicing || m_sliced)
 416   {
 417     updateGL();
 418   }
 419 }
 420
 421 void tcViewportWidget::mousePressEvent(QMouseEvent* event)
 422 {
 423   if (event->button() == Qt::LeftButton)
 424   {
 425     m_mouseInteracting = true;
 426     m_mousePos = event->posF();
 427   }
 428   else if (event->button() == Qt::RightButton)
 429   {
 430     bool ok;
 431     m_mouseStartCoord = geoAt(event->posF().x(), event->posF().y(), &ok);
 432     m_mouseIntersecting = false;
 433     if (ok)
 434     {
 435       m_mouseSlicing = true;
 436     }
 437   }
 438 }
 439
 440 void tcViewportWidget::mouseReleaseEvent(QMouseEvent* event)
 441 {
 442   if (m_mouseInteracting)
 443   {
 444     m_mouseInteracting = false;
 445   }
 446   else if (m_mouseSlicing)
 447   {
 448     m_mouseSlicing = false;
 449     m_sliced = m_mouseIntersecting;
 450     if (m_mouseIntersecting)
 451     {
 452       m_slice[0] = m_mouseStartCoord;
 453       m_slice[1] = m_mouseCoord;
 454     }
 455     updateGL();
 456   }
 457 }
 458
 459 void tcViewportWidget::wheelEvent(QWheelEvent* event)
 460 {
 461   float delta = M_PI/180.0 * event->delta()/8;
 462   delta *= 0.5f;
 463   if (event->orientation() == Qt::Vertical)
 464   {
 465     if (event->modifiers().testFlag(Qt::ControlModifier))
 466     {
 467       m_observer->adjustElevation(delta);
 468     }
 469     else
 470     {
 471       m_observer->adjustRange(-delta);
 472     }
 473   }
 474   else
 475   {
 476     m_observer->adjustAzimuth(-delta);
 477   }
 478   m_observer->setFocusAltitude(m_globe->radiusAt(m_observer->focus()));
 479
 480   updateGL();
 481 }