#import "GPUImageiOSBlurFilter.h"
#import "GPUImageSaturationFilter.h"
#import "GPUImageGaussianBlurFilter.h"
#import "GPUImageLuminanceRangeFilter.h"

@implementation GPUImageiOSBlurFilter

@synthesize blurRadiusInPixels;
@synthesize saturation;
@synthesize downsampling = _downsampling;

#pragma mark -
#pragma mark Initialization and teardown

- (id)init;
{
    if (!(self = [super init]))
    {
		return nil;
    }
    
    // First pass: downsample and desaturate
    saturationFilter = [[GPUImageSaturationFilter alloc] init];
    [self addFilter:saturationFilter];
    
    // Second pass: apply a strong Gaussian blur
    blurFilter = [[GPUImageGaussianBlurFilter alloc] init];
    [self addFilter:blurFilter];
    
    // Third pass: upsample and adjust luminance range
    luminanceRangeFilter = [[GPUImageLuminanceRangeFilter alloc] init];
    [self addFilter:luminanceRangeFilter];
        
    [saturationFilter addTarget:blurFilter];
    [blurFilter addTarget:luminanceRangeFilter];
    
    self.initialFilters = [NSArray arrayWithObject:saturationFilter];
    self.terminalFilter = luminanceRangeFilter;
    
    self.blurRadiusInPixels = 12.0;
    self.saturation = 0.8;
    self.downsampling = 4.0;
    self.rangeReductionFactor = 0.6;

    return self;
}

- (void)setInputSize:(CGSize)newSize atIndex:(NSInteger)textureIndex;
{
    if (_downsampling > 1.0)
    {
        CGSize rotatedSize = [saturationFilter rotatedSize:newSize forIndex:textureIndex];

        [saturationFilter forceProcessingAtSize:CGSizeMake(rotatedSize.width / _downsampling, rotatedSize.height / _downsampling)];
        [luminanceRangeFilter forceProcessingAtSize:rotatedSize];
    }
    
    [super setInputSize:newSize atIndex:textureIndex];
}

#pragma mark -
#pragma mark Accessors

// From Apple's UIImage+ImageEffects category:

// A description of how to compute the box kernel width from the Gaussian
// radius (aka standard deviation) appears in the SVG spec:
// http://www.w3.org/TR/SVG/filters.html#feGaussianBlurElement
//
// For larger values of 's' (s >= 2.0), an approximation can be used: Three
// successive box-blurs build a piece-wise quadratic convolution kernel, which
// approximates the Gaussian kernel to within roughly 3%.
//
// let d = floor(s * 3*sqrt(2*pi)/4 + 0.5)
//
// ... if d is odd, use three box-blurs of size 'd', centered on the output pixel.


- (void)setBlurRadiusInPixels:(CGFloat)newValue;
{
    blurFilter.blurRadiusInPixels = newValue;
}

- (CGFloat)blurRadiusInPixels;
{
    return blurFilter.blurRadiusInPixels;
}

- (void)setSaturation:(CGFloat)newValue;
{
    saturationFilter.saturation = newValue;
}

- (CGFloat)saturation;
{
    return saturationFilter.saturation;
}

- (void)setDownsampling:(CGFloat)newValue;
{
    _downsampling = newValue;
}

- (void)setRangeReductionFactor:(CGFloat)rangeReductionFactor
{
    luminanceRangeFilter.rangeReductionFactor = rangeReductionFactor;
}

- (CGFloat)rangeReductionFactor
{
    return luminanceRangeFilter.rangeReductionFactor;
}

@end