GLIMSView Source Code Documentation

glimslinedata.cpp

Go to the documentation of this file.

#include "glimslinedata.h"
#include "TraceLog.h"


GLIMSLineData::GLIMSLineData( ) :
mDefGID( -1 ),
mDefLDF( -1 ) {

}

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

  mLDFSet.toXML( doc, base );
  for ( unsigned int iline=0; iline < mLLSet.size(); iline++ ) {
    GlacierLine &gline =
    dynamic_cast<GlacierLine&>( *mLLSet[iline] );
    gline.toXML( doc, base );
  }
  return true;
}

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

  QDomNode node = elem.firstChild();
  if ( !node.isElement() )
    return false;
  QDomElement e = node.toElement();
  if ( !mLDFSet.fromXML( e ) )
    return false;

  node = e.nextSibling();
  while ( !node.isNull() ) {
    if ( !node.isElement() )
      return false;
    e = node.toElement();
    GlacierLine *llline, *xyline;
    llline = new GlacierLine;
    xyline = new GlacierLine;
    if ( !llline->fromXML( e ) )
      return false;

    if ( llline->mLDF != -1 ) {
      DspAttr &attr = llline->mAttr;
      attr.color = GLIMSGlobals::AVAILCOLORS[ mLDFSet[llline->mLDF].mColor ];
      attr.style = (Qt::PenStyle)mLDFSet[llline->mLDF].mStyle;
      attr.width = mLDFSet[llline->mLDF].mWidth;
    }

    *xyline = *llline;
    mLLSet.push_back( llline );
    mXYSet.push_back( xyline );
    node = node.nextSibling();
  }

  transformDataset();
  emit datasetChanged();
  return true;
}

void GLIMSLineData::addLine( Node &xynode ) {
  // basic shape attributes
  DspAttr attr;

  //
  GlacierLine *llline = new GlacierLine( mDefGID, mDefLDF );
  GlacierLine *xyline = new GlacierLine( mDefGID, mDefLDF );

  Node llnode = xynode;

  mImg->getLL( llnode.x, llnode.y );
  llline->nodeset().push_back( llnode );
  xyline->nodeset().push_back( xynode );

  if ( mDefLDF != -1 ) {
    LineDef &ldf = mLDFSet[mDefLDF];
    attr.color = GLIMSGlobals::AVAILCOLORS[ldf.mColor];
    attr.style = (Qt::PenStyle)ldf.mStyle;
    attr.width = ldf.mWidth;
  }
  xyline->setAttr( attr );
  mXYSet.push_back( xyline );
  mLLSet.push_back( llline );

  // push history information onto history stack
  mUndoSel.push( mSelSet );
  mHistory.push(*xyline, mXYSet.size() - 1, -1, addedLine) ;
  mRedoHistory.clear() ;

  emit datasetChanged();
}


void GLIMSLineData::restoreLine( GlacierLine &line, int iline )  {
  GlacierLine * newXYLine = new GlacierLine ;
  GlacierLine * newLLLine = new GlacierLine ;
  *newXYLine = line ;
  *newLLLine = line ;

  int numNodes = (int)(newLLLine->size()) ;
  for (int nodeNdx = 0 ; nodeNdx < numNodes ; nodeNdx++) {
    mImg->getLL((*newLLLine)[nodeNdx].x, (*newLLLine)[nodeNdx].y) ;
  }

  if ( iline < 0 || iline >= (int)mXYSet.size() ) {
    mXYSet.push_back( newXYLine );
    mLLSet.push_back( newLLLine );
    iline = (int)mXYSet.size() - 1 ;
  }
  else {
    mXYSet.insert( mXYSet.begin() + iline, newXYLine );
    mLLSet.insert( mLLSet.begin() + iline, newLLLine );
//    mXYSet.push_back( newXYLine );
//    mLLSet.push_back( newLLLine );
//    iline = (int)mXYSet.size() - 1 ;
  }
  emit datasetChanged();
}



