C++ imageType_t::AllocateData方法代码示例

  //static
  void GradientsHdrComposition::logImage(imageType_t const & rCurrentImage_p,
					 imageType_t & rResultImage_p)
  {
    int const nCols=rCurrentImage_p.Width();
    int const nRows=rCurrentImage_p.Height();
    int const nChannels=rCurrentImage_p.NumberOfChannels();
    imageType_t::color_space  colorSpace=rCurrentImage_p.ColorSpace();

    if (&rCurrentImage_p != &rResultImage_p){
      rResultImage_p.AllocateData(nCols,nRows, nChannels, colorSpace);
    }
    for(int channel=0;channel<nChannels;++channel){
      for(int row=0;row<nRows;++row){
	for(int col=0;col<nCols;++col){
	  realType_t val=rCurrentImage_p.Pixel(col,row,channel);
	  if(val<=0.0) {
	    rResultImage_p.Pixel(col,row,channel)= -1000; //this is just some value to identify extremes
	  } else {
	    val=std::log(val);
	    rResultImage_p.Pixel(col,row,channel)=val;
	  }
	}
      }
    }
  }

//static
void
GradientsBase::createLaplaceVonNeumannImage(imageType_t const & rDx_p, imageType_t const rDy_p,
					imageType_t &rResultImage_p)
{

  AssertColImage(rDx_p);
  AssertColImage(rDy_p);
  int const nRowsX=rDx_p.Height();
#ifdef DEBUG
  int const nColsX=rDx_p.Width();
  int const nRowsY=rDy_p.Height();
#endif
  int const nColsY=rDy_p.Width();
  int const nRowsRes=nRowsX;
  int const nColsRes=nColsY;
  int const nChannels=rDx_p.NumberOfChannels();
  imageType_t::color_space colorSpace=rDx_p.ColorSpace();

  Assert(nRowsX>0 && nColsX>0);
  Assert(nRowsY>0 && nColsY>0);
  Assert(nRowsY+1==nRowsX && nColsY==nColsX+1);
  Assert(nChannels==rDy_p.NumberOfChannels());

  //d2x, inner part
  rResultImage_p.AllocateData(nColsRes,nRowsRes,nChannels,colorSpace);
  for(int chan=0;chan<nChannels;++chan){
    for(int row=0;row<nRowsRes;++row){
      for(int col=1;col<nColsRes-1;++col){
	rResultImage_p.Pixel(col,row,chan)=rDx_p.Pixel(col,row,chan)-rDx_p.Pixel(col-1,row,chan);
      }
    }
    //d2x, first and last column
    for(int row=0;row<nRowsRes;++row){
      rResultImage_p.Pixel(0,row,chan)=rDx_p.Pixel(0,row,chan);
      rResultImage_p.Pixel(nColsRes-1,row,chan)=-rDx_p.Pixel(nColsRes-2,row,chan);
    }

    //d2y, inner part
    for(int row=1;row<nRowsRes-1;++row){
      for(int col=0;col<nColsRes;++col){
	rResultImage_p.Pixel(col,row,chan)+=rDy_p.Pixel(col,row,chan)-rDy_p.Pixel(col,row-1,chan);
      }
    }
    //d2y, first and last row
    for(int col=0;col<nColsRes;++col){
      rResultImage_p.Pixel(col,0,chan)+=rDy_p.Pixel(col,0,chan);
      rResultImage_p.Pixel(col,nRowsRes-1,chan)-=rDy_p.Pixel(col,nRowsRes-2,chan);
    }
  }
}

  //static
  void GradientsHdrComposition::expImage(imageType_t const & rCurrentImage_p,
					 imageType_t & rResultImage_p)
  {
    int const nCols=rCurrentImage_p.Width();
    int const nRows=rCurrentImage_p.Height();
    int const nChannels=rCurrentImage_p.NumberOfChannels();
    imageType_t::color_space  colorSpace=rCurrentImage_p.ColorSpace();

    if (&rCurrentImage_p != &rResultImage_p){
      rResultImage_p.AllocateData(nCols,nRows, nChannels, colorSpace);
    }
    for(int channel=0;channel<nChannels;++channel){
      for(int row=0;row<nRows;++row){
	for(int col=0;col<nCols;++col){
	  realType_t val=rCurrentImage_p.Pixel(col,row,channel);
	  rResultImage_p.Pixel(col,row,channel)=std::exp(val);
	}
      }
    }
  }

