GLIMSView Source Code Documentation

extensions/ImageCalculator.cpp

Go to the documentation of this file.

#include "ImageCalculator.h"
#include <iostream>
#include <sstream>
#include <fstream>


ImageCalculator::ImageCalculator(GLIMSProject *proj){
  mProj = proj;
  mImage = ImageInterface::getInterface(mProj);
}

ImageCalculator::~ImageCalculator(){
  if (mImage != NULL) {
    mImage->ImageInterface::destroyInterface();
  }
}

void ImageCalculator::calculate(std::string eq){
  calculate(eq, -1);
}

void ImageCalculator::calculate(std::string eq, int lineStyle){
  //create an arithmatic cube with the proper dimentions
  ImageArithmaticCube mathCube(0, 0, mImage->getWidth(), mImage->getHeight());

  //run through and get only the bands needed for the calculation
  for(int k=0; k < mImage->getBands(); k++){
    //put together a band name
    std::stringstream bandname;
    bandname << "b" << k;

    //see if the current name is in the equation
    if(eq.find(bandname.str(), 0) != std::string::npos){
      //if it's in the equation, get it and add it
      std::vector<double>* layers = mImage->getSliceScaled(0, 0, k, (mImage->getWidth())-1, (mImage->getHeight())-1, k);
      mathCube.addBand(layers, k);
    }
  }

  //set the equation in the arithmaticCube
  mathCube.setEquation(eq);

  //calculate and get results
  std::vector<double>* results = mathCube.calculateLayer();
  if (results == NULL) return ;

  // debugging - write out raw image
  fstream calcdFile ;
  calcdFile.open ("imageCalcCalculate.raw", fstream::out | fstream::binary) ;
  if (calcdFile.is_open()) {
    for (int hei = 0 ; hei < mImage->getHeight() ; hei++) {
      for (int wid = 0 ; wid < mImage->getWidth() ; wid++) {
        calcdFile << (int) ((*results)[(mImage->getWidth())*hei + wid]) ;
      }
    }
    calcdFile.close() ;
  }
  // end debugging

  //create a shapeFinder
  ImageShapeFinder shapes(0, 0, mImage->getWidth(), mImage->getHeight(), results);
  shapes.setAlgorithm(algorithm) ;


  //create a vector of selectable values, this is just 1 for us
  std::vector<double> sel(1);
  sel[0] = 1;


  //set the selected values to the created vector
  shapes.setSelectedValues(sel);


  //do calculations and get the selections
  //std::vector<ImageSelectionCube> sh = shapes->getSelections();
  std::vector<ImageSelectionCube*> sh = shapes.getSelections();



  /*************************************************************
   * This code is more or less copied from the Threshold tool.
   * I will try to explain it, but I'm not always sure.
   */

  //get the line data - for attempt at changing line color
  GLIMSLineData &ldata = mProj->getDataset()->getLineData();
  //get the linedefset - for attempt at changing line color
  LineDefSet mLDFSet = ldata.getLDFSet();

  //create a vector to store the lines in
  std::vector<GlacierLine> * glineset = new std::vector<GlacierLine> ;

    //for each selection from the imageSelector
      for(unsigned int iline = 0; iline < sh.size(); iline++ ){

      //get the points in this selection
      std::vector<ImageCube::ThreeDPoint> line = sh[iline]->getPoints();

     //create a glacier line args are for color change
         GlacierLine * gline = new GlacierLine(-1, lineStyle);

     //get the nodeset from the line we just created
         std::vector<Node> &ns = gline->nodeset() ;

     //node for adding vals
         Node * n = new Node ;

     //for each point in the selection
         for( unsigned int ipnt = 0; ipnt < line.size(); ipnt++ ) {
           if (line[ipnt].x >= 0 && line[ipnt].y >= 0) {
            //set the node x and y (add 0.5 to shift to center of pixel)
             n->x = line[ipnt].x+0.5;
             n->y = line[ipnt].y+0.5;

            //translate x and y to lat and long
            mImage->getLL( 0, n->x, n->y );

            //add the node
            ns.push_back( *n );
           }
        }

     if(lineStyle >=0){
      //these next 5 lines are for changing line color
      DspAttr attr = gline->getAttr();
      attr.color = GLIMSGlobals::AVAILCOLORS[ mLDFSet[lineStyle].mColor ];
      attr.style = (Qt::PenStyle)mLDFSet[lineStyle].mStyle;
      attr.width = mLDFSet[lineStyle].mWidth;
      gline->setAttr(attr);
     }


      //add the line
      glineset->push_back( *gline );
    }


    //add the set of lines to the lineData
    ldata.addLineSetLL( *glineset );

    //repaint
    mProj->getViewSet()->repaintViews();

   /*end of code from the Threashold tool
   *********************************************************/


   //delete the shape files
//    for (unsigned int i = 0; i<sh.size(); i++){
//      delete sh[i];
//    }
}

void ImageCalculator::testDriver(){

  calculate("b0==255");
  return;

//  QMessageBox::information( 0, "ImageCalculatorDialog::test", "in doCalc" );

  ImageArithmaticCube cube(0, 0, 10, 10);
  std::vector<double> temp(300);
  for (int i=0; i<100; i++){
    temp[i] = 5;
  }

  for(int j=100; j<200; j++){
    temp[j] = j;
  }

  for (int k=200; k<300; k++){
    temp[k] = 10;
  }

//  QMessageBox::information( 0, "ImageCalculatorDialog::test", "setup layers");


  cube.addBands(&temp);
  cube.setEquation("130<(b1+b2+b0)");

//  QMessageBox::information( 0, "ImageCalculatorDialog::test", "before calc" );


  std::vector<double>* res = cube.calculateLayer();

//  QMessageBox::information( 0, "ImageCalculatorDialog::test", "after calc" );


  ImageShapeFinder shapes = ImageShapeFinder(0, 0, 10, 10, res);

  std::vector<double> sel(1);
  sel[0] = 1;

  shapes.setSelectedValues(sel);

  std::vector<ImageSelectionCube*> sh = shapes.getSelections();


  std::stringstream ss;
/*  for(int l=0; l<res.size(); l++){
    if(l%10 == 0) ss << "\n";
    ss << res[l];
*/
  for(unsigned int l=0; l<sh.size(); l++){
    ss << sh[l]->getAsString() << "\n";
  }

  QMessageBox::information( 0, "ImageCalculatorDialog::test", (ss.str()).c_str() );
}

---

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