Modules/ImageProcessor/GT2005ImageProcessor/GT2005Clustering.cpp

Go to the documentation of this file.

#include "GT2005Clustering.h"

GT2005Clustering::GT2005Clustering()
{
  cl = GT2005Clusterliste();

  vhshort = 8;
  vhmiddle = 8;
  vhlong = 16;

  yshort = 0; 
  ymiddle = 80;
  ylong = 110; 
  
  hv = 20;

  vh = 4;

  lImage = 208;
  hImage = 160;

}

//a method to add a new scan-line. if the scan-line is positioned next to existing clusters, the scan-line and these 
//clusters will be merged to one cluster.
//s is the start-point of the scan-line and e the end-point. l is the length of the run measured in pixel.
void GT2005Clustering::addLine(Vector2<int> startInt, Vector2<int> endInt, int length )
{
  Vector2<double> start(startInt.x,startInt.y);
  Vector2<double> end(endInt.x,endInt.y);

  //check the direction of the run(vertical or horizontal)
  //fabs() is the the method abs() vor double
  if(fabs(start.x - end.x) < fabs(start.y - end.y))
    vertical = true;
  else
    vertical = false;
  
  //determine xmin and xmax, ymin and ymax, which are the borders of the bounding box of the 
  //lighty diagonal scan-line
  if(start.x <= end.x)
  {
    xmin = start.x;
    xmax = end.x;
  }
  else
  {
    xmin = end.x;
    xmax = start.x;
  }
  if(start.y <= end.y)
  {
    ymin = start.y;
    ymax = end.y;
  }
  else
  {
    ymin = end.y;
    ymax = start.y;
  }
  

  //clusterlist empty?
  if(cl.getEmpty())
  {
    GT2005Cluster firstCluster = GT2005Cluster(xmin,xmax,ymin,ymax);
    vhIter = cl.getVNaviBegin();
    cl.addCluster(firstCluster, vhIter, true);
  }
  else //clusterlist is not empty
  //integrates the scan-line into the clusterlist
  Cluster1(vertical);

}