void GLIMSLineData::delLine( int iline ) {
  if ( iline < 0 || iline >= (int)mXYSet.size() ) return;

  GlacierLine * deleteLine = new GlacierLine ;
  (*deleteLine) = (*(GlacierLine*)(mXYSet[iline])) ;

  mUndoSel.push( mSelSet );
  mHistory.push(*deleteLine, iline, -1, deletedLine) ;
  mRedoHistory.clear() ;

  mXYSet.erase( mXYSet.begin() + iline );
  mLLSet.erase( mLLSet.begin() + iline );
}

void GLIMSLineData::removeLine( int iline ) {

  if ( iline < 0 || iline >= (int)mXYSet.size() ) return;
  mXYSet.erase( mXYSet.begin() + iline );
  mLLSet.erase( mLLSet.begin() + iline );
}


void GLIMSLineData::breakLine( int iline, int inode ) {
  int i;
  int nnodes;
  GlacierLine *l1, *l2;

  // get the line to be broken
  Shape &xys = *mXYSet[iline];
  Shape &lls = *mLLSet[iline];
  GlacierLine &xyline = dynamic_cast<GlacierLine&>( xys );
  GlacierLine &llline = dynamic_cast<GlacierLine&>( lls );

  nnodes = (int)xyline.size();
  if ( inode <= 0 || inode >= nnodes-1 )
    return;


  // push information about the old line onto the history stack
  mUndoSel.push( mSelSet );
  mHistory.push(xyline, iline, inode,         brokeLine) ;
  mRedoHistory.clear() ;

  // create a new line (l1=XY and l2=lat-lon) with basic attribs of the
  // one being broken
  l1 = new GlacierLine( xyline.mGID, xyline.mLDF );
  l2 = new GlacierLine( xyline.mGID, xyline.mLDF );

  // fill the line with copies of the nodes starting where the
  // line is being broken and going to the end
  for ( i=inode; i < nnodes; i++ ) {
    l1->nodeset().push_back( xyline[i] );
    l2->nodeset().push_back( llline[i] );
  }

  // delete the nodes from the original line
  // that were copied into the new line above
  for ( i=nnodes-1; i > inode; i-- ) {
    xyline.delNode( i );
    llline.delNode( i );
  }

  // store the new line
  mXYSet.push_back(l1) ;
  mLLSet.push_back(l2) ;

  // push information about the new line onto the history stack
  mHistory.push(*l1,    mXYSet.size() - 1, 0, brokeLine) ;
  mRedoHistory.clear() ;

  emit datasetChanged();
  return;
}

// put a joined line back to the original two separate lines
void GLIMSLineData::restoreJoinedLines(GlacierLine &line1, int iline1,
                                       GlacierLine &line2, int iline2,
                                       GlacierLineHistoryElement * h1,
                                       GlacierLineHistoryElement * h2) {

  unsigned int i;                // handy counter
  //int nnodes;           // number of nodes

  // get the line from data set that was the product of the join
  Shape &xys = *mXYSet[iline1];
  Shape &lls = *mLLSet[iline1];
  GlacierLine &xyline = dynamic_cast<GlacierLine&>( xys );
  GlacierLine &llline = dynamic_cast<GlacierLine&>( lls );


  // update history
  GlacierLine * storeLine = new GlacierLine ;
  (*storeLine) = xyline ;
  h1->setShape(storeLine) ;

  // clear the line contents
  xyline.nodeset().clear() ;
  llline.nodeset().clear() ;

  // revert the line to its original state (stored in
  // history before the join and passed in as param line1)
  xyline = line1 ;
  llline = xyline ;
  for (i = 0 ; i < llline.size() ; i++) {
    mImg->getLL(llline[i].x, llline[i].y) ;
  }


  // allocate a new line to recreate the second line
  // of the join into
  GlacierLine * l2xy = new GlacierLine ;
  GlacierLine * l2ll = new GlacierLine ;

  // copy the original state of the second line (stored in
  // history before the join and passed in as param line2)
  // into the new line
  (*l2xy) = line2 ;
  (*l2ll) = (*l2xy) ;

  // update history
  h2->setShape(l2xy) ;

  // set the lat/lon information for the line
  for (i = 0 ; i < (*l2ll).size() ; i++) {
    mImg->getLL(((*l2ll)[i]).x, ((*l2ll)[i]).y) ;
  }

  // store the new line in the line dataset
  mXYSet.insert((mXYSet.begin() + iline2), l2xy) ;
  mLLSet.insert((mLLSet.begin() + iline2), l2ll) ;

  emit datasetChanged();
  return;
}

