C++ (Cpp) rDir Examples

Example #1

File: questao5.c Project: luarkian/list2_aa_lk

Arv* moveDirRed(Arv* arv)
{
	trocarCor(arv);
	if(cor(arv->esq->esq) == RED)
	{
		arv = rDir(arv);
		trocaCor(arv);
	}
	return arv;
}

Example #2

File: questao5.c Project: luarkian/list2_aa_lk

Arv* moveEsqRed(Arv* arv)
{
	trocarCor(arv);
	if(cor(arv->dir->esq) == RED)
	{
		arv->dir = rDir(arv->dir);
		arv = rEsq(arv);
		trocarCor(arv);
	}
	return arv;
}

Example #3

File: questao5.c Project: luarkian/list2_aa_lk

Arv* auxInsere(Arv* no, int valor,int* resp, int *chave)
{
	if(no == NULL)
	{
		Arv* novo = (Arv*) malloc(sizeof(Arv));
		if(novo == NULL)
		{
			*resp = 0;
			return NULL;
		}
		novo->val = valor;
		novo->chave = *chave;
		novo->esq = NULL;
		novo->dir = NULL;
		novo->cor = RED;
		*resp = 1;
		return novo;
	}
	if(valor == no->val)
	{
		*resp = 0;	
	}
	else
	{
		if(valor > no->val)
		{
			no->dir = auxInsere(no->dir,valor,resp, chave);
		}
		else
		{
			no->esq = auxInsere(no->esq,valor,resp, chave);
		}
	}

	if((cor(no->dir) == RED) && (cor(no->esq) == BLACK))
	{
		no = rEsq(no);
	}
	if((cor(no->esq) == RED) && (cor(no->esq->esq) == RED))
	{
		no = rDir(no);
	}
	if((cor(no->esq) == RED) && (cor(no->dir) == RED))
	{
		trocarCor(no);
	}

	return no;
}

Example #4

File: ContourBoundaryDetector.C Project: ulyssesrr/carmen_lcad

// ######################################################################
Image<float> ContourBoundaryDetector::getRidge
(std::vector<Image<float> > gradImg, int r)
{
  Image<float> gradImgX = gradImg[0];
  Image<float> gradImgY = gradImg[1];

  int w = gradImg[0].getWidth();
  int h = gradImg[0].getHeight();
  Image<float> ridgeImg(w,h,NO_INIT);

  std::vector<float> dx(NUM_GRADIENT_DIRECTIONS);
  std::vector<float> dy(NUM_GRADIENT_DIRECTIONS);    
  for(uint k = 0; k < NUM_GRADIENT_DIRECTIONS; k++)
    {
      dx[k] = cos(k*2*M_PI/NUM_GRADIENT_DIRECTIONS); 
      dy[k] = sin(k*2*M_PI/NUM_GRADIENT_DIRECTIONS);
    }

  // threshold the gradient image
  std::vector<std::vector<Image<float> > > dVin(NUM_GRADIENT_DIRECTIONS); 
  for(uint k = 0; k < NUM_GRADIENT_DIRECTIONS; k++)
    dVin[k] = std::vector<Image<float> >(2);

  for(uint k = 0; k < NUM_GRADIENT_DIRECTIONS; k++)
    {
      dVin[k][0] = Image<float>(w,h,NO_INIT);
      dVin[k][1] = Image<float>(w,h,NO_INIT);

      for(int i = 0; i < w; i++)
	{
	  for(int j = 0; j < h; j++)
	    {
	      float x = 0.0;
	      float y = 0.0;

	      int ii = int(i + r*dx[k]);
	      int jj = int(j + r*dy[k]); 

	      if(ii <  0) ii = -ii;
	      if(jj <  0) jj = -jj;
	      if(ii >= w) ii = 2*w - 2 - ii;
	      if(jj >= h) jj = 2*h - 2 - jj;
	      
	      float vX = gradImgX.getVal(ii,jj); 
	      float vY = gradImgY.getVal(ii,jj);
	      if((vX*dx[k] + vY*dy[k]) < 0.0)
		{
		  x = vX;
		  y = vY;
		}
	      
	      dVin[k][0].setVal(i,j, x);
	      dVin[k][1].setVal(i,j, y);	      
	    }
	}
    }
  itsDVin = dVin;

  std::vector<Image<float> > rDir (NUM_GRADIENT_DIRECTIONS); 
  Image<float> rDirIndex(w,h,NO_INIT);

  // calculate the geometric and arithmetic ridge direction
  // and sum the two together
  for(uint k = 0; k < NUM_GRADIENT_DIRECTIONS; k++)
    {
      rDir[k] = Image<float>(w,h,NO_INIT);

      for(int i = 0; i < w; i++)
	{
	  for(int j = 0; j < h; j++)
	    {
	      float x1 = dVin[k][0].getVal(i,j);
	      float y1 = dVin[k][1].getVal(i,j);

	      uint k2 = k + NUM_RIDGE_DIRECTIONS;
	      if(k >= NUM_RIDGE_DIRECTIONS) 
		k2 = k - NUM_RIDGE_DIRECTIONS/2;

	      float x2 = dVin[k2][0].getVal(i,j);
	      float y2 = dVin[k2][1].getVal(i,j);

	      float gVal = -(x1*x2 + y1*y2);	     	      
	      if(gVal < 0.0) 
		gVal = 0.0;
	      else 
		gVal = pow(gVal, 0.5);

	      // float ax = x2 - x1;
	      // float ay = y2 - y1;
	      // float aVal =  pow(ax*ax + ay*ay, 0.5)/ 2.0;	      
	      // rDir[k].setVal(i,j, gVal + aVal);

	      rDir[k].setVal(i,j, gVal);
	    }
	}
    }

  itsRidgeDirection = rDir;

  std::vector<Image<float> > rDirMax(NUM_RIDGE_DIRECTIONS); 
  for(uint k = 0; k < NUM_RIDGE_DIRECTIONS; k++)    
    rDirMax[k] = Image<float>(w,h,ZEROS);

  // get the maximum among the directions
  for(int i = 0; i < w; i++)
    {
      for(int j = 0; j < h; j++)
	{
	  float max = 0.0; int maxk = -1;
	  for(uint k = 0; k < NUM_RIDGE_DIRECTIONS; k++)
	    {
	      float val = rDir[k].getVal(i,j);
	      if(val > max) { max = val; maxk = k; }
	    }
	  ridgeImg.setVal(i,j, max);
	  rDirIndex.setVal(i,j, maxk);
	  if(maxk != -1)
	    rDirMax[maxk].setVal(i,j, max);
	}
    }

  itsRidgeDirectionIndex = rDirIndex;
  itsRidgeDirectionMax   = rDirMax;

  return ridgeImg;
}