void GT2005Clustering::Cluster1(bool v)
{
  //vertical or horizontal scan-line?
  if(v)
  {
    prepV(xmin); //prepare for vertical scanning
  
    //case1 or case2 ?
    //case1: there are no other clusters that are positioned between xmin and xmax
    //    only horizontal neighbours will be checked
    //case2: there are clusters that are positioned between xmin and xmax
    //    horizontal and vertical neighbours will be checked

    //case2:
    if(!((vhIter == vhIter2) || ((vhIter != vhIter2) && (cIter->getXMin() > xmax))))                    
      markV(xmin, xmax, ymin, ymax, vh);  //check vertical neighbours
    else
    {
      GT2005Cluster scanline = GT2005Cluster(xmin, xmax, ymin, ymax);
      cIter = *vhIter;
      if((vhIter != vhIter2) && (cIter->getXMin() <= xmax) && (xmin > cIter->getXMin()))
        ++vhIter;
      cl.addCluster(scanline, vhIter, true);
    }

    //case1 and second part of case2: checking for horizontal neighbours:
    //the whole scan-line is positioned in the area of the long scan-lines, so vhlong is used
    //for the modified/bounding box
    if(ymin >= ylong)
    {
      //modification of the bounding box (vhlong)
      prepH(ymin);
      if(!((vhIter == vhIter2) || ((vhIter != vhIter2) && (cIter->getYMin() > ymax))))
        markH(xmin, xmax, ymin, ymax, vhlong);
      
    } 
    //case the the beginning of the scan-line is between ymiddle and ylong (it´s not in between ylong and
    //end of scan-line, because that case is already catched in the case before this one: ymin >= ylong)
    else  if((ymin >= ymiddle) && (ymin < ylong))
    {
      //check, if the end-point of the scan-line is in the area of the long scan-lines or the middle scan-lines
      //case ymax is between ymiddle and ylong,too:
      if(ymax < ylong)
      {
        //modification of the bounding box
        prepH(ymin);
        if(!((vhIter == vhIter2) || ((vhIter != vhIter2) && (cIter->getYMin() > ymax))))
          markH(xmin, xmax, ymin, ymax, vhmiddle);  
      }
      else //ymax is between ylong and end of the image
      {
        //in this case, there will be two bounding boxes of different sizes
        //modified bounding box1  
        prepH(ymin);
        if(!((vhIter == vhIter2) || ((vhIter != vhIter2) && (cIter->getYMin() > ylong - 1))))
          markH(xmin, xmax, ymin, ylong - 1, vhmiddle);

        //modified bounding box2
        prepH(ylong - 1);
        if(!((vhIter == vhIter2) || ((vhIter != vhIter2) && (cIter->getYMin() > ymax))))
          markH(xmin, xmax, ylong - 1, ymax, vhlong);
      }//end of else (if(ymax < ylong))
    }//end of else  if(ymin >= ymiddle)

    else if((ymin >= yshort) && (ymin < ymiddle))
    {
      //ymin is positioned between yshort and ymiddle
      //check, in which area ymax is at:
      if(ymax < ymiddle) //one bounding box
      {
        //modified bounding box
        prepH(ymin);
        if(!((vhIter == vhIter2) || ((vhIter != vhIter2) && (cIter->getYMin() > ymax))))
          markH(xmin, xmax, ymin, ymax, vhshort);
      }
      else if((ylong > ymax) && (ymax >= ymiddle)) //two bounding boxes
      {
        //first modified bounding box
        prepH(ymin);
        if(!((vhIter == vhIter2) || ((vhIter != vhIter2) && (cIter->getYMin() > ymiddle-1))))
          markH(xmin, xmax, ymin, ymiddle - 1, vhshort);
        
        //second bounding box
        prepH(ymiddle -1);
        if(!((vhIter == vhIter2) || ((vhIter != vhIter2) && (cIter->getYMin() > ymax))))
          markH(xmin, xmax, ymiddle - 1, ymax, vhmiddle);
      }
      else if(ymax >= ylong) //ymax >= ylong, three bounding boxes
      {
        //first bounding box
        prepH(ymin);
        if(!((vhIter == vhIter2) || ((vhIter != vhIter2) && (cIter->getYMin() > ymiddle - 1))))
          markH(xmin, xmax, ymin, ymiddle - 1, vhshort);

        //second bounding box
        prepH(ymiddle - 1);
        if(!((vhIter == vhIter2) || ((vhIter != vhIter2) && (cIter->getYMin() > ylong - 1))))
          markH(xmin, xmax, ymiddle - 1, ylong - 1, vhmiddle);

        //third bounding box
        prepH(ylong - 1);
        if(!((vhIter == vhIter2) || ((vhIter != vhIter2) && (cIter->getYMin() > ymax))))
          markH(xmin, xmax, ylong - 1, ymax, vhlong);
      }//end of else if(ymax >= ylong) //ymax >= ylong, three bounding boxes

    }//end of else ymin >= yshort
  }//end of if(v)

  else //scan horizontal
  { 
    prepH(ymin);
    if(!((vhIter == vhIter2) || ((vhIter != vhIter2) && (cIter->getYMin() > ymax))))
      markH(xmin,xmax,ymin,ymax,vh);
    else
      {
        GT2005Cluster scanline = GT2005Cluster(xmin, xmax, ymin, ymax);
        cIter = *vhIter;
        if((vhIter != vhIter2) && (cIter->getYMin() <= ymax) && (ymin > cIter->getYMin()))
          ++vhIter;
        cl.addCluster(scanline, vhIter, false);
      }
    //case 1 and second part of case 2
    //checking vertical neighbours

    //modify bounding box, to check the vertical neighbours.
    prepV(xmin);
    if(!((vhIter == vhIter2) || ((vhIter != vhIter2) && (cIter->getXMin() > xmax)))) 
      markV(xmin, xmax, ymin, ymax,hv );      
  }//end of else (if(v))
  
}


//prepare for vertical scanning: choose vNavi, set the iterators and skip not interessting clusters
//o means: use the bounding box of the scan-line: xmin,xmax,ymin,ymax
//otherwise use the modified bounding box, xn,xx,yn,yx

void GT2005Clustering::prepV(double xminimum)
{
    //choose the list vNavi, which stores the navigation-information for vertical scanning
    vhIter = cl.getVNaviBegin(); //begin of the navigation-information list
    vhIter2 = cl.getVNaviEnd();
    cIter = *vhIter; //pointer to a cluster in clist

    //skip clusters that are not interessting for the clustering in vertical-direction.
    while((vhIter != vhIter2) && (cIter->getXMax() < xminimum))
    {
      ++vhIter;
      if(vhIter != vhIter2)
        cIter = *vhIter;
    }
    
}

