GLIMSView Source Code Documentation

histogramdlg.cpp

Go to the documentation of this file.

#include "histogramdlg.h"

HistogramDlg::HistogramDlg( QWidget *parent ) :
QWidget( parent ) {
  setCaption( "Histogram" );
  mHistUser = NULL;
  init();
}


HistogramDlg::HistogramDlg( QWidget *parent,
                            vector<HistogramDataSource*> hds,
                            HistogramUser *huser ) :
QWidget( parent ) {
  setCaption( "Histogram" );

  mHDS.HDS    = hds;
  for ( unsigned int iHDS=0; iHDS < hds.size(); iHDS++ )
    hds[iHDS]->setHistogramDlg( this );

  mHistUser   = huser;
}

void HistogramDlg::init( ) {
  mHDS.curHDS         = -1;

  mSLSet.isMerged     = false;
  mSLSet.curArr       = NULL;
  mSLSet.curLine      = 0;
  mSLSet.isChanging   = false;

  mMouse.mLeftDown    = false;
  mMouse.mMidDown     = false;
  mMouse.mRightDown   = false;
  mMouse.mPointMoving = -1;
  mMouse.mMouseX      = 0;
  mMouse.mMouseY      = 0;

  initPntsFromUser();

  setMouseTracking( true );
  buildMenuBar();
  this->setBackgroundColor( QColor( 255,255,255 ) );
  setMinimumSize( 200, 200 );

  resize( 400, 300 );
  changeDataSource();
}

void HistogramDlg::buildMenuBar( ) {
  QAction *action = NULL;
  mMenuBar = new QMenuBar( this );

  // BUILD TOP LEVEL MENUS
  /*
    QPopupMenu *fileMenu = new QPopupMenu( this );
  mMenuBar->insertItem( tr("&File"), fileMenu );
  */

  QPopupMenu *editMenu = new QPopupMenu( this );
  mMenuBar->insertItem( tr("&Edit"), editMenu );

  QPopupMenu *displayMenu = new QPopupMenu( this );
  mMenuBar->insertItem( tr("&Display"), displayMenu );

  mDSMenu = new QPopupMenu( this );
  mMenuBar->insertItem( tr("Data &Source"), mDSMenu );

  QPopupMenu *pointsMenu = new QPopupMenu( this );
  mMenuBar->insertItem( tr("&Points"), pointsMenu );

  QPopupMenu *percentMenu = new QPopupMenu( pointsMenu );
  pointsMenu->insertItem( tr("&Percent"), percentMenu );

  /*
    // BUILD THE FILE MENU
    action = new QAction( tr("Save"), tr("&Save"), 0, this );
  action->addTo( fileMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( saveHist() ) );

    action = new QAction( tr("Print"), tr("&Print"), 0, this );
  action->addTo( fileMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( printHist() ) );

    action = new QAction( tr("Close"), tr("&Close"), 0, this );
  action->addTo( fileMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( close() ) );
  */

  // BUILD THE EDIT MENU
  action = new QAction( tr("Undo"), tr("&Undo"), 0, this );
  action->addTo( editMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( undoToLast() ) );

  action = new QAction( tr("Redo"), tr("&Redo"), 0, this );
  action->addTo( editMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( redoToPrev() ) );

  // BUILD THE DISPLAY MENU
  action = new QAction( tr("Red"), tr("&Red"), 0, this );
  action->addTo( displayMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( changeToRed() ) );
  mColorAct.push_back( action );

  action = new QAction( tr("Green"), tr("&Green"), 0, this );
  action->addTo( displayMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( changeToGreen() ) );
  mColorAct.push_back( action );

  action = new QAction( tr("Blue"), tr("&Blue"), 0, this );
  action->addTo( displayMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( changeToBlue() ) );
  mColorAct.push_back( action );

  // BUILD THE DATASRC MENU
  mDSActGroup = new QActionGroup( mDSMenu );

  for ( unsigned int i=0; i < mHDS.HDS.size(); i++ ) {
    action = new QAction( tr( mHDS.HDS[i]->getHistName() ),
                          tr( mHDS.HDS[i]->getHistName() ),
                          0, this, 0, true );
    action->addTo( mDSMenu );
    connect( action, SIGNAL( activated() ), this, SLOT( changeDataSource() ) );
    mDSActGroup->insert( action );
    mHDS.actSet.push_back( action );

    if ( i == 0 )
      action->setOn( true );
  }

  // BUILD THE POINTS MENU
  // QActionGroup *actgrp = new QActionGroup( percentMenu );

  action = new QAction( tr( "One %" ), tr( "One %" ), 0, this, 0, true );
  action->addTo( percentMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( calcPercent() ) );
  mPercentAct.push_back( action );

  action = new QAction( tr( "One %" ), tr( "Two %" ), 0, this, 0, true );
  action->addTo( percentMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( calcPercent() ) );
  mPercentAct.push_back( action );

  action = new QAction( tr( "One %" ), tr( "Five %" ), 0, this, 0, true );
  action->addTo( percentMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( calcPercent() ) );
  mPercentAct.push_back( action );

  action = new QAction( tr("Best Fit"), tr("&Best Fit"), 0, this );
  action->addTo( pointsMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( bestFit() ) );

  action = new QAction( tr("Clear"), tr("&Clear"), 0, this );
  action->addTo( pointsMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( clearPoints() ) );

  action = new QAction( tr("Merge"), tr("&Merge"), 0, this, 0, true );
  action->addTo( pointsMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( mergeAll() ) );
  mMergeAct = action;
}

