GLIMSView Source Code Documentation

extensions/ImageSelectionCube.cpp

Go to the documentation of this file.

#include "ImageSelectionCube.h"
#include <math.h>

ImageSelectionCube::ImageSelectionCube(int x1, int y1, int w1, int h1, ImageInterface* theimage) :
  ImageCube( x1, y1, w1, h1, theimage){;}

ImageSelectionCube::ImageSelectionCube(int x1, int y1, int w1, int h1) :
  ImageCube( x1, y1, w1, h1){;}

ImageSelectionCube::~ImageSelectionCube(){
  for(unsigned int i=0; i < theCube.size(); i++){
// @todo 2006-07-25 dls cleaning up doubles seems to be causing crash -- need to reexamine this section to see if clean-up is needed
    //delete (theCube[i].values) ;
  }
}

void ImageSelectionCube::setSelection(std::vector<ImageCube::ThreeDPoint> points) {

  selectionPoints = removeDuplicates(points);
  //do all setup of selection here
  //i.e. figure out what pixels are in, and put them in the array

  if(points.size()<3){//if we don't have 3 pix, we don't have a poly
    if (points.size() == 1){//if it's a point, just add the pixel

      ImageCube::Pixel temp_pix;
      temp_pix.x = (int)(points[0].x) ;
      temp_pix.y = (int)(points[0].y) ;

      selectionPixels.push_back(temp_pix);

    } else if (points.size() == 2){//if it's a line, handle that here

      //use generate full line to get all values in the line
      std::vector<ImageCube::ThreeDPoint> temp = generateFullLine(points[0], points[1]);

      for(unsigned int i=0; i<temp.size(); i++){//for each pixels
        ImageCube::Pixel temp_pix;
        temp_pix.x = (int)(temp[i].x) ;
        temp_pix.y = (int)(temp[i].y) ;

        selectionPixels.push_back(temp_pix);
      }

    }

  }
  else {//we have a polygon
    std::vector<ImageCube::ThreeDPoint> borderPixels;

    //set up iterators to get two consecutive points
    std::vector<ImageCube::ThreeDPoint>::iterator main = points.begin();
    std::vector<ImageCube::ThreeDPoint>::iterator oneAhead = points.begin();
    oneAhead++;

    while (main != points.end()){//once for each point
      if(((*oneAhead).x == (*main).x) && ((*oneAhead).y == (*main).y)){
        oneAhead++;
        main++;
        continue;
      }


      //generate the y-border pixels
      std::vector<ImageCube::ThreeDPoint> temp = generateLine(*main, *oneAhead);

      //combine them into a sorted vector
      //borderPixels = combineSortedVectors(removeDuplicates(borderPixels), removeDuplicates(temp));
      borderPixels = combineSortedVectors(borderPixels, temp);

      main++;
      oneAhead++;
      //handle wraparound
      if(oneAhead == points.end()){
        oneAhead = points.begin();

        if(((*oneAhead).x == (*main).x) && ((*oneAhead).y == (*main).y)) break;
      }
    }

    borderPixels = removeDuplicates(borderPixels);

    //now we have a vector of all the edges in the order or L->R, T->B
    //(how we read)  now we just grab the first, add pixels until we
    //reach the end of that row, move to the next row and repeat

    for(unsigned int i=0; i < borderPixels.size(); i++){//while we have pixels

      ImageCube::Pixel temp_pix;
      temp_pix.x = (int)(borderPixels[i].x) ;
      temp_pix.y = (int)(borderPixels[i].y) ;

      selectionPixels.push_back(temp_pix);

      if(borderPixels[i+1].y == borderPixels[i].y){//if the next pixel is on this row

         //then we add all the pixels between the boundaries on this row
        for(int j = (int)(borderPixels[i].x)+1 ; j <= (int)(borderPixels[i+1].x) ; j++) {
          if( j == borderPixels[i+1].x && (borderPixels[i+1].z == 1)){
            j++;
            continue;
          }

          ImageCube::Pixel temp_pix;
          temp_pix.x = j;
          temp_pix.y = (int)(borderPixels[i].y);

          selectionPixels.push_back(temp_pix);

        }
        i++;//increment i, because we're adding the end boundary
      }
    }
  }
}


