+(UIImage *)coreBlurImage:(UIImage *)image withBlurNumber:(CGFloat)blur 
{ 
  CIContext *context = [CIContext contextWithOptions:nil]; 
  CIImage *inputImage= [CIImage imageWithCGImage:image.CGImage]; 
  //设置filter
  CIFilter *filter = [CIFilter filterWithName:@"CIGaussianBlur"]; 
  [filter setValue:inputImage forKey:kCIInputImageKey]; [filter setValue:@(blur) forKey: @"inputRadius"]; 
  //模糊图片
  CIImage *result=[filter valueForKey:kCIOutputImageKey]; 
  CGImageRef outImage=[context createCGImage:result fromRect:[result extent]];    
  UIImage *blurImage=[UIImage imageWithCGImage:outImage];      
  CGImageRelease(outImage); 
  return blurImage;
}

/**
   * 使用RenderScript实现高斯模糊的算法
   * @param bitmap
   * @return
   */
public Bitmap blur(Bitmap bitmap){
 //Let's create an empty bitmap with the same size of the bitmap we want to blur
 Bitmap outBitmap = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);
 //Instantiate a new Renderscript
 RenderScript rs = RenderScript.create(getApplicationContext());
 //Create an Intrinsic Blur Script using the Renderscript
 ScriptIntrinsicBlur blurScript = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
 //Create the Allocations (in/out) with the Renderscript and the in/out bitmaps
 Allocation allIn = Allocation.createFromBitmap(rs, bitmap);
 Allocation allOut = Allocation.createFromBitmap(rs, outBitmap);
 //Set the radius of the blur: 0 < radius <= 25
 blurScript.setRadius(20.0f);
 //Perform the Renderscript
 blurScript.setInput(allIn);
 blurScript.forEach(allOut);
 //Copy the final bitmap created by the out Allocation to the outBitmap
 allOut.copyTo(outBitmap);
 //recycle the original bitmap
 bitmap.recycle();
 //After finishing everything, we destroy the Renderscript.
 rs.destroy();
 return outBitmap;
}

GaussianBlurFilter filter = new GaussianBlurFilter();
filter.setSigma(10);

RxImageData.bitmap(bitmap).addFilter(filter).into(image2);

public class GaussianBlurFilter implements CommonFilter {
 private float[] kernel;
 private double sigma = 2;
 ExecutorService mExecutor;
 CompletionService<Void> service;
 public GaussianBlurFilter() {
  kernel = new float[0];
 }
 public void setSigma(double a) {
  this.sigma = a;
 }
 @Override
   public ImageProcessor filter(final ImageProcessor src){
  final int width = src.getWidth();
  final int height = src.getHeight();
  final int size = width*height;
  int dims = src.getChannels();
  makeGaussianKernel(sigma, 0.002, (int)Math.min(width, height));
  mExecutor = TaskUtils.newFixedThreadPool("cv4j",dims);
  service = new ExecutorCompletionService<>(mExecutor);
  // save result
  for (int i=0; i<dims; i++) {
   final int temp = i;
   service.submit(new Callable<Void>() {
    public Void call() throws Exception {
     byte[] inPixels = src.tobyte(temp);
     byte[] temp = new byte[size];
     blur(inPixels, temp, width, height);
     // H Gaussian
     blur(temp, inPixels, height, width);
     // V Gaussain
     return null;
    }
   }
   );
  }
  for (int i = 0; i < dims; i++) {
   try {
    service.take();
   }
   catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
  mExecutor.shutdown();
  return src;
 }
 /**
   * <p> here is 1D Gaussian    , </p>
   *
   * @param inPixels
   * @param outPixels
   * @param width
   * @param height
   */
 private void blur(byte[] inPixels, byte[] outPixels, int width, int height)
   {
  int subCol = 0;
  int index = 0, index2 = 0;
  float sum = 0;
  int k = kernel.length-1;
  for (int row=0; row<height; row++) {
   int c = 0;
   index = row;
   for (int col=0; col<width; col++) {
    sum = 0;
    for (int m = -k; m< kernel.length; m++) {
     subCol = col + m;
     if(subCol < 0 || subCol >= width) {
      subCol = 0;
     }
     index2 = row * width + subCol;
     c = inPixels[index2] & 0xff;
     sum += c * kernel[Math.abs(m)];
    }
    outPixels[index] = (byte)Tools.clamp(sum);
    index += height;
   }
  }
 }
 public void makeGaussianKernel(final double sigma, final double accuracy, int maxRadius) {
  int kRadius = (int)Math.ceil(sigma*Math.sqrt(-2*Math.log(accuracy)))+1;
  if (maxRadius < 50) maxRadius = 50;
  // too small maxRadius would result in inaccurate sum.
  if (kRadius > maxRadius) kRadius = maxRadius;
  kernel = new float[kRadius];
  for (int i=0; i<kRadius; i++)        // Gaussian function
  kernel[i] = (float)(Math.exp(-0.5*i*i/sigma/sigma));
  double sum;
  // sum over all kernel elements for normalization
  if (kRadius < maxRadius) {
   sum = kernel[0];
   for (int i=1; i<kRadius; i++)
           sum += 2*kernel[i];
  } else
        sum = sigma * Math.sqrt(2*Math.PI);
  for (int i=0; i<kRadius; i++) {
   double v = (kernel[i]/sum);
   kernel[i] = (float)v;
  }
  return;
 }
}