void HistogramDlg::paintEvent( QPaintEvent * ) {
  const int scaleW        = mDspDims.scaleW;
  const int graphBorderW  = mDspDims.graphBorderW;
  const int topY          = mDspDims.topY;
  const int winW          = mDspDims.winW;
  const int winH          = mDspDims.winH;
  const int graphW        = mDspDims.graphW;
  const int graphH        = mDspDims.graphH;
  Histogram *hist     = NULL;
  char bufDataMin[15];
  char bufDataMax[15];
  char bufDataMid[15];
  double dataMin, dataMax, dataMid;
  bool haveDS = ( mHDS.HDS.size() == 0 || mHDS.curHDS == -1 ) ? false : true;

  QBrush graphBrushSet[4];
  QColor lineColorSet[4];

  graphBrushSet[0] = QBrush( QColor( 100,0,0 ), Dense4Pattern );
  lineColorSet[0] = QColor( 255,0,0 );
  graphBrushSet[1] = QBrush( QColor( 0,100,0 ), Dense4Pattern );
  lineColorSet[1] = QColor( 0,255,0 );
  graphBrushSet[2] = QBrush( QColor( 0,0,100 ), Dense4Pattern );
  lineColorSet[2] = QColor( 0,0,255 );
  // THE NON-COLOR BRUSH
  graphBrushSet[3] = QBrush( QColor( 100,100,100 ), Dense4Pattern );
  // THE MERGED COLOR
  lineColorSet[3] = QColor( 75,75,75 );

  if ( haveDS ) {
    hist = mHDS.histSet[mHDS.curHist];
    dataMin = hist->getMin();
    dataMax = hist->getMax();
    dataMid = ( dataMax - dataMin ) / 2;

    sprintf( bufDataMin, "%6.3f", dataMin );
    sprintf( bufDataMax, "%6.3f", dataMax );
    sprintf( bufDataMid, "%6.3f", dataMid );
  }

  // OFFSCREEN PIXMAP/PAINTER
  QPixmap bufpm( winW, winH );
  QPainter bufp( &bufpm );
  bufp.setFont( QFont( "Times", 10 ) );

  // CLEAR DRAWING AREA
  QBrush brush( QColor( 255,255,255 ) );
  bufp.fillRect( 0, 0, winW, winH, brush );

  if ( haveDS ) {
    // DRAW GRAPH BOARDER
    bufp.drawRect( scaleW,
                   graphBorderW,
                   graphW,
                   graphH );

    // DRAW 0-255 SCALE
    bufp.rotate( -90 );
    bufp.translate( -winH, 0 );
    bufp.drawText( scaleW+1, 2, graphH, 12, AlignCenter, "Color" );
    bufp.drawLine( scaleW+1, 33, scaleW + graphH-1, 33 );
    bufp.drawLine( scaleW+1, 30, scaleW+1, 37 );
    bufp.drawLine( scaleW+1 + (graphH / 2), 30, scaleW+1 + (graphH / 2), 37 );
    bufp.drawLine( scaleW+graphH, 30, scaleW+graphH, 37 );
    bufp.drawText( scaleW+1-30, 16, 60, 12, AlignCenter, "0" );
    bufp.drawText( scaleW+1-30+(graphH/2), 16, 60, 12, AlignCenter, "128" );
    bufp.drawText( scaleW+1-30+graphH, 16, 60, 12, AlignCenter, "256" );
    bufp.translate( winH, 0 );
    bufp.rotate( 90 );

    // DRAW DN SCALE
    bufp.drawText( scaleW, winH-14, graphW, 12, AlignCenter, "DN Value" );
    bufp.drawLine( scaleW, winH-34, scaleW + graphW-1, winH-34 );
    bufp.drawLine( scaleW, winH-31, scaleW, winH-38 );
    bufp.drawLine( scaleW+(graphW/2), winH-31, scaleW+(graphW/2), winH-38 );
    bufp.drawLine( scaleW+graphW-1, winH-31, scaleW+graphW-1, winH-38 );
    bufp.drawText( scaleW+1-30, winH-29, 60, 12, AlignCenter, bufDataMin );
    bufp.drawText( scaleW+1-30+(graphW/2), winH-29, 60, 12, AlignCenter, bufDataMid );
    bufp.drawText( scaleW+1-30+graphW, winH-29, 60, 12, AlignCenter, bufDataMax );

    // DRAW DATA
    QBrush oldbrush = bufp.brush();
    if ( !mHDS.histSet.isColor() ) {
      bufp.setBrush( graphBrushSet[3] );
      bufp.drawPolygon( mHDS.dataPnts[0] );
    } else if ( !mSLSet.isMerged ) {
      bufp.setBrush( graphBrushSet[mHDS.curHist] );
      bufp.drawPolygon( mHDS.dataPnts[mHDS.curHist] );
    } else {
      bufp.setBrush( graphBrushSet[0] );
      bufp.drawPolygon( mHDS.dataPnts[0] );
      bufp.setBrush( graphBrushSet[1] );
      bufp.drawPolygon( mHDS.dataPnts[1] );
      bufp.setBrush( graphBrushSet[2] );
      bufp.drawPolygon( mHDS.dataPnts[2] );
    }
    bufp.setBrush( oldbrush );

    // INIT STRETCH LINE
    if ( mSLSet.curArr == NULL ) {
      // INITIALIZE SL STACK
      for ( unsigned int iStk=0; iStk < 3; iStk++ ) {
        mSLSet.lineSet[iStk].push( QPointArray( 2 ) );
        mSLSet.lineSet[iStk].top().setPoint( 0, mDspDims.graphZeroX, mDspDims.graphMaxY );
        mSLSet.lineSet[iStk].top().setPoint( 1, mDspDims.graphMaxX, mDspDims.graphZeroY );
      }
      mSLSet.curArr = &mSLSet.lineSet[0].top();

      alertUser();
    }

    // DRAW STRETCH LINE
    if ( !mHDS.histSet.isColor() )
      bufp.setPen( lineColorSet[3] );
    else if ( !mSLSet.isMerged )
      bufp.setPen( lineColorSet[mHDS.curHist] );
    else
      bufp.setPen( lineColorSet[3] );

    bufp.drawPolyline( *mSLSet.curArr );

    for ( unsigned int i=0; i < mSLSet.curArr->size(); i++ )
      bufp.drawRect( (*mSLSet.curArr).at(i).x()-2, ((QPointArray)*mSLSet.curArr).at(i).y()-2, 5, 5 );

    // DRAW GUIDE LINE
    if ( mMouse.mPointMoving >= 0 ) {
      QPen oldpen = bufp.pen();
      QPen newpen( QColor( 128,128,128 ), 0, DashLine );
      bufp.setPen( newpen );
      int px = (*mSLSet.curArr)[mMouse.mPointMoving].x();
      int py = (*mSLSet.curArr)[mMouse.mPointMoving].y();
      bufp.drawLine( px, py, px, mDspDims.graphMaxY );
      bufp.setPen( oldpen );
    }
  } else if ( mHDS.curHDS == -1 ) {
    bufp.drawText( 0, (winH / 2) - 10, winW, 20, AlignCenter, "No Data Sources Selected" );
  } else {
    bufp.drawText( 0, (winH / 2) - 10, winW, 20, AlignCenter, "No Data Sources" );
  }

  QPainter p( this );
  p.drawPixmap( 0, topY, bufpm );
}