void GLIMSLineData::joinLine( int il1,
                              int il2,
                              int in1,
                              int in2 ) {

  // get the two lines to be joined
  Shape &xys1 = *mXYSet[il1];
  Shape &xys2 = *mXYSet[il2];
  Shape &lls1 = *mLLSet[il1];
  Shape &lls2 = *mLLSet[il2];

  GlacierLine &xyl1 = dynamic_cast<GlacierLine&>( xys1 );
  GlacierLine &xyl2 = dynamic_cast<GlacierLine&>( xys2 );
  GlacierLine &lll1 = dynamic_cast<GlacierLine&>( lls1 );
  GlacierLine &lll2 = dynamic_cast<GlacierLine&>( lls2 );

  // push history onto stack
  mUndoSel.push( mSelSet );
  mHistory.push(xyl1, il1, in1, joinedLines) ;
  mHistory.push(xyl2, il2, in2, joinedLines) ;
  mRedoHistory.clear() ;


  // check to see if the nodes are at the ends of the lines
  if ( !(in1 == 0 || in1 == (int)xyl1.size()-1) ||
       !(in2 == 0 || in2 == (int)xyl2.size()-1) )
    return;

  // if the node in line 1 to be joined is at the beginning of the line,
  // reverse the node order so it's at the end
  if ( in1 == 0 ) {
    std::reverse( xyl1.nodeset().begin(), xyl1.nodeset().end() );
    std::reverse( lll1.nodeset().begin(), lll1.nodeset().end() );
  }

  // if the node in line 2 to be joined is at the end of the line,
  // reverse the node order so it's at the beginning
  if ( in2 != 0 ) {
    std::reverse( xyl2.nodeset().begin(), xyl2.nodeset().end() );
    std::reverse( lll2.nodeset().begin(), lll2.nodeset().end() );
  }

  // put the nodes in line 2 to line 1
  for ( int inode=0; inode < (int)xyl2.size(); inode++ ) {
    xyl1.nodeset().push_back( xyl2[inode] );
    lll1.nodeset().push_back( lll2[inode] );
  }
  removeLine (il2) ;

  emit datasetChanged();
  return;
}

void GLIMSLineData::rejoinLine( GlacierLine & originalLine,
                                int il1,
                                int il2,
                                GlacierLineHistoryElement * h1,
                                GlacierLineHistoryElement * h2) {

  // get line from dataset
  Shape &xys = *mXYSet[il1];
  Shape &lls = *mLLSet[il1];

  GlacierLine &xyl = dynamic_cast<GlacierLine&>( xys );
  GlacierLine &lll = dynamic_cast<GlacierLine&>( lls );

  // update history
  GlacierLine * storeLine = new GlacierLine ;
  (*storeLine) = xyl ;
  h1->setShape(storeLine) ;

  // empty out the line
  xyl.nodeset().clear() ;
  lll.nodeset().clear() ;

  // restore stored line to active dataset
  xyl = originalLine ;
  lll = xyl ;

  // recalc the lat-lon info
  for (unsigned int i = 0 ; i < lll.size() ; i++) {
    mImg->getLL(lll[i].x, lll[i].y) ;
  }

  // update history
  // get second line from dataset
  Shape &xys2 = *mXYSet[il2];
  GlacierLine &xyl2 = dynamic_cast<GlacierLine&>( xys2 );
  h2->setShape(&xyl2) ;

  // remove extra line
  removeLine (il2) ;

  emit datasetChanged();
  return;
}

void GLIMSLineData::addLineNode( Node &node,
                                 int iline,
                                 int inode ) {
  if ( iline == -1 )
    return;

  if ( inode == -1 )
    insertLineNode( node, iline );
  else
    insertLineNode( node, iline, inode+1 );
  emit datasetChanged();

}