void ImageSelectionCube::setSelection(std::vector<ImageCube::Pixel> pixs){

  borderPixels = pixs;

  selectionPixels = pixs;
  selectionPoints = generatePoints(pixs);


  //TODO generate the Points that outline this shape



}


std::string ImageSelectionCube::getAsString(){

  return getAsString(";");
}


std::string ImageSelectionCube::getAsString(std::string delim, std::ofstream &f){
  pixelArray.clearAll();

  // for each pixel in the selection area
  int i = 0 ;
  for( i = 0; i < (int)(selectionPixels.size()) ; i++){
    // create a new pixel element in pixelArray with the image x-y coords of the current pixel location
    pixelArray.add(selectionPixels[i].x, selectionPixels[i].y);
  }

  int x = 0 ;
  int y = 0 ;

  // for each pixel in the selection area
  for( i = 0; i < (int)(selectionPixels.size()) ; i++){

    // for each band ("layer") in the image
    for(int k = 0; k<this->layers; k++){

      // get the associated PixelProfile element from pixel array and
      // add the values to the element
      x = selectionPixels[i].x ;
      y = selectionPixels[i].y ;

      PixelProfile * newPix = pixelArray.getPixel(x, y) ;
      if (newPix != NULL) {
        if (x > 0 && y > 0) {
          newPix->add(ImageCube::getValueAtOverall(x, y, k));
        }
      }
    }
  }


  pixelArray.getAsString(delim, f);
  return "" ;
}


std::string ImageSelectionCube::getAsString(std::string delim){
  pixelArray.clearAll();

  // for each pixel in the selection area
  int i = 0 ;
  for( i = 0 ; i < (int)(selectionPixels.size()) ; i++ ) {
    // create a new pixel element in pixelArray with the image x-y coords of the current pixel location
    pixelArray.add(selectionPixels[i].x, selectionPixels[i].y);
  }

  int x = 0 ;
  int y = 0 ;

  // for each pixel in the selection area
  for( i = 0 ; i < (int)(selectionPixels.size()) ; i++ ) {
    // for each band ("layer") in the image
    for(int k = 0; k<this->layers; k++){
      // get the associated PixelProfile element from pixel array and
      // add the values to the element
      x = selectionPixels[i].x ;
      y = selectionPixels[i].y ;
      PixelProfile * newPix = pixelArray.getPixel(x, y) ;
      if (newPix != NULL) {
        newPix->add(ImageCube::getValueAtOverall(x, y, k));
      }
    }
  }

  return pixelArray.getAsString(delim) ;
}


std::vector<ImageCube::ThreeDPoint> ImageSelectionCube::getPoints(){
  return selectionPoints;
}


std::vector<ImageCube::Pixel> ImageSelectionCube::getPixels(){
  return selectionPixels;
}