void HistogramDlg::resizeEvent( QResizeEvent * ) {
  int     newIntValX, newIntValY;
  double  newDblValX, newDblValY;

  mOldDspDims = mDspDims;
  mDspDims    = calcDspDims();

  int newGraphW = mDspDims.graphMaxX - mDspDims.graphZeroX;
  int newGraphH = mDspDims.graphMaxY - mDspDims.graphZeroY;
  int oldGraphW = mOldDspDims.graphMaxX - mOldDspDims.graphZeroX;
  int oldGraphH = mOldDspDims.graphMaxY - mOldDspDims.graphZeroY;

  double xscale = (double)newGraphW / (double)oldGraphW;
  double yscale = (double)newGraphH / (double)oldGraphH;

  createDataPnts();

  if ( !mSLSet.curArr )
    return;

  // stack<QPointArray> newStk[3];
  QPointArray curArr;
  for ( unsigned int iStk=0; iStk < 3; iStk++ ) {
    stack<QPointArray> tmpStk;
    int szStk = mSLSet.lineSet[iStk].size();
    for ( int iArr=0; iArr < szStk; iArr++ ) {
      tmpStk.push( mSLSet.lineSet[iStk].top() );
      mSLSet.lineSet[iStk].pop();
      curArr = tmpStk.top();

      for ( unsigned int i=0; i < curArr.size(); i++ ) {
        curArr.setPoint( i,
                         (int)( curArr.at(i).x() - mDspDims.graphZeroX ),
                         (int)( curArr.at(i).y() - mDspDims.graphZeroY ) );

        newDblValX = (double)curArr.at(i).x() * xscale;
        newDblValY = (double)curArr.at(i).y() * yscale;
        newIntValX = (int)newDblValX;
        newIntValY = (int)newDblValY;
        newIntValX += ( ( (newDblValX-newIntValX)*10 ) > 5 ) ? 1 : 0;
        newIntValY += ( ( (newDblValY-newIntValY)*10 ) > 5 ) ? 1 : 0;

        curArr.setPoint( i,
                         newIntValX,
                         newIntValY );

        curArr.setPoint( i,
                         (int)( curArr.at(i).x() + mDspDims.graphZeroX ),
                         (int)( curArr.at(i).y() + mDspDims.graphZeroY ) );
      }

    }

    int tmpStkSz = tmpStk.size();
    for ( int iTmp=0; iTmp < tmpStkSz; iTmp++ ) {
      mSLSet.lineSet[iStk].push( tmpStk.top() );
      tmpStk.pop();
    }
  }

  stack<QPointArray> newRedoStk;
  stack<QPointArray> tmpStk;
  int redoStkSz = mSLSet.redoSet.size();
  for ( int iRedoArr=0; iRedoArr < redoStkSz; iRedoArr++ ) {
    tmpStk.push( mSLSet.redoSet.top() );
    mSLSet.redoSet.pop();
    curArr = tmpStk.top();

    for ( unsigned int i=0; i < curArr.size(); i++ ) {
      curArr.setPoint( i,
                       (int)( curArr.at(i).x() - mDspDims.graphZeroX ),
                       (int)( curArr.at(i).y() - mDspDims.graphZeroY ) );

      newDblValX = (double)curArr.at(i).x() * xscale;
      newDblValY = (double)curArr.at(i).y() * yscale;
      newIntValX = (int)newDblValX;
      newIntValY = (int)newDblValY;
      newIntValX += ( ( (newDblValX-newIntValX)*10 ) > 5 ) ? 1 : 0;
      newIntValY += ( ( (newDblValY-newIntValY)*10 ) > 5 ) ? 1 : 0;

      curArr.setPoint( i,
                       newIntValX,
                       newIntValY );

      curArr.setPoint( i,
                       (int)( curArr.at(i).x() + mDspDims.graphZeroX ),
                       (int)( curArr.at(i).y() + mDspDims.graphZeroY ) );
    }
  }

  int tmpStkSz = tmpStk.size();
  for ( int iTmp=0; iTmp < tmpStkSz; iTmp++ ) {
    newRedoStk.push( tmpStk.top() );
    tmpStk.pop();
  }
  mSLSet.redoSet = newRedoStk;

  mSLSet.curArr = &mSLSet.lineSet[mSLSet.curLine].top();
}

