GLIMSView Source Code Documentation

linedef.h

Go to the documentation of this file.

#ifndef __LINEDEF_H
#define __LINEDEF_H

#include "xmlserializeable.h"
#include "ValidationReport.h"

class LineDef : public XMLSerializeable {
public:
  int     mGlacType;             // GLACIER TYPE
  int     mType;                 // SEGMENT TYPE
  int     mLabel;                // SEGMENT LABEL
  int     mLMat, mRMat;          // LEFT/RIGHT MATERIAL
  float   mLXUncert, mLYUncert;  // LOCAL X/Y UNCERTAINTY
  float   mGXUncert, mGYUncert;  // GLOBAL X/Y UNCERTAINTY
  int     mLFeature, mRFeature;  // LEFT/RIGHT FEATURE
  int     mColor;                // LINE COLOR
  int     mStyle;                // LINE STYLE
  int     mWidth;                // LINE WIDTH
  char*   mName;                 // LINE NAME

  LineDef( ) {
    mGlacType = 0;
    mType     = 0;
    mLabel    = 0;
    mLMat     = 0;
    mRMat     = 0;
    mLXUncert = -999.0f;
    mLYUncert = -999.0f;
    mGXUncert = -999.0f;
    mGYUncert = -999.0f;
    mLFeature = 0;
    mRFeature = 0;
    mColor    = 0;
    mStyle    = 0;
    mWidth    = 0;
    mName     = "";
  }

  virtual bool fromXML( QDomElement &elem ) {
    if ( std::string( "LineDefinition" ).compare( (const char*)elem.tagName() ) )
      return false;

    mGlacType = readIntTag( elem, "GlacType" );
    mType =     readIntTag( elem, "Type" );
    mLabel =    readIntTag( elem, "Label" );
    mLMat =     readIntTag( elem, "LMat" );
    mRMat =     readIntTag( elem, "RMat" );
    mLXUncert = readDoubleTag( elem, "LXUncert" );
    mLYUncert = readDoubleTag( elem, "LYUncert" );
    mGXUncert = readDoubleTag( elem, "GXUncert" );
    mGXUncert = readDoubleTag( elem, "GYUncert" );
    mLFeature = readIntTag( elem, "LFeature" );
    mRFeature = readIntTag( elem, "RFeature" );
    mColor =    readIntTag( elem, "Color" );
    mStyle =    readIntTag( elem, "Style" );
    mWidth =    readIntTag( elem, "Width" );
    mName = (char*)readTextTag(elem, "Name" ).c_str();

    return true;
  }

  virtual bool toXML( QDomDocument &doc,
                      QDomElement &elem,
                      std::string id = "" ) {
    QDomElement base = doc.createElement( "LineDefinition" );
    if ( id != "" )
      base.setAttribute( "id", (char*)id.c_str() );
    elem.appendChild( base );

    writeIntTag( doc, base, "GlacType", mGlacType );
    writeIntTag( doc, base, "Type", mType );
    writeIntTag( doc, base, "Label", mLabel );
    writeIntTag( doc, base, "LMat", mLMat );
    writeIntTag( doc, base, "RMat", mRMat );
    writeDoubleTag( doc, base, "LXUncert", mLXUncert );
    writeDoubleTag( doc, base, "LYUncert", mLYUncert );
    writeDoubleTag( doc, base, "GXUncert", mGXUncert );
    writeDoubleTag( doc, base, "GYUncert", mGYUncert );
    writeIntTag( doc, base, "LFeature", mLFeature );
    writeIntTag( doc, base, "RFeature", mRFeature );
    writeIntTag( doc, base, "Color", mColor );
    writeIntTag( doc, base, "Style", mStyle );
    writeIntTag( doc, base, "Width", mWidth );
    writeTextTag( doc, base, "Name", mName ); // dls 5/20/04 - was set to GlacType instead of Name

    return true;
  }

  bool operator==( LineDef &ldf ) {

    if ( ldf.mGlacType == mGlacType &&
         ldf.mGXUncert == mGXUncert &&
         ldf.mGYUncert == mGYUncert &&
         ldf.mLabel == mLabel &&
         ldf.mLFeature == mLFeature &&
         ldf.mLMat == mLMat &&
         ldf.mLXUncert == mLXUncert &&
         ldf.mLYUncert == mLYUncert &&
         ldf.mName == mName &&
         ldf.mRFeature == mRFeature &&
         ldf.mRMat == mRMat &&
         ldf.mType == mType )
      return true;
    return false;
  }

  bool operator!=( LineDef &ldf ) {
    return !(*this == ldf);
  }



  bool validate (ValidationReport * valRep) {
    bool dataValid = true ;
    std::stringstream rptstream ;


    // Glacier type
    if ( mGlacType < 0 ) {
      valRep->reportError( "Glacier type is invalid." ) ;
      dataValid = false ;
    }

    // Segment type
    if ( mType < 0 ) {
      valRep->reportError( "Segment type is not defined." ) ;
      dataValid = false ;
    }

    // Segment label
    if ( !mLabel ) {
      valRep->reportWarning( "Segment label is not defined." ) ;
    }

    // Local X uncertainty
    if ( mLXUncert == -999.0 ) {
      valRep->reportWarning( "Local X uncertainty is not defined. This attribute is required." ) ;
    }

    // Local Y uncertainty
    if ( mLYUncert == -999.0 ) {
      valRep->reportWarning( "Local Y uncertainty is not defined. This attribute is required." ) ;
    }

    // Global X uncertainty
    if ( mGXUncert == -999.0 ) {
      valRep->reportWarning( "Global X uncertainty is not defined. This attribute is required." ) ;
    }

    // Global Y uncertainty
    if ( mGYUncert == -999.0 ) {
      valRep->reportWarning( "Global Y uncertainty is not defined. This attribute is required." ) ;
    }

    // Left material
    if ( !mLMat ) {
      valRep->reportWarning( "Left material is set to NULL." ) ;
    }

    // Right material
    if ( !mRMat ) {
      valRep->reportWarning( "Right material is set to NULL." ) ;
    }

    // Left feature
    if ( !mLFeature ) {
      valRep->reportWarning( "Left feature is set to NULL." ) ;
    }

    // Right feature
    if ( !mRFeature ) {
      valRep->reportWarning( "Right feature is set to NULL." ) ;
    }

    /* 
    // Definition name
    if ( !mName || mName[0] == '\0') {
      valRep->reportWarning( "Definition name is not defined." ) ;
    }
    */

/*    
    // end line definition check 
    if (dataValid) {
      rptstream << "Line definition is valid." ;
      valRep->subsectionEnd( rptstream.str()  ) ;
    }
    else {
      rptstream << "Line definition has missing or invalid information." ;
      valRep->subsectionEnd( rptstream.str()  ) ;
    }
*/

    // return status of check
    return dataValid ;
  }


};

#endif

---

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