std::vector<ImageCube::ThreeDPoint> ImageSelectionCube::generateFullLine(ImageCube::ThreeDPoint s, ImageCube::ThreeDPoint f){

  //if it's effectivly a straight line, we've already handled that in genLine
  if ((-1<(f.x - s.x) && (f.x - s.x)<1) || (-1<(f.y - s.y) && (f.y - s.y)<1)){
    return generateLine(s, f);
  }

  double m;
  double b;

  int lx, ly, hx, hy;

  //figure out m and b (y=mx+b)
  if(s.x > f.x) {//if slope is negative
    m = ((double)(s.y - f.y))/((double)(s.x - f.x));
    b = s.y - (m*(s.x));
  } else {//if slope is positive
    m = ((double)(f.y - s.y))/((double)(f.x - s.x));
    b = s.y - (m*(s.x));
  }

  //figure out high and low y
  if(s.y > f.y) {
    hy = (int)(s.y);
    ly = (int)(f.y);
  } else {
    hy = (int)(f.y);
    ly = (int)(s.y);
  }

  //figure out high and low x
  if(s.x > f.x) {
    hx = (int)(s.x) ;
    lx = (int)(f.x) ;
  } 
  else {
    hx = (int)(f.x) ;
    lx = (int)(s.x) ;
  }

  std::vector<ImageCube::ThreeDPoint> temp;

  if(m > 1){//if longer in x direction
    for (int i=lx; i<=hx; i++){
      double val = (m*(double)i)+b;
      ImageCube::ThreeDPoint borderPoint;
      borderPoint.y = (int)(val+0.5);
      borderPoint.x = i;
      borderPoint.z = 0;

      temp.push_back(borderPoint);

      if((int)(val+0.15) != (int)(val+0.5)){
        //if we're really close to the upper edge
        //grab the next pixel over too
        ImageCube::ThreeDPoint borderPoint2;
        borderPoint2.y = (int)(val+0.15);
        borderPoint2.x = i;
        borderPoint2.z = 0;

        temp.push_back(borderPoint2);

      } else if ((int)(val-0.15) != (int)(val)){
        //if we're really close to the lower edge
        //grab the next pixel over too
        ImageCube::ThreeDPoint borderPoint2;
        borderPoint2.y = (int)(val-0.15);
        borderPoint2.x = i;
        borderPoint2.z = 0;

        temp.push_back(borderPoint2);
      }
    }

  }else {//if equal or longer in y direction

    for (int i=ly; i<=hy; i++){
      double val = ((double)i-b)/m;
      ImageCube::ThreeDPoint borderPoint;
      borderPoint.x = (int)(val+0.5);
      borderPoint.y = i;
      borderPoint.z = 0;

      temp.push_back(borderPoint);

      if((int)(val+0.15) != (int)(val+0.5)){
        //if we're really close to the upper edge
        //grab the next pixel over too
        ImageCube::ThreeDPoint borderPoint2;
        borderPoint2.x = abs((int)(val+0.15));
        borderPoint2.y = i;
        borderPoint2.z = 0;

        temp.push_back(borderPoint2);

      } else if ((int)(val-0.15) != (int)(val)){
        //if we're really close to the lower edge
        //grab the next pixel over too
        ImageCube::ThreeDPoint borderPoint2;
        borderPoint2.x = (int)(val-0.15);
        borderPoint2.y = i;
        borderPoint2.z = 0;

        temp.push_back(borderPoint2);

      }
    }
  }
  return temp;
}


std::vector<ImageCube::ThreeDPoint> ImageSelectionCube::generateLine(ImageCube::ThreeDPoint s, ImageCube::ThreeDPoint f) {

  //TODO check for div by zero first
  if(-1<(f.y - s.y) && (f.y - s.y)<1){//if the line is effectivly straight vertical

    int lx, hx;

    //figure out highs and lows
    if(s.x > f.x) {
      hx = (int)(s.x) ;
      lx = (int)(f.x) ;
    } else {
      hx = (int)(f.x) ;
      lx = (int)(s.x) ;
    }

  std::vector<ImageCube::ThreeDPoint> temp;

  ImageCube::ThreeDPoint borderPoint;
    borderPoint.x = (int)lx;
    borderPoint.y = (int)f.y;
    borderPoint.z = 0;

    temp.push_back(borderPoint);

    ImageCube::ThreeDPoint borderPoint2;
    borderPoint2.x = (int)hx;
    borderPoint2.y = (int)f.y;
    borderPoint2.z = 0;

    temp.push_back(borderPoint2);

    return temp;

  }
  else if(-1<(f.x - s.x) && (f.x - s.x)<1){//if the line is straight horizantal

    int ly, hy;

    //figure out highs and lows
    if(s.y > f.y) {
      hy = (int)(s.y) ;
      ly = (int)(f.y) ;
    } else {
      hy = (int)(f.y) ;
      ly = (int)(s.y) ;
    }

    std::vector<ImageCube::ThreeDPoint> temp;

    //walk along and add pixels
    for(int i=ly; i<=hy; i++){
      ImageCube::ThreeDPoint borderPoint;
      borderPoint.x = (int)(f.x);
      borderPoint.y = (int)i;
      borderPoint.z = 0;

      temp.push_back(borderPoint);
    }

    return temp;

  }

  //if the line is not vertical or horizantal, we have more work
  else {

    double m;
    double b;

    int ly, hy;

    //figure out m and b (y=mx+b)
    if(s.x > f.x) {
      m = ((double)(s.y - f.y))/((double)(s.x - f.x));
      b = s.y - (m*(s.x));

    } else {
      m = ((double)(f.y - s.y))/((double)(f.x - s.x));
      b = s.y - (m*(s.x));
    }

    //figure out high and lowy
    if(s.y > f.y) {
      hy = (int)(s.y) ;
      ly = (int)(f.y) ;
    } else {
      hy = (int)(f.y) ;
      ly = (int)(s.y) ;
    }

    std::vector<ImageCube::ThreeDPoint> temp;

    for (int i=ly; i<=hy; i++){
      //for each y, we generate the x value and add that
      //we'll fill in the middle later

      double val = (i-b)/m;//get x
      ImageCube::ThreeDPoint borderPoint;
      borderPoint.x = abs((int)(val+0.5)) ;
      borderPoint.y = i;

      //if we round, we want know that later
      if((int)val != int(val+0.5)) borderPoint.z = 1;
      else borderPoint.z = 0;

      temp.push_back(borderPoint);
    }
    return temp;
  }
}