DspDims HistogramDlg::calcDspDims( ) {
  DspDims dspDims;
  dspDims.scaleW         = 40;
  dspDims.graphBorderW   = 30;
  dspDims.topY           = mMenuBar->height();
  dspDims.winW           = this->width();
  dspDims.winH           = this->height() - dspDims.topY;
  dspDims.graphW         = dspDims.winW - dspDims.scaleW - dspDims.graphBorderW;
  dspDims.graphH         = dspDims.winH - dspDims.scaleW - dspDims.graphBorderW;
  dspDims.graphZeroX     = dspDims.scaleW;
  dspDims.graphMaxX      = dspDims.scaleW+dspDims.graphW-1;
  dspDims.graphZeroY     = dspDims.graphBorderW;
  dspDims.graphMaxY      = dspDims.graphBorderW+dspDims.graphH-1;

  return dspDims;
}

void HistogramDlg::mousePressEvent( QMouseEvent * ) {
  if ( mHDS.HDS.size() <= 0 || mHDS.curHDS == -1 )
    return;
  mMouse.mPointMoving = mouseOnPoint();
}

void HistogramDlg::mouseReleaseEvent( QMouseEvent * ) {
  if ( mHDS.HDS.size() <= 0 || mHDS.curHDS == -1 )
    return;

  if ( mSLSet.isChanging ) {
    mSLSet.isChanging = false;
    alertUser();
  }
  mMouse.mPointMoving = -1;
  repaint( false );
}

void HistogramDlg::mouseMoveEvent( QMouseEvent *me ) {
  int newX, newY;

  if ( mHDS.HDS.size() <= 0 || mHDS.curHDS == -1 )
    return;

  mMouse.mMouseX = me->x();
  mMouse.mMouseY = me->y() - mDspDims.topY;

  if ( mMouse.mPointMoving >= 0 ) {
    // THIS ONLY HAPPENS ONCE DURING A POINT MOVE
    if ( !mSLSet.isChanging ) {
      if ( !mSLSet.isMerged ) {
        mSLSet.lineSet[mSLSet.curLine].push( mSLSet.curArr->copy() );
      } else {
        mSLSet.lineSet[0].push( mSLSet.curArr->copy() );
        mSLSet.lineSet[1].push( mSLSet.curArr->copy() );
        mSLSet.lineSet[2].push( mSLSet.curArr->copy() );
      }
      mSLSet.curArr = &mSLSet.lineSet[mSLSet.curLine].top();
      mSLSet.redoSet.empty();
      mSLSet.isChanging = true;
    }

    if ( mMouse.mPointMoving == 0 ||
         mMouse.mPointMoving == (int)mSLSet.curArr->size()-1 ) {
      newX = (*mSLSet.curArr)[mMouse.mPointMoving].x();
      newY = mMouse.mMouseY;
    } else {
      if ( mMouse.mMouseX - (*mSLSet.curArr)[mMouse.mPointMoving-1].x() < 6 ||
           (*mSLSet.curArr)[mMouse.mPointMoving+1].x() - mMouse.mMouseX < 6 )
        newX = (*mSLSet.curArr)[mMouse.mPointMoving].x();
      else
        newX = mMouse.mMouseX;

      newY = mMouse.mMouseY;

      if ( newX > mDspDims.graphMaxX ) newX = mDspDims.graphMaxX;
      if ( newX < mDspDims.graphZeroX ) newX = mDspDims.graphZeroX;
    }

    if ( newY > mDspDims.graphMaxY ) newY = mDspDims.graphMaxY;
    if ( newY < mDspDims.graphZeroY ) newY = mDspDims.graphZeroY;

    if ( !mSLSet.isMerged )
      mSLSet.curArr->setPoint( mMouse.mPointMoving, newX, newY );
    else {
      mSLSet.lineSet[0].top().setPoint( mMouse.mPointMoving, newX, newY );
      mSLSet.lineSet[1].top().setPoint( mMouse.mPointMoving, newX, newY );
      mSLSet.lineSet[2].top().setPoint( mMouse.mPointMoving, newX, newY );
    }
    repaint( false );
  } else {
    QCursor c1( PointingHandCursor );
    if ( mouseOnPoint() >= 0 )
      setCursor( c1 );
    else
      setCursor( QCursor( ArrowCursor ) );
  }
}


