geo/tcGeoImageData.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 tcGeoImageData.cpp
  22  * @brief Terrain image data.
  23  */
  24
  25 #include "tcGeoImageData.h"
  26 #include "tcChannelManager.h"
  27 #include "tcChannel.h"
  28 #include <glVector.h>
  29
  30 #include <ogr_spatialref.h>
  31
  32 #include <QObject>
  33
  34 /*
  35  * Constructors + destructor
  36  */
  37
  38 /// Default constructor.
  39 tcGeoImageData::tcGeoImageData()
  40 : tcGeoData(tcGeoData::ImageData)
  41 , m_channelManager(new tcChannelManager())
  42 , m_texToGeo()
  43 , m_geoToTex()
  44 , m_effectiveTexToGeo()
  45 , m_geoToEffectiveTex()
  46 , m_sensor(0)
  47 , m_name(QObject::tr("Unamed geographical image data"))
  48 , m_sunDirection(0.0, 1.0, 0.0)
  49 , m_channelSetup()
  50 , m_effectiveNormals()
  51 {
  52   for (int i = 0; i < 3; ++i)
  53   {
  54     m_channelSetup[i] = false;
  55   }
  56 }
  57
  58 /// Destructor.
  59 tcGeoImageData::~tcGeoImageData()
  60 {
  61   delete m_channelManager;
  62 }
  63
  64 /*
  65  * Accessors
  66  */
  67
  68 /// Get a name for this image data.
  69 const QString& tcGeoImageData::name() const
  70 {
  71   return m_name;
  72 }
  73
  74 /// Get the channel manager.
  75 tcChannelManager* tcGeoImageData::channelManager() const
  76 {
  77   return m_channelManager;
  78 }
  79
  80 /// Get the sun direction.
  81 maths::Vector<3,float> tcGeoImageData::sunDirection(const tcGeo& coord) const
  82 {
  83   return (maths::Vector<3,float>)(coord.operator maths::Matrix<3,double>() * m_sunDirection);
  84 }
  85
  86 /*
  87  * Main interface
  88  */
  89
  90 /// Get the affine transformation from texture to geo.
  91 const tcAffineTransform2<double> tcGeoImageData::texToGeo() const
  92 {
  93   return m_texToGeo;
  94 }
  95
  96 /// Get the affine transformation from geo to texture.
  97 const tcAffineTransform2<double> tcGeoImageData::geoToTex() const
  98 {
  99   return m_geoToTex;
 100 }
 101
 102 /// Get the affine transformation from effective texture to geo.
 103 const tcAffineTransform2<double> tcGeoImageData::effectiveTexToGeo() const
 104 {
 105   return m_effectiveTexToGeo;
 106 }
 107
 108 /// Get the affine transformation from geo to effective texture.
 109 const tcAffineTransform2<double> tcGeoImageData::geoToEffectiveTex() const
 110 {
 111   return m_geoToEffectiveTex;
 112 }
 113
 114 /*
 115  * Rendering
 116  */
 117
 118 void tcGeoImageData::setupThumbnailRendering(int numChannels, int* channels)
 119 {
 120   Q_ASSERT(numChannels >= 3);
 121
 122   float colours[3][4] = {{ 1.0f, 0.0f, 0.0f, 1.0f },
 123                          { 0.0f, 1.0f, 0.0f, 1.0f },
 124                          { 0.0f, 0.0f, 1.0f, 1.0f }};
 125   for (int i = 0; i < 3; ++i)
 126   {
 127     if (channels[i] >= 0 && channels[i] < channelManager()->numChannels())
 128     {
 129       m_channelSetup[i] = true;
 130       glActiveTexture(GL_TEXTURE0 + i);
 131       glEnable(GL_TEXTURE_2D);
 132       glBindTexture(GL_TEXTURE_2D, channelManager()->channel(channels[i])->thumbnailTexture());
 133       /// @todo Do this in a non NV specific way
 134       // result = previous*1 + texture*colour
 135       glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, colours[i]);
 136
 137       glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV);
 138       glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_ADD);
 139       if (i == 0)
 140       {
 141         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_ZERO);
 142         glTexEnvi(GL_TEXTURE_ENV,   GL_OPERAND0_RGB, GL_SRC_COLOR);
 143         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_ZERO);
 144         glTexEnvi(GL_TEXTURE_ENV,   GL_OPERAND1_RGB, GL_SRC_COLOR);
 145       }
 146       else
 147       {
 148         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
 149         glTexEnvi(GL_TEXTURE_ENV,   GL_OPERAND0_RGB, GL_SRC_COLOR);
 150         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_ZERO);
 151         glTexEnvi(GL_TEXTURE_ENV,   GL_OPERAND1_RGB, GL_ONE_MINUS_SRC_COLOR);
 152       }
 153       glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_TEXTURE);
 154       glTexEnvi(GL_TEXTURE_ENV,   GL_OPERAND2_RGB, GL_SRC_COLOR);
 155       glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE3_RGB_NV, GL_CONSTANT);
 156       glTexEnvi(GL_TEXTURE_ENV,   GL_OPERAND3_RGB_NV, GL_SRC_COLOR);
 157     }
 158     else
 159     {
 160       m_channelSetup[i] = false;
 161     }
 162   }
 163
 164   setEffectiveTexToGeo(texToGeo());
 165 }
 166
 167 void tcGeoImageData::setupDetailedRendering(int numChannels, int* channels,
 168                                            const tcGeo& swCorner, const tcGeo& neCorner)
 169 {
 170   Q_ASSERT(numChannels >= 3);
 171
 172   float colours[3][4] = {{ 1.0f, 0.0f, 0.0f, 1.0f },
 173                          { 0.0f, 1.0f, 0.0f, 1.0f },
 174                          { 0.0f, 0.0f, 1.0f, 1.0f }};
 175
 176   tcGeo seCorner(neCorner.lon(), swCorner.lat());
 177   tcGeo nwCorner(swCorner.lon(), neCorner.lat());
 178   // Translate coordinates, we don't care about innacuracies along the edges
 179   maths::Vector<2,double> swTexCoord = geoToTex() * swCorner;
 180   maths::Vector<2,double> neTexCoord = geoToTex() * neCorner;
 181   double r1x = swTexCoord[0];
 182   double r1y = neTexCoord[1];
 183   double r2x = neTexCoord[0];
 184   double r2y = swTexCoord[1];
 185
 186   // Load any additionals
 187   for (int i = 3; i < numChannels; ++i)
 188   {
 189     if (channels[i] >= 0 && channels[i] < channelManager()->numChannels())
 190     {
 191       Reference<tcAbstractPixelData> data = channelManager()->channel(channels[i])->portion(&r1x, &r1y, &r2x, &r2y);
 192       m_effectiveNormals[i-3] = dynamicCast<tcTypedPixelData<maths::Vector<3,float> >*>(data);
 193     }
 194   }
 195   for (int i = 0; i < 3; ++i)
 196   {
 197     if (channels[i] >= 0 && channels[i] < channelManager()->numChannels())
 198     {
 199       m_channelSetup[i] = true;
 200       // Only bother if we're overlapping the interesting bit
 201       if (r1x < 1.0 && r1y < 1.0 && r2x > 0.0 && r2y > 0.0)
 202       {
 203         GLuint texture = channelManager()->channel(channels[i])->portionTexture(&r1x, &r1y, &r2x, &r2y);
 204         if (0 != texture)
 205         {
 206           glActiveTexture(GL_TEXTURE0 + i);
 207           glEnable(GL_TEXTURE_2D);
 208           glBindTexture(GL_TEXTURE_2D, texture);
 209           /// @todo Do this in a non NV specific way
 210           // result = previous*1 + texture*colour
 211           glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, colours[i]);
 212
 213           glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV);
 214           glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_ADD);
 215           if (i == 0)
 216           {
 217             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_ZERO);
 218             glTexEnvi(GL_TEXTURE_ENV,   GL_OPERAND0_RGB, GL_SRC_COLOR);
 219             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_ZERO);
 220             glTexEnvi(GL_TEXTURE_ENV,   GL_OPERAND1_RGB, GL_SRC_COLOR);
 221           }
 222           else
 223           {
 224             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
 225             glTexEnvi(GL_TEXTURE_ENV,   GL_OPERAND0_RGB, GL_SRC_COLOR);
 226             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_ZERO);
 227             glTexEnvi(GL_TEXTURE_ENV,   GL_OPERAND1_RGB, GL_ONE_MINUS_SRC_COLOR);
 228           }
 229           glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_TEXTURE);
 230           glTexEnvi(GL_TEXTURE_ENV,   GL_OPERAND2_RGB, GL_SRC_COLOR);
 231           glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE3_RGB_NV, GL_CONSTANT);
 232           glTexEnvi(GL_TEXTURE_ENV,   GL_OPERAND3_RGB_NV, GL_SRC_COLOR);
 233         }
 234       }
 235     }
 236     else
 237     {
 238       m_channelSetup[i] = false;
 239     }
 240   }
 241
 242   setEffectiveTexToGeo(tcAffineTransform2<double>(nwCorner, seCorner-nwCorner));
 243 }
 244
 245 void tcGeoImageData::setupNormalRendering()
 246 {
 247   for (int i = 0; i < 3; ++i)
 248   {
 249     glActiveTexture(GL_TEXTURE0 + i);
 250     glBindTexture(GL_TEXTURE_2D, 0);
 251     glDisable(GL_TEXTURE_2D);
 252     m_channelSetup[i] = false;
 253   }
 254   glActiveTexture(GL_TEXTURE0);
 255 }
 256
 257 void tcGeoImageData::texCoord(const tcGeo& coord)
 258 {
 259   // Coordinates need offsetting and scaling
 260   maths::Vector<2,double> texCoord = geoToEffectiveTex() * coord;
 261   for (int i = 0; i < 3; ++i)
 262   {
 263     if (m_channelSetup[i])
 264     {
 265       glMultiTexCoord2(GL_TEXTURE0 + i, texCoord);
 266     }
 267   }
 268 }
 269
 270 maths::Vector<3,float> tcGeoImageData::normalAt(int norm, const tcGeo& coord)
 271 {
 272   Q_ASSERT(norm >= 0 && norm < 3);
 273   if (0 != m_effectiveNormals[norm])
 274   {
 275     maths::Vector<2,double> texCoord = geoToEffectiveTex() * coord;
 276     return m_effectiveNormals[norm]->interpolateLinear(texCoord[0], texCoord[1]);
 277   }
 278   else
 279   {
 280     return maths::Vector<3,float>(0.0f);
 281   }
 282 }
 283
 284 void tcGeoImageData::finishRendering()
 285 {
 286   for (int i = 0; i < 3; ++i)
 287   {
 288     m_effectiveNormals[i] = 0;
 289   }
 290 }
 291
 292 /*
 293  * Protected mutators
 294  */
 295
 296 /// Set the texture to geo transformation.
 297 void tcGeoImageData::setTexToGeo(const tcAffineTransform2<double>& texToGeo)
 298 {
 299   m_texToGeo = texToGeo;
 300   m_geoToTex = texToGeo.inverse();
 301 }
 302
 303 /// Set the effective texture to geo transformation.
 304 void tcGeoImageData::setEffectiveTexToGeo(const tcAffineTransform2<double>& effectiveTexToGeo)
 305 {
 306   m_effectiveTexToGeo = effectiveTexToGeo;
 307   m_geoToEffectiveTex = effectiveTexToGeo.inverse();
 308 }
 309
 310 /// Set the name.
 311 void tcGeoImageData::setName(const QString& name)
 312 {
 313   m_name = name;
 314 }
 315
 316 /// Set the sun direction.
 317 void tcGeoImageData::setSunDirection(const tcGeo& sunDirection, const tcGeo& sunReference)
 318 {
 319   m_sunDirection = sunReference * (maths::Vector<3,double>)sunDirection;
 320 }