void GLIMSLineData::restoreLineNode( Node &node,
                                     int iline,
                                     int inode ) {

  if ( iline == -1 )
    return;

  if ( inode == -1 )
    reinsertLineNode( node, iline );
  else
    reinsertLineNode( node, iline, inode );

  emit datasetChanged();
}

void GLIMSLineData::delLineNode( int iline, int inode ) {

  Shape &xys = *mXYSet[iline];
  Shape &lls = *mLLSet[iline];
  Line &xyline = dynamic_cast<Line&>( xys );
  Line &llline = dynamic_cast<Line&>( lls );
  if ( xyline.size() <= 1 ) {
    delLine( iline );
  }
  else {
    Node saveNode = xyline[inode] ;
    // dls
    mUndoSel.push( mSelSet );
    mHistory.push(saveNode, iline, inode, deletedNode) ;
    mRedoHistory.clear() ;

    xyline.delNode( inode );
    llline.delNode( inode );
  }
  emit datasetChanged();
}

void GLIMSLineData::removeLineNode( int iline, int inode ) {

  Shape &xys = *mXYSet[iline];
  Shape &lls = *mLLSet[iline];
  Line &xyline = dynamic_cast<Line&>( xys );
  Line &llline = dynamic_cast<Line&>( lls );
  if ( xyline.size() <= 1 ) {
    // use non-history version of delete line
    removeLine( iline );
  }
  else {
    xyline.delNode( inode );
    llline.delNode( inode );
  }
  emit datasetChanged();
}

void GLIMSLineData::moveLineNode( int iline,
                                  int inode,
                                  Node &xynode ) {
  Node llnode = xynode;
  mImg->getLL( llnode.x, llnode.y );
  Shape &xys = *mXYSet[iline];
  Shape &lls = *mLLSet[iline];
  Line &xyline = dynamic_cast<Line&>( xys );
  Line &llline = dynamic_cast<Line&>( lls );

  startMoveLineNode (iline, inode, xyline[inode]) ;

  xyline[inode] = xynode;
  llline[inode] = llnode;

  emit datasetChanged();
}


void GLIMSLineData::startMoveLineNode( int   iline,
                                       int   inode,
                                       Node &xynode ) {

  // make sure the node hasn't already been moving
  // kluge - see todo lists for this class
  GlacierLineHistoryElement * lastaction = mHistory.peek() ;
  bool moving = false ;
  if ( lastaction != NULL                      &&
       lastaction->getAction()    == movedNode &&
       lastaction->getLineIndex() == iline     &&
       lastaction->getNodeIndex() == inode        ) {
    moving = true ;
  }

  if (!moving) {
    // push history information onto history stack
    Shape &xys = *mXYSet[iline] ;
    Line &xyline = dynamic_cast<Line&>( xys );
    Node saveNode = xyline[inode] ;

    mUndoSel.push( mSelSet );
    mHistory.push(saveNode, iline, inode, movedNode) ;
    mRedoHistory.clear() ;
  }

  // KLUGE ignore this - it's just to shut the compiler up
  double kluge = xynode.x ;
  kluge = kluge + 1.0 ;
}

void GLIMSLineData::restoreMovedLineNode( int  iline,
                                          int  inode,
                                          Node &xynode ) {
  Node llnode = xynode;
  mImg->getLL( llnode.x, llnode.y );
  Shape &xys = *mXYSet[iline];
  Shape &lls = *mLLSet[iline];
  Line &xyline = dynamic_cast<Line&>( xys );
  Line &llline = dynamic_cast<Line&>( lls );

  xyline[inode] = xynode;
  llline[inode] = llnode;
  emit datasetChanged();
}