std::vector<ImageCube::ThreeDPoint> ImageSelectionCube::combineSortedVectors(std::vector<ImageCube::ThreeDPoint> a, std::vector<ImageCube::ThreeDPoint> b){

  std::vector<ImageCube::ThreeDPoint> temp;
  std::vector<ImageCube::ThreeDPoint>::iterator control = a.begin();
  std::vector<ImageCube::ThreeDPoint>::iterator adding = b.begin();

  while (adding < b.end()){//while we have stuff in b
    if(control < a.end()){//as long as there's stuff in a
      if((*adding).y < (*control).y) {
        temp.push_back(*adding);
        adding++;
      }else if((*control).y < (*adding).y){
        temp.push_back(*control);
        control++;
      }else{//y's are the same, so base off x's
        if((*adding).x < (*control).x) {
          temp.push_back(*adding);
          adding++;
        }else if((*control).x < (*adding).x){
          temp.push_back(*control);
          control++;
        }else {//both x and y the same, we only need one copy
          temp.push_back(*control);
          control++;
          adding++;
        }
      }

    }else{ //only b's left
      temp.push_back(*adding);
      adding++;
    }
  }//if no more in b,
  while(control < a.end()){//add anything left in a
    temp.push_back(*control);
    control++;
  }
  return temp;
}


std::vector<ImageCube::ThreeDPoint> ImageSelectionCube::removeDuplicates(std::vector<ImageCube::ThreeDPoint> theVec){
  std::vector<ImageCube::ThreeDPoint> temp = *(new std::vector<ImageCube::ThreeDPoint>());

  int tempsize = 0;

//  temp.push_back(theVec[0]);
//  tempsize++;

  for(int i=0; i < (int)(theVec.size()) ; i++){
    int j = theVec.size() - 1;
    bool match = false;

    while (j > i){
      if((theVec[i].x == theVec[j].x)&&(theVec[i].y == theVec[j].y)){
        match = true;
        break;
      }
      j--;
    }

    if(!match){
      temp.push_back(theVec[i]);
      tempsize++;
    }
/*
    if((theVec[i].x != temp[tempsize-1].x)&&(theVec[i].y != temp[tempsize-1].y)&&(theVec[i].z != temp[tempsize-1].z)){
      temp.push_back(theVec[i]);
      tempsize++;
    }
*/
  }

  return temp;

}

/*
std::vector<ImageCube::Pixel> ImageSelectionCube::getBoundaryPixels(std::vector<ImageCube::Pixel> pixs){
  //for this algorithm, a boundary pixel will be defined as
  //a pixels with at least one edge not connected to another
  //pixel in the shape
  //the output will be a vector which contains the boundary
  //pixels in clockwise order around the shape

  std::vector<ImageCube::Pixel> temp;

  return temp;
}
*/

std::vector<ImageCube::ThreeDPoint> ImageSelectionCube::generatePoints(std::vector<ImageCube::Pixel> pixs){


  return getPointsFromAngles(getAngles(pixs));
  /*
  //take in the boundary pixels, and create lines
  std::vector<ImageCube::ThreeDPoint> temp;


  //add the first pixel as the first point,
  //this will be the upper left corner
  ImageCube::ThreeDPoint point;
  point.x = pixs[0].x;
  point.y = pixs[0].y;
  point.z = 0;

  temp.push_back(point);

  ImageCube::ThreeDPoint* lastPoint = &point;
  ImageCube::Pixel* lastPix = &pixs[0];


  //loop through the rest of the pixels to find more points
  for(int i=1; i<pixs.size(); i++){

  }
  return temp;
  */
}


