GLIMSView Source Code Documentation

glimsglobals.cpp

Go to the documentation of this file.

#include "glimsglobals.h"
#include <iostream>

std::vector<QColor>         GLIMSGlobals::AVAILCOLORS;
std::vector<std::string>    GLIMSGlobals::AVAILCOLORSTR;

bool GLIMSGlobals::mGlbsLoaded = false;

// LINE ATTRIBUTES
std::vector<Attr>    GLIMSGlobals::mGlbGlacTypes;
std::vector<Attr>    GLIMSGlobals::mGlbMDF;
std::vector<Attr>    GLIMSGlobals::mGlbTypes;
std::vector<Attr>    GLIMSGlobals::mGlbFtrs;
std::vector<Attr>    GLIMSGlobals::mGlbLbls;

// GLACIER ATTRIBUTES
std::vector<Attr>    GLIMSGlobals::mGlbPrimCsfn;
std::vector<Attr>    GLIMSGlobals::mGlbForm;
std::vector<Attr>    GLIMSGlobals::mGlbFrntChar;
std::vector<Attr>    GLIMSGlobals::mGlbLonChar;
std::vector<Attr>    GLIMSGlobals::mGlbDomMassSrc;
std::vector<Attr>    GLIMSGlobals::mGlbTongueAct;

const std::string GLIMSGlobals::GFTR_FILE    = "globals/lineftrs.atr";
const std::string GLIMSGlobals::GLBL_FILE    = "globals/linelbls.atr";
const std::string GLIMSGlobals::GLDF_FILE    = "globals/global.ldf";
const std::string GLIMSGlobals::GMDF_FILE    = "globals/linemat.atr";
const std::string GLIMSGlobals::GTYPE_FILE   = "globals/linetypes.atr";
const std::string GLIMSGlobals::GCAT_FILE    = "globals/linecatagory.atr";
const std::string GLIMSGlobals::GPCLASS_FILE = "globals/glacpclass.atr";
const std::string GLIMSGlobals::GFORM_FILE   = "globals/glacform.atr";
const std::string GLIMSGlobals::GFCHAR_FILE  = "globals/glacfrontalchar.atr";
const std::string GLIMSGlobals::GLCHAR_FILE  = "globals/glaclonchar.atr";
const std::string GLIMSGlobals::GDOMMS_FILE  = "globals/glacdommass.atr";
const std::string GLIMSGlobals::GTGACT_FILE  = "globals/glactongueact.atr";

LineDefSet GLIMSGlobals::mGlbLDFSet;

void GLIMSGlobals::loadGlobals( ) {
  if ( mGlbsLoaded )
    return;
  mGlbsLoaded = true;

  // LOAD GLOBALS
  readAttrFile( mGlbMDF,       GMDF_FILE );
  readAttrFile( mGlbTypes,     GTYPE_FILE );
  readAttrFile( mGlbLbls,      GLBL_FILE );
  readAttrFile( mGlbFtrs,      GFTR_FILE );
  readAttrFile( mGlbGlacTypes, GCAT_FILE );

  // LOAD GLOBAL GLACIER ATTRIBUTES
  readAttrFile( mGlbPrimCsfn,   GPCLASS_FILE );
  readAttrFile( mGlbForm,       GFORM_FILE );
  readAttrFile( mGlbFrntChar,   GFCHAR_FILE );
  readAttrFile( mGlbLonChar,    GLCHAR_FILE );
  readAttrFile( mGlbDomMassSrc, GDOMMS_FILE );
  readAttrFile( mGlbTongueAct,  GTGACT_FILE );

  mGlbLDFSet.fromXMLFile( GLDF_FILE, "LineDefinitions" );
  // INITIALIZE AVAILCOLORS
  AVAILCOLORS.push_back( QColor(0,0,255) );
  AVAILCOLORS.push_back( QColor(255,0,0) );
  AVAILCOLORS.push_back( QColor(0,255,0) );
  AVAILCOLORS.push_back( QColor(255,0,255) );
  AVAILCOLORS.push_back( QColor(255,255,0) );
  AVAILCOLORS.push_back( QColor(255,216,0) );
  AVAILCOLORS.push_back( QColor(215,115,70) );
  AVAILCOLORS.push_back( QColor(0,255,255) );
  AVAILCOLORS.push_back( QColor(0,0,0) );
  AVAILCOLORS.push_back( QColor(255,255,255) );

  AVAILCOLORSTR.push_back( "Blue" );
  AVAILCOLORSTR.push_back( "Red" );
  AVAILCOLORSTR.push_back( "Green" );
  AVAILCOLORSTR.push_back( "Purple" );
  AVAILCOLORSTR.push_back( "Yellow" );
  AVAILCOLORSTR.push_back( "Gold" );
  AVAILCOLORSTR.push_back( "Orange" );
  AVAILCOLORSTR.push_back( "Cyan" );
  AVAILCOLORSTR.push_back( "Black" );
  AVAILCOLORSTR.push_back( "White" );
}