bool HistogramDlg::mouseInGraph( ) {
  if ( mMouse.mMouseX < mDspDims.graphMaxX &&
       mMouse.mMouseX > mDspDims.graphZeroX &&
       mMouse.mMouseY < mDspDims.graphMaxY &&
       mMouse.mMouseY > mDspDims.graphZeroY )
    return true;

  return false;
}

int HistogramDlg::mouseOnPoint( ) {
  for ( int i=0; i < (int)mSLSet.curArr->size(); i++ ) {
    if ( abs( mMouse.mMouseX - (*mSLSet.curArr)[i].x() ) <= 3 &&
         abs( mMouse.mMouseY - (*mSLSet.curArr)[i].y() ) <= 3 )
      return i;
  }

  return -1;
}

void HistogramDlg::mouseDoubleClickEvent( QMouseEvent * ) {
  unsigned int i, a;
  int pnt = mouseOnPoint();

  if ( !mouseInGraph() )
    return;

  if ( !mSLSet.isMerged ) {
    mSLSet.lineSet[mSLSet.curLine].push( mSLSet.curArr->copy() );
  } else {
    mSLSet.lineSet[0].push( mSLSet.curArr->copy() );
    mSLSet.lineSet[1].push( mSLSet.curArr->copy() );
    mSLSet.lineSet[2].push( mSLSet.curArr->copy() );
  }

  mSLSet.curArr = &mSLSet.lineSet[mSLSet.curLine].top();
  mSLSet.redoSet.empty();

  if ( pnt < 0 ) {
    for ( i=0; i < mSLSet.curArr->size(); i++ )
      if ( abs( (*mSLSet.curArr).at(i).x() - mMouse.mMouseX ) <= 3 )
        return;

    QPointArray tmpPntArr( mSLSet.curArr->size() +1 );
    bool mFoundIt = false;
    a=0;
    for ( i=0; i < mSLSet.curArr->size(); i++ ) {
      if ( !mFoundIt && (*mSLSet.curArr).at(i).x() > mMouse.mMouseX ) {
        tmpPntArr.setPoint( a, mMouse.mMouseX, mMouse.mMouseY );
        i--;
        mFoundIt = true;
        mMouse.mPointMoving = a;
      } else
        tmpPntArr.setPoint( a, (*mSLSet.curArr).at(i).x(), (*mSLSet.curArr).at(i).y() );
      a++;
    }
    setCursor( QCursor( PointingHandCursor ) );
    if ( !mSLSet.isMerged )
      (*mSLSet.curArr) = tmpPntArr;
    else {
      mSLSet.lineSet[0].top() = tmpPntArr;
      mSLSet.lineSet[1].top() = tmpPntArr;
      mSLSet.lineSet[2].top() = tmpPntArr;
    }

  } else {
    if ( pnt == 0 || pnt == (int)mSLSet.curArr->size()-1 )
      return;

    QPointArray tmpPntArr( mSLSet.curArr->size() - 1 );
    a = 0;
    for ( i=0; i < mSLSet.curArr->size(); i++ ) {
      if ( (int)i != pnt ) {
        tmpPntArr.at(a) = (*mSLSet.curArr).at(i);
        a++;
      }
    }
    setCursor( QCursor( ArrowCursor ) );
    if ( !mSLSet.isMerged )
      (*mSLSet.curArr) = tmpPntArr;
    else {
      mSLSet.lineSet[0].top() = tmpPntArr;
      mSLSet.lineSet[1].top() = tmpPntArr;
      mSLSet.lineSet[2].top() = tmpPntArr;
    }
  }

  alertUser();
  repaint( false );
}

void HistogramDlg::setHDS( vector<HistogramDataSource*> hds ) {
  mHDS.HDS = hds;

}

