Exemplo n.º 1
0
  //static
  void GradientsMergeMosaic::featherMask(weightImageType_t &rMask_p, int32 featherRadius_p)
  {
#if 0
    // create test pattern
    int const nCols=rMask_p.Width();
    int const nRows=rMask_p.Height();
    int const nChannels=rMask_p.NumberOfChannels();
    rMask_p.Black();
    for(int channel=0;channel<nChannels;++channel){
      for(int col=nCols*0.25;col<nCols*0.75;++col){
	for(int row=0;row<nRows;row++){
	  rMask_p.Pixel(col,row,channel)=1.0;
	}
      }
    }
#endif
    if(featherRadius_p<=0){
      // nothing to do
      return;
    }
    // first, I need to shrink the mask, then convolve
    TimeMessage startFeatherErode("Erode mask for feathering");
    // FIXME this is quite slow for featherRadius_p>20.
    // We would need a separable erode, promised by Juan...
    //    erodeMask(rMask_p, featherRadius_p);
    // FIXME this is quick workaround, using separable convolution instead
    erodeMaskConvolve(rMask_p, featherRadius_p);
    startFeatherErode.Stop();

    TimeMessage startFeatherConvolve("ConvolveMask for feathering");
    convolveMask(rMask_p, featherRadius_p);
    startFeatherConvolve.Stop();
  }
Exemplo n.º 2
0
  ///static
  void GradientsMergeMosaic::addBorder(weightImageType_t const & rFullMask_p, weightImageType_t &rShrinkedMask_p)
  {
    int const nCols=rShrinkedMask_p.Width();
    int const nRows=rShrinkedMask_p.Height();
    int const nChannels=rShrinkedMask_p.NumberOfChannels();
    Assert(nCols==rFullMask_p.Width());
    Assert(nRows==rFullMask_p.Height());
    Assert(nChannels==rFullMask_p.NumberOfChannels());

    // multiple channels really not necessary, but who cares...
    for(int channel=0;channel<nChannels;++channel){
      for(int col=0;col<nCols;++col){
	for(int row=0;row<nRows;row++){
	  if(rFullMask_p.Pixel(col,row,channel)!=0.0 && rShrinkedMask_p.Pixel(col,row,channel)==0){
	    rShrinkedMask_p.Pixel(col,row,channel)= -1.0;
	  }
	}
      }
    }
  }
Exemplo n.º 3
0
  //static
  void GradientsMergeMosaic::mergeMosaicProcessImage(imageType_t const & rImage_p, realType_t dBlackPoint_p,
						     pcl_enum eType_p,
						     int32 shrinkCount_p,
						     int32 featherRadius_p,
						     imageType_t &rSumImageDx_p,
						     imageType_t &rSumImageDy_p,
						     sumMaskImageType_t &rSumMaskImage_p,
						     weightImageType_t &rCountImageDx_p,
						     weightImageType_t &rCountImageDy_p)
  {
#ifdef DEBUG
    int const nCols=rImage_p.Width();
    int const nRows=rImage_p.Height();
    int const nChannels=rImage_p.NumberOfChannels();
#endif
    Assert(nCols==rSumImageDx_p.Width()+1);
    Assert(nRows==rSumImageDx_p.Height());
    Assert(nChannels==rSumImageDx_p.NumberOfChannels());

    Assert(nCols==rSumImageDy_p.Width());
    Assert(nRows==rSumImageDy_p.Height()+1);
    Assert(nChannels==rSumImageDy_p.NumberOfChannels());

    Assert(nCols==rSumMaskImage_p.Width());
    Assert(nRows==rSumMaskImage_p.Height());
    Assert(1==rSumMaskImage_p.NumberOfChannels());

    Assert(eType_p!=GradientsMergeMosaicType::Average || nCols==rCountImageDx_p.Width()+1);
    Assert(eType_p!=GradientsMergeMosaicType::Average || nRows==rCountImageDx_p.Height());
    Assert(eType_p!=GradientsMergeMosaicType::Average || 1==rCountImageDx_p.NumberOfChannels());
    Assert(eType_p!=GradientsMergeMosaicType::Average || nCols==rCountImageDy_p.Width());
    Assert(eType_p!=GradientsMergeMosaicType::Average || nRows==rCountImageDy_p.Height()+1);
    Assert(eType_p!=GradientsMergeMosaicType::Average || 1==rCountImageDy_p.NumberOfChannels());

    Assert(shrinkCount_p>=0);
    Assert(featherRadius_p>=0);
    Assert(dBlackPoint_p>=0.0);
    weightImageType_t maskImage;

    TimeMessage startAddImage("Adding image to data");

    TimeMessage startBinarize("Binarize Image");
    binarizeImage(rImage_p,dBlackPoint_p,maskImage);
    // save this for border computation later
    weightImageType_t fullMask(maskImage);
    startBinarize.Stop();

    // we are doing this because image after StarAlign usually contain aliased pixels.
    // These must not to be used during merge.
    TimeMessage startShrink("Shrinking mask");
    erodeMask(maskImage,shrinkCount_p);
    startShrink.Stop();
    TimeMessage startFeather("Feathering mask");
    featherMask(maskImage,featherRadius_p);
    startFeather.Stop();

    TimeMessage startBorder("Computing border");
    addBorder(fullMask,maskImage);
    fullMask.AllocateData(0,0); // save memory
    startBorder.Stop();

    TimeMessage startSumMask("Creating combined mask");
    addToMask(maskImage,eType_p,rSumMaskImage_p);
    startSumMask.Stop();
    TimeMessage startAddGradients("Adding gradients data");
    addToImage(rImage_p,eType_p,maskImage,rSumImageDx_p,rSumImageDy_p,rCountImageDx_p, rCountImageDy_p);
    startAddGradients.Stop();
  }