void GLIMSLineData::insertLineNode( Node &node,
                                    int iline,
                                    int inode ) {

  std::vector<Node>::iterator itll, itxy;
  if ( iline == -1 )
    return;


  Shape &lls = *mLLSet[iline];
  Shape &xys = *mXYSet[iline];
  Line &llline = dynamic_cast<Line&>( lls );
  Line &xyline = dynamic_cast<Line&>( xys );

  if ( inode == -1 ) {
    itxy = xyline.nodeset().end();
    itll = llline.nodeset().end();
  }
  else {
    itxy = (xyline.nodeset().begin()+inode);
    itll = (llline.nodeset().begin()+inode);
  }

  Node llnode = node;

  mImg->getLL( llnode.x, llnode.y );

  xyline.nodeset().insert( itxy, node );
  llline.nodeset().insert( itll, llnode );

  // push history information onto history stack
  Node saveNode = node ;
  mUndoSel.push( mSelSet );
  mHistory.push(saveNode, iline, inode, insertedNode) ;
  mRedoHistory.clear() ;

  emit datasetChanged();
}

void GLIMSLineData::reinsertLineNode( Node &node,
                                      int iline,
                                      int inode ) {

  std::vector<Node>::iterator itll, itxy;
  if ( iline == -1 )
    return;

  Shape &lls = *mLLSet[iline];
  Shape &xys = *mXYSet[iline];
  Line &llline = dynamic_cast<Line&>( lls );
  Line &xyline = dynamic_cast<Line&>( xys );

  if ( inode == -1 ) {
    itxy = xyline.nodeset().end();
    itll = llline.nodeset().end();
  }
  else if (inode == 0) {
    itxy = (xyline.nodeset().begin());
    itll = (llline.nodeset().begin());
  }
  else {
    // 1 is added to inode to convert from array counting (0,1,2..n)
    // to iterator counting (1,2,3..n)
    itxy = (xyline.nodeset().begin() + inode);
    itll = (llline.nodeset().begin() + inode);
  }

  Node llnode = node;
  mImg->getLL( llnode.x, llnode.y );
  xyline.nodeset().insert( itxy, node );
  llline.nodeset().insert( itll, llnode );
  emit datasetChanged();
}



GlacierLine* GLIMSLineData::toXY( GlacierLine *gl ) {
  if ( gl == NULL )
    return NULL;

  GlacierLine &llline = *gl;
  GlacierLine *gline = new GlacierLine( llline.mGID, llline.mLDF );
  DspAttr &attr = gline->getAttr();
  for ( unsigned int inode=0; inode < llline.size(); inode++ ) {
    Node xynode = llline[inode];
    mImg->getXY( xynode.x, xynode.y );
    gline->nodeset().push_back( xynode );
  }
  LineDef &ldf = mLDFSet[ llline.mLDF ];
  attr.color = GLIMSGlobals::AVAILCOLORS[ ldf.mColor ];
  attr.style = (Qt::PenStyle)ldf.mStyle;
  attr.width = ldf.mWidth;
  return gline;
}

void GLIMSLineData::pop( ) {
  // pop from the history and push onto the redo stack
  pop (&mHistory, &mRedoHistory, &mUndoSel, &mRedoSel) ;
}

void GLIMSLineData::redo( ) {
  // pop from the redo stack and push onto the history stack
  pop (&mRedoHistory, &mHistory, &mRedoSel, &mUndoSel) ;
}

