GLIMSView Source Code Documentation

image.cpp

Go to the documentation of this file.

#include "image.h"

#include "gdalfrmt.h"
#include "hdfeosfrmt.h"
#include "l7a_geotiff.h"
#include "l7a_nlaps.h"
#include "l7a_fast.h"
#include "nlapsfrmt.h"

#include "TraceLog.h"

std::string Image::MFF_NAMES[] = {
"Landsat 7 Geotiff",
"Landsat 7 NLAPS",
"Landsat 7 FastL7A"
};

int Image::NUM_MFF = 3;


Image::Image( ImageFormat *imgf ) :
mImgFrmt( imgf ) {
  std::vector<ImageFormat::BandInf> bandset = imgf->getBandInfSet();

  mWidth = 0;
  mHeight = 0;

  // GET THE LARGEST DIMENSIONS FOR BOTH X & Y
  for ( unsigned int i=0; i < bandset.size(); i++ ) {
    if ( bandset[i].width > mWidth )
      mWidth = bandset[i].width;
    if ( bandset[i].height > mHeight )
      mHeight = bandset[i].height;
  }

  mState.mRed = -1;
  mState.mGreen = -1;
  mState.mBlue = -1;
  mState.mColor = false;

  mMemFrmt = NULL;
}

Image::~Image( ) {
  if ( mImgFrmt )
    delete mImgFrmt;

  if ( mMemFrmt )
    delete mMemFrmt;
}

Image* Image::openImage( std::string fname, MultiFileType type ) {
  Image *retimg = NULL;
  switch ( type ) {
    case LSAT7_GEOTIFF:
      {
        L7A_Geotiff *l7a_g = new L7A_Geotiff;
        if ( l7a_g->open(fname ) )
          retimg =  new Image( l7a_g );
        else {
          delete l7a_g;
          return NULL;
        }
      }
      break;

    case LSAT7_NLAPS:
      {
        L7A_Nlaps *l7a_n = new L7A_Nlaps;
        if ( l7a_n->open(fname ) )
          retimg =  new Image( l7a_n );
        else {
          delete l7a_n;
          return NULL;
        }
      }
      break;

    case LSAT7_FASTL7A:
      return NULL;
      break;

    default:
      break;
  }

  GDALFrmt *gdal = new GDALFrmt;
  if ( !retimg && gdal->open( fname ) )
    retimg = new Image( gdal );
  else
    delete gdal;

  HdfEosFrmt *hdfeos = new HdfEosFrmt;
  if ( !retimg && hdfeos->open( fname ) )
    retimg = new Image( hdfeos );
  else
    delete hdfeos;

  NlapsFrmt *nlaps = new NlapsFrmt;
  if ( !retimg && nlaps->open( fname ) )
    retimg = new Image( nlaps );
  else
    delete nlaps;

  if ( retimg ) {
    ImageState state;
    state.mFileName = fname;
    state.mType     = type;
    retimg->setImageState( state );
    return retimg;
  }
  return NULL;
}