void GLIMSGlobals::readAttrFile( std::vector<Attr> &vec,
                                 std::string fname ) {
  QDomElement e;
  QDomDocument doc;
  QFile f( fname.c_str() );
  if ( !f.open( IO_ReadOnly ) )
    return;
  if ( !doc.setContent( &f ) ) {
    f.close();
    return;
  }
  f.close();

  e = doc.documentElement();
  QDomNode node = e.firstChild();
  while ( !node.isNull() ) {
    if ( !node.isElement() )
      break;
    e = node.toElement();
    Attr attr;
    attr.fromXML( e );
    vec.push_back( attr );
    node = node.nextSibling();
  }
}


std::string GLIMSGlobals::getIDOf (const std::vector<Attr> glacierAttribute, const std::string attributeValue) {
  for ( unsigned int i = 0 ; i < glacierAttribute.size() ; i++ ) {
    if ( attributeValue == glacierAttribute[i].value ) {
      return glacierAttribute[i].id ;
    }
  }
  return "" ;
}

int GLIMSGlobals::getIntIDOf (const std::vector<Attr> glacierAttribute, const std::string attributeValue) {
  // get the ID of an attribute with value attributeValue
  std::string attIDstr = getIDOf (glacierAttribute, attributeValue) ;
  if ( attIDstr.length() == 0 || attIDstr == "-999" /* nul */ ) {
    return -1 ;
  }

  // put the ID in a stringstream so it can be manipulated
  std::stringstream attIDstrstream ;
  attIDstrstream << attIDstr ;

  // read the ID out of the stringstream into an integer and return
  int attIDint = 0 ;
  attIDstrstream >> attIDint ;
  return attIDint ;
}

// get the index where this value is stored in the vector
int GLIMSGlobals::getNdxOfValue (const std::vector<Attr> glacierAttribute, const std::string attributeValue) {
  unsigned int index = 0 ;
  for (  ; index < glacierAttribute.size() ; index++ ) {
    if ( attributeValue == glacierAttribute[index].value ) {
      return index ;
    }
  }
  return 0 ;
}

int GLIMSGlobals::getNdxOfID (const std::vector<Attr> glacierAttribute, const int attributeID) {
  std::stringstream attributeIDStrstream ;
  attributeIDStrstream << attributeID ;
  std::string attributeIDStr = attributeIDStrstream.str() ;

  unsigned int index = 0 ;
  for ( ; index < glacierAttribute.size() ; index++ ) {
    if ( attributeIDStr == glacierAttribute[index].id ) {
      return index ;
    }
  }
  return 0 ;
}

int GLIMSGlobals::getNdxOfID (const std::vector<Attr> glacierAttribute, const std::string attributeID) {
  unsigned int index = 0 ;
  for ( ; index < glacierAttribute.size() ; index++ ) {
    if ( attributeID == glacierAttribute[index].id ) {
      return index ;
    }
  }
  return 0 ;
}

---

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