void HistogramDlg::setUser( HistogramUser *user ) {
  mHistUser = user;
}

void HistogramDlg::addHDS( HistogramDataSource *hds ) {
  mHDS.HDS.push_back( hds );
  hds->setHistogramDlg( this );

  QAction *action = new QAction( tr( hds->getHistName() ),
                                 tr( hds->getHistName() ),
                                 0, this, 0, true );
  action->addTo( mDSMenu );
  connect( action, SIGNAL( activated() ), this, SLOT( changeDataSource() ) );
  mDSActGroup->insert( action );
  mHDS.actSet.push_back( action );
  action->setOn( true );
}

void HistogramDlg::changeToRed( ) {
  mHDS.curHist = 0;
  mSLSet.redoSet.empty();
  mSLSet.curArr = &mSLSet.lineSet[0].top();
  mSLSet.curLine = 0;
  repaint( false );
}

void HistogramDlg::changeToGreen( ) {
  mHDS.curHist = 1;
  mSLSet.redoSet.empty();
  mSLSet.curArr = &mSLSet.lineSet[1].top();
  mSLSet.curLine = 1;
  repaint( false );
}

void HistogramDlg::changeToBlue( ) {
  mHDS.curHist = 2;
  mSLSet.redoSet.empty();
  mSLSet.curArr = &mSLSet.lineSet[2].top();
  mSLSet.curLine = 2;
  repaint( false );
}

void HistogramDlg::changeToAll( ) {

}

void HistogramDlg::changeDataSource( ) {
  unsigned int cnt = 0;

  while ( cnt < mHDS.actSet.size() && !mHDS.actSet[cnt]->isOn() )
    cnt++;

  if ( cnt >= mHDS.actSet.size() )
    return;

  mHDS.curHDS = cnt;

  // HERE'S WHERE A THREAD GOES TO WAIT FOR HIST CALCULATION
  QApplication::setOverrideCursor( Qt::waitCursor );
  mHDS.histSet = mHDS.HDS[mHDS.curHDS]->getHistSet();
  QApplication::restoreOverrideCursor();
  mHDS.curHist = mSLSet.curLine;

  if ( !mHDS.histSet.isColor() ) {
    mSLSet.isMerged = false;
    mMergeAct->setOn( false );
    mMergeAct->setEnabled( false );

    mColorAct[0]->setEnabled( false );
    mColorAct[1]->setEnabled( false );
    mColorAct[2]->setEnabled( false );
  } else {
    mSLSet.isMerged = false;
    mMergeAct->setOn( false );
    mMergeAct->setEnabled( true );

    mColorAct[0]->setEnabled( true );
    mColorAct[1]->setEnabled( true );
    mColorAct[2]->setEnabled( true );
  }

  createDataPnts();
  repaint( false );

}

void HistogramDlg::createDataPnts( ) {
  Histogram *hist;
  double min;
  double max;
  double scaleX;
  double scaleY;
  int    cmax;

  if ( mHDS.HDS.size() <= 0 )
    return;

  mDspDims    = calcDspDims();

  int graphW = mDspDims.graphMaxX - mDspDims.graphZeroX;
  int graphH = mDspDims.graphMaxY - mDspDims.graphZeroY;

  vector<QPoint> points;

  QPoint begp( mDspDims.graphZeroX, mDspDims.graphMaxY );
  QPoint endp( mDspDims.graphMaxX, mDspDims.graphMaxY );

  for ( int i=0; i < 3; i++ ) {
    if ( !mHDS.histSet.isColor() && i > 0 )
      break;

    hist = mHDS.histSet[i];
    if ( hist == NULL )
      continue;

    min  = hist->getMin();
    max  = hist->getMax();
    cmax = hist->getMaxCnt();

    scaleX = (double)graphW / (double)(max-min);
    scaleY = (double)graphH / (double)cmax;

    vector<Hash> hash = hist->getHist();
    for ( unsigned int iHash=0; iHash < hash.size(); iHash++ ) {
      QPoint p( (int)((hash[iHash].mVal - min)*scaleX+mDspDims.graphZeroX),
                (int)(mDspDims.graphMaxY - (hash[iHash].mCnt*scaleY)) );

      points.push_back( p );
    }

    QPointArray parr( points.size() + 3 );
    parr.setPoint( 0, begp );
    unsigned int iPnt;
    for ( iPnt=0; iPnt < points.size(); iPnt++ )
      parr.setPoint( iPnt+1, points[iPnt] );

    parr.setPoint( iPnt+1, endp );
    parr.setPoint( iPnt+2, begp );

    mHDS.dataPnts[i] = parr.copy();
    points.clear();
  }
}

void HistogramDlg::bestFit( ) {

}

void HistogramDlg::mergeAll( ) {
  if ( mSLSet.isMerged == false ) {
    mSLSet.isMerged = true;
    // PUSH CUR ARRAY TO ALL
    mSLSet.lineSet[0].push( *mSLSet.curArr );
    mSLSet.lineSet[1].push( *mSLSet.curArr );
    mSLSet.lineSet[2].push( *mSLSet.curArr );
    mSLSet.curArr = &mSLSet.lineSet[0].top();
    mSLSet.curLine = 0;
  } else {
    mSLSet.isMerged = false;
  }
  repaint( false );
}