//static
void
GradientsBase::solveImage(imageType_t const &rLaplaceImage_p, imageType_t &rSolution_p)
{
  int const nRows=rLaplaceImage_p.Height();
  int const nCols=rLaplaceImage_p.Width();
  int const nChannels=rLaplaceImage_p.NumberOfChannels();
  imageType_t::color_space colorSpace=rLaplaceImage_p.ColorSpace();

#ifdef USE_FFTW
  // adapted from http://www.umiacs.umd.edu/~aagrawal/software.html,

  AssertColImage(rLaplaceImage_p);
  // just in case we accidentally change this, because code below believes in double...
  Assert(typeid(realType_t)==typeid(double));
  // check assumption of row major format
  Assert(rLaplaceImage_p.PixelAddress(0,0)+1==rLaplaceImage_p.PixelAddress(1,0));


  rSolution_p.AllocateData(nCols,nRows,nChannels,colorSpace);
  rSolution_p.ResetSelections();
  rSolution_p.Black();

#ifdef USE_THREADS
    // threaded version
    int const nElements=nRows*nCols;
    int const nThreads=Thread::NumberOfThreads(nElements);

    if(fftw_init_threads()==0){
      throw Error("Problem initilizing threads");
    }
    fftw_plan_with_nthreads(nThreads);
#endif

  for(int chan=0;chan<nChannels;++chan){
    TimeMessage startSolver(String("FFTW Solver, Channel ")+String(chan));

    // FIXME see if fttw_allocate gives us something...
    imageType_t fcos(nCols,nRows);

#if 0
    // During experiment, the higher optimization did not give us anything except for an additional delay. May change later.
    fftw_plan pForward= fftw_plan_r2r_2d(nRows, nCols, const_cast<double *>(rLaplaceImage_p.PixelData(chan)), fcos.PixelData(), FFTW_REDFT10, FFTW_REDFT10, FFTW_MEASURE);
    fftw_plan pInverse = fftw_plan_r2r_2d(nRows, nCols, fcos.PixelData(), rSolution_p.PixelData(chan), FFTW_REDFT01, FFTW_REDFT01, FFTW_ESTIMATE);
#else
    fftw_plan pForward= fftw_plan_r2r_2d(nRows, nCols, const_cast<double *>(rLaplaceImage_p.PixelData(chan)), fcos.PixelData(), FFTW_REDFT10, FFTW_REDFT10, FFTW_MEASURE);
    fftw_plan pInverse = fftw_plan_r2r_2d(nRows, nCols, fcos.PixelData(), rSolution_p.PixelData(chan), FFTW_REDFT01, FFTW_REDFT01, FFTW_ESTIMATE);
#endif

    // find DCT
    fftw_execute(pForward);

    realType_t const pi=pcl::Pi();

    for(int row = 0 ; row < nRows; ++row){
      for(int col = 0 ; col < nCols; ++col){
	fcos.Pixel(col,row) /= 2*cos(pi*col/( (double) nCols)) - 2 + 2*cos(pi*row/((double) nRows)) - 2;
      }
    }
    fcos.Pixel(0,0)=0.0;

    // Inverse DCT
    fftw_execute(pInverse);
    fftw_destroy_plan(pForward);
    fftw_destroy_plan(pInverse);
  }
#endif
#ifdef USE_PIFFT
  // use PI FFT based solver by Carlos Milovic F.
  rLaplaceImage_p.ResetSelections();
  rSolution_p.AllocateData(nCols,nRows,nChannels,colorSpace);
  rSolution_p.ResetSelections();
  // current solver handles only one channel per run.
  for(int chan=0;chan<nChannels;++chan){
    TimeMessage startSolver(String("PIFFT Solver, Channel ")+String(chan));
    imageType_t tmpImage(nCols,nRows);
    rLaplaceImage_p.SelectChannel(chan);
    tmpImage.Assign(rLaplaceImage_p);
    __SolvePoisson(tmpImage);
    rSolution_p.SelectChannel(chan);
    rSolution_p.Mov(tmpImage);
  }
#endif
}