void GLIMSLineData::pop( GlacierLineHistory       * historyUndo, GlacierLineHistory       * historyRedo,
                         std::stack<SelectionSet> * selSetUndo,  std::stack<SelectionSet> * selSetRedo) {

  if (historyUndo->size() == 0 ) {
    return ;
  }
  GlacierLineHistoryElement * lastAction = historyUndo->pop() ;

  if (lastAction != NULL) {
    switch (lastAction->getAction()) {
      case (deletedNode):

        if (lastAction->getShape() != NULL) {
          // get a copy of the node that was deleted
          Node addBackNode = *((Node*)lastAction->getShape()) ;
          // get information about where to restore the node to
          int lndx = lastAction->getLineIndex() ; // line index - line this node belonged to
          int nndx = lastAction->getNodeIndex() ; // node index - what position this node
                                                  // was in before it was deleted

          // restore the node to its original position in the line
          restoreLineNode (addBackNode, lndx, nndx) ;
          lastAction->setAction(addedNode) ;
          historyRedo->push(lastAction) ;
        }
        break ;

      case (deletedLine):

        if (lastAction->getShape() != NULL) {
          // get a copy of the line that was deleted
          GlacierLine addBackLine = *((GlacierLine*)lastAction->getShape()) ;
          // get information about where to restore the line to
          int lndx = lastAction->getLineIndex() ; // line index - the original position of
                                                  // the line in the line set before deletion

          // restore the line to its original position in the line set
          restoreLine (addBackLine, lndx) ;
          lastAction->setAction(addedLine) ;
          historyRedo->push(lastAction) ;
        }
        break ;

      case (addedNode):
      case (insertedNode):

        if (lastAction->getShape() != NULL) {
          // get information about where to remove the node from
          int lndx = lastAction->getLineIndex() ; // line index - the original position of
                                                  // the line in the line set the node was added to
          int nndx = lastAction->getNodeIndex() ; // node index - what position this node
                                                  // was in after it was added

          // restore the line to its original position in the line set
          removeLineNode(lndx, nndx) ;
          lastAction->setAction(deletedNode) ;
          historyRedo->push(lastAction) ;
        }
        break ;

      case (addedLine):

        if (lastAction->getShape() != NULL) {
          // get information about where to remove the line from
          int lndx = lastAction->getLineIndex() ; // line index - the original position of
                                                  // the line in the line set when it was added

          // restore the line to its original position in the line set
          removeLine(lndx) ;
          lastAction->setAction(deletedLine) ;
          historyRedo->push(lastAction) ;
        }
        break ;

      case (movedNode):
        if (lastAction->getShape() != NULL) {
          // get a copy of the node before it was moved
          Node originalNode = *((Node*)lastAction->getShape()) ;
          // get information about what node to move back to its original position
          int lndx = lastAction->getLineIndex() ; // line index - the index of the line
                                                  // in the line set with the moved node
          int nndx = lastAction->getNodeIndex() ; // node index - the position of the moved
                                                  // node in the line


          // extract the affected node so its current state
          // can be stored in the history
          lastAction->setShape( &((*((GlacierLine*)(mXYSet[lndx])))[nndx]) ) ;
          // restore the line to its original position relative to the image
          restoreMovedLineNode(lndx, nndx, originalNode) ;
          // push history element to the other history stack
          historyRedo->push(lastAction) ;
        }
        break ;

      case (brokeLine):
        if (mHistory.size() == 0) {
          return ;
        }
        if (lastAction->getShape() != NULL) {
          // get information about the other half of the broken line
          GlacierLineHistoryElement * lastAction2 = historyUndo->peek() ;

          if (lastAction2->getAction() == brokeLine) {
            historyUndo->pop() ;
            lastAction->setAction(joinedLines) ;
            lastAction2->setAction(joinedLines) ;
            historyRedo->push(lastAction2) ;
            historyRedo->push(lastAction) ;

            // the first line is the new line created from the broken original
            // get information about what lines and nodes use to mend broken line
            int lndx1 = lastAction->getLineIndex() ; // line 1 index
            //int nndx1 = lastAction->getNodeIndex() ; // node index where line was broken

            // the second line is the original line
            int lndx2 = lastAction2->getLineIndex() ; // line 2 index
            //int nndx2 = lastAction2->getNodeIndex() ; // node index where line was broken
            GlacierLine originalLine = *((GlacierLine*)lastAction2->getShape()) ; //original line stored in history

            // join the two lines back to the original single line
            rejoinLine(originalLine, lndx2, lndx1, lastAction2, lastAction) ;

          }
          else {
            historyRedo->push(lastAction) ;
          }
        }
        break ;

      case (joinedLines):
        if (mHistory.size() == 0) {
          return ;
        }

        if (lastAction->getShape() != NULL) {

          // get information about the other original line
          GlacierLineHistoryElement * lastAction2 = historyUndo->peek() ;

          if (lastAction2->getAction() == joinedLines) {

            // remove the second part of this history from the stack
            historyUndo->pop() ;
            lastAction->setAction(brokeLine) ;
            lastAction2->setAction(brokeLine) ;
            // push the history elements in reverse order onto the other
            // stack so they maintain their relative order
            historyRedo->push(lastAction2) ;
            historyRedo->push(lastAction) ;

            // get a copy of the original line
            GlacierLine restoreLine1 = *((GlacierLine*)lastAction->getShape()) ;
            // get information about what lines and nodes use to break a pair of joined lines
            int lndx1 = lastAction->getLineIndex() ; // line 1 index

            // get a copy of the original line
            GlacierLine restoreLine2 = *((GlacierLine*)lastAction2->getShape()) ;
            // get information about what lines and nodes use to break a pair of joined lines
            int lndx2 = lastAction2->getLineIndex() ; // line 1 index

            // restore the lines back to their original separation
            restoreJoinedLines(restoreLine2, lndx2, restoreLine1, lndx1, lastAction2, lastAction) ;

          }
          else {
            historyRedo->push(lastAction) ;
          }
        }
        break ;

      case (selection):
        historyRedo->push(lastAction) ;
        break ;

      default :
        historyRedo->push(lastAction) ;
        break ;
    } // end switch on action
  } // end if lastAction != NULL

  // restore previous selection of nodes/lines onscreen from
  // selection set undo history
  if ( selSetUndo->size() > 0 ) {
    mSelSet.clear();
    mSelSet = selSetUndo->top();
    selSetRedo->push(mSelSet);
    selSetUndo->pop();
  }
}