void HistogramDlg::clearPoints( ) {
  QPointArray parr( 2 );
  parr.setPoint( 0, mSLSet.curArr->at( 0 ) );
  parr.setPoint( 1, mSLSet.curArr->at( mSLSet.curArr->size()-1 ) );

  mSLSet.lineSet[mSLSet.curLine].push( parr );
  mSLSet.curArr = &mSLSet.lineSet[mSLSet.curLine].top();
  mSLSet.redoSet.empty();

  alertUser();
  repaint( false );
}

void HistogramDlg::undoToLast( ) {
  if ( mSLSet.lineSet[mSLSet.curLine].size() < 2 )
    return;

  mSLSet.redoSet.push( mSLSet.curArr->copy() );
  mSLSet.lineSet[mSLSet.curLine].pop();
  mSLSet.curArr = &mSLSet.lineSet[mSLSet.curLine].top();

  repaint( false );
}

void HistogramDlg::redoToPrev( ) {
  if ( mSLSet.redoSet.size() <= 0 )
    return;

  mSLSet.lineSet[mSLSet.curLine].push( mSLSet.redoSet.top().copy() );
  mSLSet.curArr = &mSLSet.lineSet[mSLSet.curLine].top();
  mSLSet.redoSet.pop();

  repaint( false );

}

void HistogramDlg::calcPercent( ) {
  if ( mHDS.curHDS == -1 )
    return;

  unsigned int    iPct = 0;
  double          cntTot=0, cntTot2=0, cntTot3=0;
  double          cntLeft=0, cntRight=0,
  cntLeft2=0, cntRight2=0,
  cntLeft3=0, cntRight3=0;
  double          valR = 0.0, valL = 0.0, valR2 = 0.0,
  valL2 = 0.0, valR3 = 0.0, valL3 = 0.0;
  int             h0sz, h1sz=0, h2sz=0;

  vector<Hash> hist[3];
  double percentVals[] = { .01, .02, .05};

  bool isColor = mHDS.histSet.isColor();

  while ( iPct < mPercentAct.size() && !mPercentAct[iPct]->isOn() )
    iPct++;

  mPercentAct[iPct]->setOn( false );

  if ( iPct >= mPercentAct.size() )
    return;

  mPercentAct[iPct]->setOn( false );

  // CALC COUNT TOTAL
  int iCnt=0;

  hist[0] = mHDS.histSet[0]->getHist();
  h0sz = hist[0].size();
  for ( iCnt=0; iCnt < h0sz; iCnt++ )
    cntTot += hist[0][iCnt].mCnt;

  if ( isColor ) {
    hist[1] = mHDS.histSet[1]->getHist();
    h1sz = hist[1].size();
    for ( iCnt=0; iCnt < h1sz; iCnt++ )
      cntTot2 += hist[1][iCnt].mCnt;

    hist[2] = mHDS.histSet[2]->getHist();
    h2sz = hist[2].size();
    for ( iCnt=0; iCnt < h2sz; iCnt++ )
      cntTot3 += hist[2][iCnt].mCnt;
  }

  // CALC LEFT VAL
  iCnt = 1;
  while ( iCnt < h0sz && cntLeft < (cntTot*percentVals[iPct]) ) {
    valL = hist[0][iCnt].mVal;
    if ( iCnt < h0sz )
      cntLeft += hist[0][iCnt].mCnt;
    iCnt++;
  }

  if ( isColor ) {
    iCnt = 1;
    while ( iCnt < h1sz && cntLeft2 < (cntTot2*percentVals[iPct]) ) {
      valL2 = hist[1][iCnt].mVal;
      if ( iCnt < h0sz )
        cntLeft2 += hist[1][iCnt].mCnt;
      iCnt++;
    }

    iCnt = 1;
    while ( iCnt < h2sz && cntLeft3 < (cntTot3*percentVals[iPct]) ) {
      valL3 = hist[2][iCnt].mVal;
      if ( iCnt < h0sz )
        cntLeft3 += hist[2][iCnt].mCnt;
      iCnt++;
    }
  }


  // CALC RIGHT VAL
  iCnt = 2;
  while ( iCnt < h0sz && cntRight < (cntTot*percentVals[iPct]) ) {
    valR = hist[0][h0sz-iCnt].mVal;
    cntRight += hist[0][h0sz-iCnt].mCnt;
    iCnt++;
  }

  if ( isColor ) {
    iCnt = 2;
    while ( iCnt < h1sz && cntRight2 < (cntTot2*percentVals[iPct]) ) {
      valR2 = hist[1][h1sz-iCnt].mVal;
      cntRight2 += hist[1][h1sz-iCnt].mCnt;
      iCnt++;
    }

    iCnt = 2;
    while ( iCnt < (int)h2sz && cntRight3 < (int)(cntTot3*percentVals[iPct]) ) {
      valR3 = hist[2][h2sz-iCnt].mVal;
      cntRight3 += hist[2][h2sz-iCnt].mCnt;
      iCnt++;
    }
  }

  QPointArray parr( 4 );
  QPointArray parr2( 4 );
  QPointArray parr3( 4 );

  parr.setPoint( 0, mDspDims.graphZeroX, mDspDims.graphMaxY );
  parr.setPoint( 3, mDspDims.graphMaxX, mDspDims.graphZeroY );

  if ( isColor ) {
    parr2.setPoint( 0, mDspDims.graphZeroX, mDspDims.graphMaxY );
    parr2.setPoint( 3, mDspDims.graphMaxX, mDspDims.graphZeroY );
    parr3.setPoint( 0, mDspDims.graphZeroX, mDspDims.graphMaxY );
    parr3.setPoint( 3, mDspDims.graphMaxX, mDspDims.graphZeroY );
  }

  double min = hist[0][0].mVal;
  double max = hist[0][hist[0].size()-1].mVal;
  double graphW = mDspDims.graphMaxX - mDspDims.graphZeroX;
  double scaleX = graphW / (double)(max-min);

  parr.setPoint( 1, (int)(valL*scaleX+mDspDims.graphZeroX), (int)mDspDims.graphMaxY );
  parr.setPoint( 2, (int)(valR*scaleX+mDspDims.graphZeroX), (int)mDspDims.graphZeroY );

  if ( isColor ) {
    min = hist[1][0].mVal;
    max = hist[1][hist[1].size()-1].mVal;
    scaleX = graphW / (double)(max-min);
    parr2.setPoint( 1, (int)(valL2*scaleX+mDspDims.graphZeroX), (int)mDspDims.graphMaxY );
    parr2.setPoint( 2, (int)(valR2*scaleX+mDspDims.graphZeroX), (int)mDspDims.graphZeroY );

    min = hist[2][0].mVal;
    max = hist[2][hist[2].size()-1].mVal;
    scaleX = graphW / (double)(max-min);
    parr3.setPoint( 1, (int)(valL3*scaleX+mDspDims.graphZeroX),(int)mDspDims.graphMaxY );
    parr3.setPoint( 2, (int)(valR3*scaleX+mDspDims.graphZeroX), (int)mDspDims.graphZeroY );
  }

  mSLSet.lineSet[0].push( parr.copy() );
  if ( isColor ) {
    mSLSet.lineSet[1].push( parr2.copy() );
    mSLSet.lineSet[2].push( parr3.copy() );
  }

  mSLSet.redoSet.empty();
  mSLSet.curArr = &mSLSet.lineSet[mSLSet.curLine].top();

  mSLSet.isMerged = false;
  mMergeAct->setOn( false );

  alertUser();
  repaint( false );

}