//prepare for horizontal scanning: choose hNavi, set the iterators and skip not interessting clusters
//o means: use the bounding box of the scan-line: xmin,xmax,ymin,ymax
//otherwise use the modified bounding box, xn,xx,yn,yx
void GT2005Clustering::prepH(double yminimum)
{
  //choose the list hNavi, which stores the navigation-information for horizontal scanning
  vhIter = cl.getHNaviBegin(); //begin of the navigation-information list
  vhIter2 = cl.getHNaviEnd(); //end of the navigation-information list
  cIter = *vhIter; //pointer to a cluster in clist
  
  //skip clusters that are not interessting for the clustering in horizontal-direction.
  while((vhIter != vhIter2) && (cIter->getYMax() < yminimum))
  {
    ++vhIter;
    if(vhIter != vhIter2)
      cIter = *vhIter;
  }
}




void GT2005Clustering::markV(double xminimum, double xmaximum, double yminimum, double ymaximum, int expansion )
{
  //initialize the iterator to mark the range of candidate at the beginning of every marking and clustering
  //process
  cfirst = NULL;
  clast = NULL;
  //in case that there are no other clusters, which will be taken into account, too,
  cinput = vhIter; 

    
  cIter = *vhIter;
  //if this constrain is not satisfied, the cluster already skipped the range xn-xx/xmin-xmax
  while((vhIter != vhIter2) && (cIter->getXMin() <= xmaximum))
  {
    //if this constrain is not satisfied, the cluster is positioned before the range xn-xx
    if(cIter->getXMax() >= xminimum)
    {
      //candidates
      //vd is the distance between clusters in vertical scanning
      if((cIter->getYMax() >= (yminimum - expansion)) && (cIter->getYMin() <= (ymaximum + expansion)))
      {
        if(cfirst == NULL)
          cfirst = vhIter;
        clast = vhIter;
        cIter->setCandidate(true);
      }
    }// end of if(cIter->getXMax() >= xminimum)
    ++vhIter;
    if(vhIter != vhIter2)
      cIter = *vhIter;
  }//end of while((vhIter != vhIter2) && (cIter->getXMin() <= xmaximum))

  if(cfirst != NULL)
  {
    clusterFinal(true, xminimum,xmaximum,yminimum,ymaximum);
  }
  else
  {
    GT2005Cluster scanline = GT2005Cluster(xminimum, xmaximum, yminimum, ymaximum);
    cIter = *cinput;
    if((cinput != vhIter2) && (cIter->getXMin() <= xmaximum) && (xminimum > cIter->getXMin()))
      ++cinput;
    cl.addCluster(scanline, cinput, true);
  }
}



void GT2005Clustering::markH(double xminimum, double xmaximum, double yminimum, double ymaximum, int expansion)
{
  //initialize the iterator to mark the range of candidate at the beginning of every marking and clustering 
  //process
  cfirst = NULL;
  clast = NULL;
  cinput = vhIter;

  cIter = *vhIter;
  //if this constrain is not satisfied, the cluster already skipped the range yn-yx
  while((vhIter != vhIter2) && (cIter->getYMin() <= ymaximum))
  {
    //if this constrain is not satisfied, the cluster is positioned before the range yn-yx
    if(cIter->getYMax() >= yminimum)
    { 
      if((cIter->getXMin() <= (xmaximum + expansion)) && (cIter->getXMax() >= (xminimum - expansion)))
      {
        if(cfirst == NULL)
          cfirst = vhIter;
        clast = vhIter;
        cIter->setCandidate(true);
      }//end of if((cIter->getXMin() <= xmaximum) && (cIter->getXMax() >= xminimum))

    }//end of if(cIter->getYMax() >= yminimum)
    ++vhIter;
    if(vhIter != vhIter2)
      cIter = *vhIter;
  }//end of while((vhIter != vhIter2) && (cIter->getYMin() <= ymaximum))

  if(cfirst != NULL)
  {
    clusterFinal(false, xminimum,xmaximum,yminimum,ymaximum);
  }
  else
  {
    GT2005Cluster scanline = GT2005Cluster(xminimum, xmaximum, yminimum, ymaximum);
    cIter = *cinput;
    if((cinput != vhIter2) && (cIter->getYMin() <= ymaximum) && (yminimum > cIter->getYMin()))
      ++cinput;
    cl.addCluster(scanline, cinput, false);
  }

}