std::vector<double> ImageSelectionCube::getAngles(std::vector<ImageCube::Pixel> points){
  //most of this code was taken from another project and modified
  //just so you know

  //basically we're looking for the angles between pixels here
  //later, we use these angles to place points

  int xySize = points.size();
  //std::vector<double> results = *(new std::vector<double>(xySize));
  std::vector<double> results(xySize);

  int i;
  double x,y;
  double x1, x2, y1, y2, difx, dify;
  x1 = x2 = y1 = y2 = difx = dify = 0.0;


  std::vector<ImageCube::Pixel>::iterator sitor = points.begin();
  //for each pixel in the vector
  for(i=0; i<xySize; sitor++, i++){
    if(i==0){
      x1 = (*sitor).x;
      y1 = (*sitor).y;
      continue;
    }
    x = (*sitor).x;
    y = (*sitor).y;
    x2 = x;
    y2 = y;
    difx = x1-x2;
    dify = y1-y2;

    //calculate the angle from this to the last and store
    results[i] = atan2(dify,difx);
    x1 = x2;
    y1 = y2;
  }

  //redo first number to handle wraparound
/*  sitor = points->begin();
  x2 = (*sitor).x;
  y2 = (*sitor).y;
  difx = x1-x2;
  dify = y1-y2;
  results[xySize] = atan2(dify, difx);
*/
  return results;
}


std::vector<ImageCube::ThreeDPoint> ImageSelectionCube::getPointsFromAngles(std::vector<double> angles){
  //this code was taken from another project...
  //just so you know

  //here we're taking the angles, and finding local maximums, these
  //will be points.  We also make points out of inflection points

  //std::vector<ImageCube::ThreeDPoint> results = *(new std::vector<ImageCube::ThreeDPoint>());
  std::vector<ImageCube::ThreeDPoint> results;


   double lastangle = 0.0;
   double thisangle = 0.0;

   int xySize = angles.size();

  double *deltaAngles = new double[xySize];

  std::vector<double>::iterator itor = angles.begin();
  //loop through and create an array of delta angles,
  //this will later be used to find max Curvature points
  int i = 0 ;
  for(i = 0; i<xySize; i++, itor++) {
    // get the max points by checking the angle value
    thisangle = (*itor);
    if(i==0){
      lastangle = thisangle;
      continue;
    }
    else
    {
      double delta = thisangle-lastangle;
      if(delta > 3.14159){
        delta = -6.2831853 + delta;
      }
      else if(delta < -3.14159){
        delta = 6.2831853 + delta;
      }
      deltaAngles[i-1] = delta;
    }
    lastangle = thisangle;
  }

  //handle wrap around
/*  itor = mySmoothedPoints->begin();
  thisangle = (*itor);
  double delta = thisangle-lastangle;
  if(delta > 3.14159){
    delta = -6.2831853 + delta;
  }
  else if(delta < -3.14159){
    delta = 6.2831853 + delta;
  }
  deltaAngles[xySize-1] = delta;
  */

  lastangle = 0.0;
  thisangle = 0.0;
  double nextangle = 0.0;

  //now we use the change in angle to find local max and inflection
  for( i = 0 ; i < xySize ; i++ ) {
    thisangle = deltaAngles[i];

    //handles wrap-around
    if(i==0){
      lastangle = deltaAngles[xySize-1];
      nextangle = deltaAngles[i+1];
    }
    else if(i == (xySize - 1)){
      lastangle = deltaAngles[i-1];
      nextangle = deltaAngles[0];
    }
    else{
      lastangle = deltaAngles[i-1];
      nextangle = deltaAngles[i+1];
    }

    //this is a max curvature point
    if((fabs(thisangle) > fabs(lastangle)) && (fabs(thisangle) > fabs(nextangle))){

      ImageCube::ThreeDPoint temp = *(new ImageCube::ThreeDPoint());
    //  ImageCube::ThreeDPoint temp;
      temp.x = borderPixels[i].x;
      temp.y = borderPixels[i].y;
      results.push_back(temp);
    }
    //this is an inflection point
    if((thisangle > 0 && lastangle <0) || (thisangle < 0 && lastangle >0)){
      ImageCube::ThreeDPoint temp = *(new ImageCube::ThreeDPoint());
    //  ImageCube::ThreeDPoint temp;
      temp.x = borderPixels[i].x;
      temp.y = borderPixels[i].y;
      results.push_back(temp);
    }
  }

  delete[] deltaAngles;

  return results;
}

---

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