SpecificationMathsKernel

kernel SpecificationMathsKernel : ImageComputationKernel<ePixelWise>
{
  Image<eWrite, eAccessPoint> dst;

  void define()
  {
    /// Math functions cannot be used when providing params default values.
  }

local:
  float4 local1;
  float local2;

  void init() {
    /// Math functions can be used to initialise locals in init().
    local1 = float4(cos(sin(float4(3.0f))));
    local2 = acos(asin(0.5f));
  }

  void MathFunctionsExample() {
    SampleType(dst) pixel = SampleType(dst)(0.5f);

    /// The following math functions are defined on both scalar and vector float types.
    /// i.e. float, float1, float2, float3 and float4.
    /// On vectors the math function is applied to each component element-wise
    /// For example: sin(float2(1.0f, 2.0f)) is equivalent to float2(sin(1.0f), sin(2.0f)).
    /// When a function takes multiple arguments the same logic is applied to each argument element-wise.

    /// Trigonometric functions:
    // floatn sin(floatn a);
    pixel = sin(pixel);
    // floatn cos(floatn a);
    pixel = cos(pixel);
    // floatn tan(floatn a);
    pixel = tan(pixel);
    // floatn asin(floatn a);
    pixel = asin(pixel);
    // floatn acos(floatn a);
    pixel = acos(pixel);
    // floatn atan(floatn a);
    pixel = atan(pixel);
    // floatn atan2(floatn a, floatn b);
    pixel = atan2(pixel, pixel);

    /// Logarithmic, exponential and power functions:
    // floatn exp(floatn x);
    // Returns the natural exponent, e^x.
    pixel = exp(pixel);
    // floatn log(floatn x);
    // Returns the natural log, log x of base e.
    pixel = log(pixel);
    // floatn log2(floatn x);
    // Returns the log x of base 2.
    pixel = log2(pixel);
    // floatn log10(floatn x);
    // Returns the log x of base 10.
    pixel = log10(pixel);
    // floatn pow(floatn x, floatn a);
    // Returns x^a.
    pixel = pow(pixel, pixel);
    // floatn sqrt(floatn x);
    // Returns the positive square root of x.
    pixel = sqrt(pixel);
    // floatn rsqrt(floatn x);
    // Returns the inverse square root of x, i.e. 1.0f/sqrt(x).
    pixel = rsqrt(pixel + 1.0f);

    /// Rounding functions:
    // floatn floor(floatn x);
    // Returns x rounded to an integer towards negative infinity.
    pixel = floor(pixel);
    // floatn ceil(floatn x);
    // Returns x rounded to an integer towards positive infinity.
    pixel = ceil(pixel);
    // floatn round(floatn x);
    // Returns x rounded to the nearest integer, ties rounded to even.
    pixel = round(pixel);

    /// Absolute and sign functions:
    // floatn fabs(floatn x);
    // Returns the absolute value of x.
    pixel = fabs(pixel);

    // floatn sign(floatn x);
    // Returns the value of the sign bit of x i.e. 1.0f for positive values,
    // -1.0f for negative values and 0.0f for +/-0.0f.
    pixel = sign(pixel);

    /// Remainder functions:
    // floatn fmod(floatn x, floatn y);
    // Returns the floating point remainder of the division of x / y.
    pixel = fmod(pixel, SampleType(dst)(0.5f));

    /// Clamping functions:
    // floatn min(floatn x, floatn y);
    pixel = min(pixel, SampleType(dst)(0.5f));
    // floatn max(floatn x, floatn y);
    pixel = max(pixel, SampleType(dst)(0.5f));
    // floatn clamp(floatn x, floatn y, floatn z);
    pixel = clamp(pixel, SampleType(dst)(0.0f), SampleType(dst)(1.0f));

    /// Interpolation functions:
    // floatn lerp(floatn a, floatn b, floatn t);
    // Returns the linear interpolation/extrapolation between two points a and b
    // i.e. a + t(b - a)
    pixel = lerp(pixel, SampleType(dst)(1.0f), SampleType(dst)(0.5f));


    /// Special cases:
    /// These functions don't follow the standard pattern on vectors like the above functions, but instead compute something bespoke.

    // float dot(floatn x, floatn y);
    // Returns the dot product of x dot y.
    float dotProduct = dot(pixel, pixel);

    // float3 cross(float3 x, float3 y);
    // Returns the cross product of x cross y.
    float3 crossProduct = cross(float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f));

    // int length(floatn x);
    // Returns the number of elements in a vector i.e. length(float2(1.0f, 2.0f)) -> 2
    int len = length(pixel);

    // floatn normalize(floatn x);
    // Returns the L2-Norm of x.
    pixel = normalize(pixel);

    // float median(float data[], int size);
    // Returns the median value in an array of data of length size.
    float arr[6] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f};
    float med = median(arr, 6);

    dst() = pixel;
  }

  void process(int2 pos) {
    MathFunctionsExample();
  }
};
Copy code