void GLIMSLineData::push( ) {
  // save undo information for current selection of nodes/lines onscreen
  //  mUndoSel.push( mSelSet );
  emit datasetChanged();
}

void GLIMSLineData::pushSelection( ) {
  mUndoSel.push( mSelSet );
  Node saveNode ;
  mHistory.push(saveNode, -1, -1, selection) ;
  mRedoHistory.clear() ;
}


void GLIMSLineData::setLDF( int iline, int ildf ) {
  if ( iline < 0 || iline >= (int)mXYSet.size() ||
       ildf < 0 || ildf >= (int)mLDFSet.size() )
    return;

  Shape &xys = *mXYSet[iline];
  Shape &lls = *mLLSet[iline];
  GlacierLine &xyline = dynamic_cast<GlacierLine&>( xys );
  GlacierLine &llline = dynamic_cast<GlacierLine&>( lls );
  xyline.mLDF = ildf;
  llline.mLDF = ildf;
  DspAttr &attr = xyline.getAttr();
  attr.color = GLIMSGlobals::AVAILCOLORS[ mLDFSet[ildf].mColor ];
  attr.style = (Qt::PenStyle)mLDFSet[ildf].mStyle;
  attr.width = mLDFSet[ildf].mWidth;
  emit datasetChanged();
}

void GLIMSLineData::setGID( int iline, int igid ) {
  if ( iline < 0 || iline >= (int)mXYSet.size() )
    return;

  // get the Shape at index iline
  Shape &xys = *mXYSet[iline];
  Shape &lls = *mLLSet[iline];

  // cast the Shape to a GlacierLine
  GlacierLine &xyline = dynamic_cast<GlacierLine&>( xys );
  GlacierLine &llline = dynamic_cast<GlacierLine&>( lls );

  // assign the GID (igid) to the line
  xyline.mGID = igid;
  llline.mGID = igid;

  // announce a change
  emit datasetChanged();
}

void GLIMSLineData::addLineSetLL( std::vector<GlacierLine> &glset ) {
  GlacierLine *newXYLine;
  GlacierLine *newLLLine;

  push();
  for ( int iline=0; iline < (int)glset.size(); iline++ ) {
    newXYLine = new GlacierLine;
    newLLLine = new GlacierLine;
    *newXYLine = glset[iline];
    *newLLLine = glset[iline];

    /*
    std::vector<Node> &ns = glset[iline].nodeset();
    for( int in=0; in < (int)ns.size(); in++ )
    {
        Node *n = new Node;
        *n = ns[in];
        newLine->nodeset().push_back( *n );
        delete n;
    }
    */

    mXYSet.push_back( newXYLine );
    mLLSet.push_back( newLLLine );
  }
  transformDataset();
}

