                 switch self {
                 case .none:
                     source.withUnsafeBytes { (source: UnsafePointer<Pixel>) in
-                        filling { point in
+                        _filling { point in
                             let _x = Int(point.x)
                             let _y = Int(point.y)
                             return 0..<s_width ~= _x && 0..<s_height ~= _y ? source[_y * s_width + _x] : Pixel()
                         }
                     }
                 default:
+                    
+                    @inline(__always)
+                    func filling(operation: (Point) -> ColorPixel<Pixel.Model>) {
+                        
+                        if antialias {
+                            
+                            var buffer = buffer
+                            
+                            var _p = Point(x: 0, y: 0)
+                            let _p1 = Point(x: 1, y: 0) * transform
+                            let _p2 = Point(x: 0, y: 1) * transform
+                            
+                            let _q1 = Point(x: -0.4, y: -0.4) * transform
+                            let _q2 = Point(x: 0.2, y: 0) * transform
+                            let _q3 = Point(x: 0, y: 0.2) * transform
+                            
+                            for _ in 0..<height {
+                                var p = _p
+                                for _ in 0..<width {
+                                    var _q = p + _q1
+                                    var pixel = ColorPixel<Pixel.Model>()
+                                    for _ in 0..<5 {
+                                        var q = _q
+                                        for _ in 0..<5 {
+                                            pixel += operation(q)
+                                            q += _q2
+                                        }
+                                        _q += _q3
+                                    }
+                                    buffer.pointee = Pixel(pixel * 0.04)
+                                    buffer += 1
+                                    p += _p1
+                                }
+                                _p += _p2
+                            }
+                        } else {
+                            _filling { Pixel(operation($0)) }
+                        }
+                    }
                     
                     let _source = Pixel.self is ColorPixel<Pixel.Model>.Type ? source : source._memmap { (pixel: Pixel) in ColorPixel(pixel) }
                     

    
    @_versioned
    @inline(__always)
    func convolve<Pixel: ColorPixelProtocol>(source: UnsafePointer<ColorPixel<Pixel.Model>>, width: Int, height: Int, point: Point, kernel_size: Int, kernel: (Double) -> Double) -> Pixel {
        
        var pixel = ColorPixel<Pixel.Model>()
        var t: Double = 0
        
        let _x = Int(point.x)

            let a3 = sampler(_tx, _s9.opacity, _s10.opacity, _s11.opacity, _s12.opacity)
            let a4 = sampler(_tx, _s13.opacity, _s14.opacity, _s15.opacity, _s16.opacity)
            
            return ColorPixel<ColorModel>(color: color, opacity: sampler(_ty, a1, a2, a3, a4))
            
        } else {
            return ColorPixel<ColorModel>()
        }
    }
}