QImage* Image::getRect(
                      int x1,
                      int y1,
                      int w1,
                      int h1,
                      int w2,
                      int h2,
                      ImageFormat::ScaleType st ) {
  double  b1xs, b2xs, b3xs;   // X SCALE FOR ALL BANDS
  double  b1ys, b2ys, b3ys;   // Y SCALE FOR ALL BANDS
  void    *data[3];           // DATA PTR FOR RAW DATA
  QImage  *retimg;            // QIMAGE PTR FOR RETURN
  int     imgw, imgh;         // BAND WIDTH/HEIGHT

  if ( mState.mRed == -1 )
    return NULL;

  std::vector<ImageFormat::BandInf> bandset =     // BAND INFO FOR IMAGE
                                                  mImgFrmt->getBandInfSet();

  if ( w2 == 0 )
    w2 = w1;
  if ( h2 == 0 )
    h2 = h1;

  imgw = width();
  imgh = height();

  // COMPARE BAND DIMS TO REQUESTED AND GET NEEDED DATA DIMS FOR ALL BANDS
  b1xs = (double)bandset[mState.mRed].width / (double)imgw;
  b2xs = (double)bandset[mState.mGreen].width / (double)imgw;
  b3xs = (double)bandset[mState.mBlue].width / (double)imgw;
  b1ys = (double)bandset[mState.mRed].height / (double)imgh;
  b2ys = (double)bandset[mState.mGreen].height / (double)imgh;
  b3ys = (double)bandset[mState.mBlue].height / (double)imgh;

  // GET THE DATA FROM THE FORMAT
  data[0] = mImgFrmt->getBand( mState.mRed,
                               (int)(x1*b1xs),
                               (int)(y1*b1ys),
                               (int)(w1*b1xs),
                               (int)(h1*b1ys),
                               w2,
                               h2,
                               st );
  if ( mState.mRed == mState.mGreen )
    data[1] = data[0];
  else
    data[1] = mImgFrmt->getBand( mState.mGreen,
                                 (int)(x1*b2xs),
                                 (int)(y1*b2ys),
                                 (int)(w1*b2xs),
                                 (int)(h1*b2ys),
                                 w2,
                                 h2,
                                 st );

  if ( mState.mRed == mState.mBlue )
    data[2] = data[0];
  else if ( mState.mGreen == mState.mBlue )
    data[2] = data[1];
  else
    data[2] = mImgFrmt->getBand( mState.mBlue,
                                 (int)(x1*b3xs),
                                 (int)(y1*b3ys),
                                 (int)(w1*b3xs),
                                 (int)(h1*b3ys),
                                 w2,
                                 h2,
                                 st );

  if ( data[0] == NULL || data[1] == NULL || data[2] == NULL )
    return new QImage( w2, h2, 32 );

  // SCALE DATA TO UNSIGNED BYTE FOR IMAGE
  for ( int i=0; i < 3; i++ ) {
    int sz = w2 * h2;
    int iband=0;
    if ( i == 0 )
      iband = mState.mRed;
    else if ( i == 1 )
      iband = mState.mGreen;
    else
      iband = mState.mBlue;

    double max = bandset[iband].max;
    double min = bandset[iband].min;

    if ( i == 1 && mState.mGreen == mState.mRed ) {
      data[1] = data[0];
      continue;
    }

    if ( i == 2 && (mState.mRed == mState.mBlue || mState.mGreen == mState.mBlue) ) {
      data[2] = data[0];
      continue;
    }

    ImageFormat::DataType dt = (ImageFormat::DataType)0;
    if ( i == 0 )
      dt = bandset[mState.mRed].type;
    if ( i == 1 )
      dt = bandset[mState.mGreen].type;
    if ( i == 2 )
      dt = bandset[mState.mBlue].type;

    switch ( dt ) {
      case ImageFormat::INT8:
        min = -127;
        max = 128;
        data[i] = scaleToUC( (char*)data[i], min, max, sz );
        break;

      case ImageFormat::UINT8:
        break;

      case ImageFormat::INT16:
        data[i] = scaleToUC( (short*)data[i], min, max, sz );
        break;

      case ImageFormat::UINT16:
        data[i] = scaleToUC( (unsigned short*)data[i], min, max, sz );
        break;

      default:
        break;
    }
  }

  // RESIZE(GROW) SMALLER DATA

  // CONSTRUCT QIMAGE
  retimg = new QImage( w2, h2, 32 );
  makeRGBA( retimg->bits(),
            (unsigned char*)data[0],
            (unsigned char*)data[1],
            (unsigned char*)data[2],
            w2,
            h2 );

  delete [] (char*)data[0];
  if ( !(mState.mRed == mState.mGreen) )
    delete [] (char*)data[1];

  if ( !(mState.mRed == mState.mBlue || mState.mGreen == mState.mBlue) )
    delete [] (char*)data[2];

  return retimg;
}