void GT2005Clustering::clusterFinal(bool v, double xminimum, double xmaximum, double yminimum, double ymaximum)
{
  //borders of the new cluster
  double newXMIN;
  double newXMAX;
  double newYMIN;
  double newYMAX;
  
  cIter = *cfirst;
  if(xminimum < cIter->getXMin())
    newXMIN = xminimum;
  else
    newXMIN = cIter->getXMin();
  if(xmaximum > cIter->getXMax())
    newXMAX = xmaximum;
  else
    newXMAX = cIter->getXMax();
  if(yminimum < cIter->getYMin())
    newYMIN = yminimum;
  else
    newYMIN = cIter->getYMin();
  if(ymaximum > cIter->getYMax())
    newYMAX = ymaximum;
  else
    newYMAX = cIter->getYMax();
  

  //define position for the new cluster:
  if(v)
  {
    if(cfirst == cl.getVNaviBegin())
      cinput = NULL;
    else
    {
      cinput = --cfirst;
      ++cfirst;
    }
  }//end of if(v)
  else
  {
    if(cfirst == cl.getHNaviBegin())
      cinput = NULL;
    else
    {
      cinput = --cfirst;
      ++cfirst;
    }
  }

  ++cfirst; // cfirst already was taken into account
  ++clast;//in order to include clast   
  for(vhIter = cfirst; vhIter != clast; ++vhIter)
  {
    cl.removeCluster(cIter);
    cIter = *vhIter;
    if(cIter->getCandidate() == true)
    {
      if(cIter->getXMin() < newXMIN)
        newXMIN = cIter->getXMin();
      if(cIter->getXMax() > newXMAX)
        newXMAX = cIter->getXMax();
      if(cIter->getYMin() < newYMIN)
        newYMIN = cIter->getYMin();
      if(cIter->getYMax() > newYMAX)
        newYMAX = cIter->getYMax();
    }
  }
  cl.removeCluster(cIter);

  //build cluster and add it to the clusterlist:
  GT2005Cluster newCluster = GT2005Cluster(newXMIN, newXMAX, newYMIN, newYMAX);
  if(cinput == NULL)
  {
    if(v)
      cinput = cl.getVNaviBegin();
    else
      cinput = cl.getHNaviBegin();
  }
  else
    ++cinput;
  cl.addCluster(newCluster, cinput, v);

}

int GT2005Clustering::getSize()
{
  hlist.clear();  
  hlist = cl.getMidpoints();
  return(hlist.size());
}


Vector2<double> GT2005Clustering::getMidpoint(int e)
{
  hlist.clear();
  hlist = cl.getMidpoints();

  hiterator = hlist.begin();
  for(int i = 0; i < e; ++i)
  {
    ++hiterator;
  }
  return (*hiterator);
}

Vector2<double> GT2005Clustering::getMidpointX(int e)
{
  vhIter = cl.getVNaviBegin();
  for(int i = 0; i < e; ++i)
  {
    ++vhIter;
  }
  cIter = *vhIter;
  return(cIter->getMidpoint());
}
 
Vector2<double> GT2005Clustering::getMidpointY(int e)
{
  vhIter = cl.getHNaviBegin();
  for(int i = 0; i < e; ++i)
  {
    ++vhIter;
  }
  cIter = *vhIter;
  return(cIter->getMidpoint());
}

GT2005Cluster GT2005Clustering::getClusterX(int e)
{
  vhIter = cl.getVNaviBegin();
  for(int i = 0; i < e; ++i)
  {
    ++vhIter;
  }
  cIter = *vhIter;
  return(*cIter);
}

GT2005Cluster GT2005Clustering::getClusterY(int e)
{
  vhIter = cl.getHNaviBegin();
  for(int i = 0; i < e; ++i)
  {
    ++vhIter;
  }
  cIter = *vhIter;
  return(*cIter);
}

void GT2005Clustering::reset()
{
  cl.deleteAll();
}

---