void HistogramDlg::initPntsFromUser( ) {
  if ( mHistUser ) {
    const QPointArray *parr = mHistUser->getHistPnts();
    mSLSet.lineSet[0].empty();
    mSLSet.lineSet[1].empty();
    mSLSet.lineSet[2].empty();
    mSLSet.redoSet.empty();

    mSLSet.lineSet[0].push( parr[0].copy() );
    mSLSet.lineSet[1].push( parr[1].copy() );
    mSLSet.lineSet[2].push( parr[2].copy() );

    resize( this->width(), this->height() );
  }
}

void HistogramDlg::alertUser( ) {
  if ( mHistUser ) {
    QPointArray parr[3];
    parr[0] = mSLSet.lineSet[0].top().copy();
    if ( mHDS.histSet.isColor() ) {
      parr[1] = mSLSet.lineSet[1].top().copy();
      parr[2] = mSLSet.lineSet[2].top().copy();
    } else {
      parr[1].resize( 0 );
      parr[2].resize( 0 );
    }

    for ( unsigned int iArr=0; iArr < 3; iArr++ ) {
      if ( !mHDS.histSet.isColor() && iArr > 0 )
        break;

      double min = mHDS.histSet.getHist( iArr )->getMin();
      double max = mHDS.histSet.getHist( iArr )->getMax();
      double graphW = mDspDims.graphMaxX - mDspDims.graphZeroX;
      double graphH = mDspDims.graphMaxY - mDspDims.graphZeroY;

      double scaleX = (max-min) / graphW;
      double scaleY = 255 / graphH;

      for ( unsigned int iPnt=0; iPnt < parr[iArr].size(); iPnt++ ) {
        double x = parr[iArr].at(iPnt).x();
        double y = parr[iArr].at(iPnt).y();

        x -= mDspDims.scaleW;
        y = mDspDims.graphMaxY - y;

        x *= scaleX;
        y *= scaleY;

        parr[iArr].setPoint( iPnt, (int)x, (int)y );
      }
    }

    mHistUser->setHistPnts( parr );
  }
}

void HistogramDlg::reloadHistSet( ) {
  /*
  if( mHistUser )
      mHistUser->reset();
  */
  changeDataSource( );
}

---

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