int Image::width( ) {
  int w = 0;
  std::vector<ImageFormat::BandInf> bandset =     // BAND INFO FOR IMAGE
                                                  mImgFrmt->getBandInfSet();

  if ( mState.mRed >= 0 && mState.mRed < (int)bandset.size() )
    w = bandset[mState.mRed].width;
  if ( mState.mGreen >= 0 && mState.mGreen < (int)bandset.size() )
    w = MAX( bandset[mState.mGreen].width, w );
  if ( mState.mBlue >= 0 && mState.mBlue < (int)bandset.size() )
    w = MAX( bandset[mState.mBlue].width, w );

  return w;
}

int Image::height( ) {
  int h = 0;
  std::vector<ImageFormat::BandInf> bandset =     // BAND INFO FOR IMAGE
                                                  mImgFrmt->getBandInfSet();

  if ( mState.mRed >= 0 && mState.mRed < (int)bandset.size() )
    h = bandset[mState.mRed].height;
  if ( mState.mGreen >= 0 && mState.mGreen < (int)bandset.size() )
    h = MAX( bandset[mState.mGreen].height, h );
  if ( mState.mBlue >= 0 && mState.mBlue < (int)bandset.size() )
    h = MAX( bandset[mState.mBlue].height, h );

  return h;
}

int Image::width( int bind ) {
  int w = 0;
  std::vector<ImageFormat::BandInf> bandset =     // BAND INFO FOR IMAGE
                                                  mImgFrmt->getBandInfSet();

  if ( bind >= 0 && bind < (int)bandset.size() )
    w = bandset[bind].width;

  return w;
}

int Image::height( int bind ) {
  int h = 0;
  std::vector<ImageFormat::BandInf> bandset =     // BAND INFO FOR IMAGE
                                                  mImgFrmt->getBandInfSet();

  if ( bind >= 0 && bind < (int)bandset.size() )
    h = bandset[bind].height;

  return h;
}

std::vector<ImageFormat::BandInf>&
Image::getBandInfSet( ) const {
  return mImgFrmt->getBandInfSet();
}

std::string Image::getName( ) const {
  return mImgFrmt->getName();
}

template<class DType>
unsigned char* Image::scaleToUC( DType *data,
                                 double min,
                                 double max,
                                 int len ) {
  unsigned char *retdata = new unsigned char[ len ];

  min *= -1;
  for ( int i=0; i < len; i++ )
    retdata[i] = (unsigned char)((data[i] + min) * 255.0 / (max+min));

  delete [] data;
  return retdata;
}

void Image::makeRGBA( unsigned char* imbits,
                      unsigned char* rData,
                      unsigned char* gData,
                      unsigned char* bData,
                      int newWidth,
                      int newHeight ) {
  int ibdata;
  int iidata;
  for ( int y=0; y < newHeight; y++ ) {
    for ( int x=0; x < newWidth; x++ ) {
      ibdata = newWidth * y + x;
      iidata = (newWidth * y * 4) + x * 4;

      imbits[iidata++] = bData[ibdata];
      imbits[iidata++] = gData[ibdata];
      imbits[iidata++] = rData[ibdata];
      imbits[iidata] = 0xff;
    }
  }
}

void Image::getLL( double &x, double &y ) {
  mImgFrmt->getLL( mState.mRed, x, y );
}

void Image::getXY( double &x, double &y ) {
  mImgFrmt->getXY( mState.mRed, x, y );
}

void Image::setMemBuf( bool state ) {
  if ( state ) {
    if ( mMemFrmt )
      return;

    mMemFrmt = new InMemFormat( mImgFrmt, &mState );
    mImgFrmt = mMemFrmt;
  } else {
    if ( !mMemFrmt )
      return;

    mImgFrmt = mMemFrmt->getFormat();
    delete mMemFrmt;
    mMemFrmt = NULL;
  }
}

---

Home | Search | Disclaimers & Privacy | Contact Us GLIMSView Maintainer: dsoltesz@usgs.gov