bool GLIMSLineData::validate (ValidationReport * valRep) {
  bool dataValid = true ;
  mSelSet.clear() ;
  std::stringstream rptstream ;
  valRep->breakBegin( "Line data check..." ) ;


  // Only run line checks if there are lines to check
  if ( !mLLSet.size() ) {
    valRep->reportWarning("No lines have been created!") ;
    valRep->breakEnd( "CHECK COMPLETE: There are no lines to check." ) ;
  }
  else {
    unsigned int iline = 0 ; 

    // ------------------------------------------------------
    // Check that each line is long enough
    // ------------------------------------------------------
    valRep->subsectionBegin("Checking line vertex count.") ;
    for ( iline = 0 ; iline < mLLSet.size() ; iline++ ) {
      // get the line to check
      GlacierLine &llline = dynamic_cast<GlacierLine&>( *mLLSet[iline] );

      int lineVerts = llline.nodeset().size() ;
      // if line isn't long enough
      if ( lineVerts < 4 ) {
        dataValid = false ;
        SelectionSet::SelObj selobj ;
        selobj.obj = iline ;
        mSelSet.add( selobj ) ; 

        rptstream << "Line " << iline << " does not have enough vertices (total count of " << lineVerts << ")." << endl ;
        valRep->reportError( rptstream.str() ) ;
        rptstream.str("") ;
      }
    }
    valRep->subsectionEnd("Line vertex count finished.") ;

    // ------------------------------------------------------
    // Check that each line has an associated glacier ID
    // ------------------------------------------------------
    valRep->subsectionBegin("Checking for associated glacier IDs") ;
    for ( iline = 0 ; iline < mLLSet.size() ; iline++ ) {
      // get the line to check
      GlacierLine &llline = dynamic_cast<GlacierLine&>( *mLLSet[iline] );

      // if line doesn't have a GID, add to selection
      if ( llline.mGID < 0 ) {
        dataValid = false ;
        SelectionSet::SelObj selobj ;
        selobj.obj = iline ;
        mSelSet.add( selobj ) ;

        rptstream << "Line " << iline << " has no associated glacier ID" << endl ;
        valRep->reportError( rptstream.str() ) ;
        rptstream.str("") ;
      }
    }
    rptstream.str ("") ;
    valRep->subsectionEnd("Associated glacier ID check finished.") ;

    // ------------------------------------------------------
    // Check that each line has an associated line definition
    // ------------------------------------------------------
    valRep->subsectionBegin("Checking for associated line definitions") ;
    for ( iline = 0 ; iline < mLLSet.size() ; iline++ ) {
      // get the line to check
      GlacierLine &llline = dynamic_cast<GlacierLine&>( *mLLSet[iline] );

      // if line doesn't have a GID, add to selection
      if ( llline.mLDF < 0 ) {
        dataValid = false ;
        SelectionSet::SelObj selobj ;
        selobj.obj = iline ;
        mSelSet.add( selobj ) ; 

        rptstream << "Line " << iline << " has no associated line definition" << endl ;
        valRep->reportError( rptstream.str() ) ;
        rptstream.str("") ;
      }
    }
    valRep->subsectionEnd("Associated line definition check finished.") ;

    // -------------
    // End of the line report
  
    if (dataValid) {
      valRep->breakEnd( "CHECK COMPLETE: All lines have required information." ) ;
    }
    else {
      valRep->breakEnd( "ERROR: There are lines missing information. These lines are highlighted on the screen." ) ;
    }
  }


  // ------------------------------------------------------
  // Check line definitions
  // ------------------------------------------------------
  valRep->breakBegin("Checking line definition validity") ;
  bool linedefValid = mLDFSet.validate (valRep) ;
  valRep->breakEnd("Line definition validity check finished.") ;


  // ------------------------------------------------------
  // Wrap up the line report
  // ------------------------------------------------------
  if (linedefValid) {
    valRep->breakEnd( "CHECK COMPLETE: All line definitions have required information." ) ;
  }
  else {
    valRep->breakEnd( "ERROR: There are line definitions missing required information. Review the line definitions in the Line Config in the Configuration Tool." ) ;
  }


  // return status of lines
  return dataValid && linedefValid ;
}

---

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