# vispy.glsl.build_spatial_filters module

A filter is a shader that transform the current displayed texture. Since shaders cannot be easily serialized within the GPU, they have to be well structured on the python side such that we can possibly merge them into a single source code for both vertex and fragment. Consequently, there is a default code for both vertex and fragment with specific entry points such that filter knows where to insert their specific code (declarations, functions and call (or code) to be inserted in the main function).

Spatial interpolation filter classes for OpenGL textures.

Each filter generates a one-dimensional lookup table (weights value from 0 to ceil(radius)) that is uploaded to video memory (as a 1d texture) and is then read by the shader when necessary. It avoids computing weight values for each pixel. Furthemore, each 2D-convolution filter is separable and can be computed using 2 1D-convolution with same 1d-kernel (= the lookup table values).

Available filters:

> - Nearest (radius 0.5)

> - Linear (radius 1)

> - Hanning (radius 1)

> - Hamming (radius 1)

> - Hermite (radius 1)

> - Kaiser (radius 1)

> - Quadric (radius 1.5)

> - Cubic (radius 2)

> - CatRom (radius 2)

> - Mitchell (radius 2)

> - Spline16 (radius 2)

> - Spline36 (radius 4)

> - Gaussian (radius 2)

> - Bessel (radius 3.2383)

> - Sinc (radius 4)

> - Lanczos (radius 4)

> - Blackman (radius 4)

Note:

    Weights code has been translated from the antigrain geometry library
    available at http://www.antigrain.com/

class vispy.glsl.build_spatial_filters.Bessel

  Bases: `SpatialFilter`

  Bessel filter (radius = 3.2383).

  besj(x, n)

    Function BESJ calculates Bessel function of first kind of order n.

    Parameters:
      x: int

        value at which the Bessel function is required

      n int

        an integer (>=0), the order

    Notes

    C++ Mathematical Library Converted from equivalent FORTRAN library Converted by Gareth Walker for use by course 392 computational project All functions tested and yield the same results as the corresponding FORTRAN versions.

    If you have any problems using these functions please report them to M.Muldoon@UMIST.ac.uk

    Documentation available on the web http://www.ma.umist.ac.uk/mrm/Teaching/392/libs/392.html Version 1.0 8/98 29 October, 1999

    Adapted for use in AGG library by

      Andy Wilk (castor.vulgaris@gmail.com)

    Adapted for use in vispy library by

      Nicolas P. Rougier (Nicolas.Rougier@inria.fr)

  weight(x)

    Return filter weight for a distance x.

    Parameters:
      `x` 0 < float < ceil(self.radius)

        Distance to be used to compute weight.

class vispy.glsl.build_spatial_filters.Blackman

  Bases: `SpatialFilter`

  Blackman filter (radius = 4).

  weight(x)

    Return filter weight for a distance x.

    Parameters:
      `x` 0 < float < ceil(self.radius)

        Distance to be used to compute weight.

class vispy.glsl.build_spatial_filters.CatRom

  Bases: `SpatialFilter`

  Catmull-Rom filter (radius = 2).

  Weight function:

             |  0 ≤ x < 1: 0.5*(2 + x^2*(-5+x*3))
      w(x) = |  1 ≤ x < 2: 0.5*(4 + x*(-8+x*(5-x)))
             |  2 ≤ x    : 0

  weight(x)

    Return filter weight for a distance x.

    Parameters:
      `x` 0 < float < ceil(self.radius)

        Distance to be used to compute weight.

class vispy.glsl.build_spatial_filters.Cubic

  Bases: `SpatialFilter`

  Cubic filter (radius = 2).

  Weight function:

      w(x) = 1/6((x+2)^3 - 4*(x+1)^3 + 6*x^3 -4*(x-1)^3)

  weight(x)

    Return filter weight for a distance x.

    Parameters:
      `x` 0 < float < ceil(self.radius)

        Distance to be used to compute weight.

class vispy.glsl.build_spatial_filters.Gaussian

  Bases: `SpatialFilter`

  Gaussian filter (radius = 2).

  Weight function:

      w(x) = exp(-2x^2) * sqrt(2/pi)

  Note:

      This filter does not seem to be correct since:

        x = np.linspace(0, 1, 100 )
        f = weight
        z = f(x+1)+f(x)+f(1-x)+f(2-x)

        z should be 1 everywhere but it is not the case and it produces "grid
        effects".

  weight(x)

    Return filter weight for a distance x.

    Parameters:
      `x` 0 < float < ceil(self.radius)

        Distance to be used to compute weight.

class vispy.glsl.build_spatial_filters.Hamming(radius=1)

  Bases: `SpatialFilter`

  Hamming filter (radius = 1).

  Weight function:

      w(x) = 0.54 + 0.46 * cos(pi * x)

  weight(x)

    Return filter weight for a distance x.

    Parameters:
      `x` 0 < float < ceil(self.radius)

        Distance to be used to compute weight.

class vispy.glsl.build_spatial_filters.Hanning(radius=1)

  Bases: `SpatialFilter`

  Hanning filter (radius = 1).

  Weight function:

      w(x) = 0.5 + 0.5 * cos(pi * x)

  weight(x)

    Return filter weight for a distance x.

    Parameters:
      `x` 0 < float < ceil(self.radius)

        Distance to be used to compute weight.

class vispy.glsl.build_spatial_filters.Hermite(radius=1)

  Bases: `SpatialFilter`

  Hermite filter (radius = 1).

  Weight function:

      w(x) = (2*x-3)*x^2 + 1

  weight(x)

    Return filter weight for a distance x.

    Parameters:
      `x` 0 < float < ceil(self.radius)

        Distance to be used to compute weight.

class vispy.glsl.build_spatial_filters.Kaiser(b=6.33)

  Bases: `SpatialFilter`

  Kaiser filter (radius = 1).

  Weight function:

      w(x) = bessel_i0(a sqrt(1-x^2)* 1/bessel_i0(b)

  bessel_i0(x)
  weight(x)

    Return filter weight for a distance x.

    Parameters:
      `x` 0 < float < ceil(self.radius)

        Distance to be used to compute weight.

class vispy.glsl.build_spatial_filters.Lanczos

  Bases: `SpatialFilter`

  Lanczos filter (radius = 4).

  weight(x)

    Return filter weight for a distance x.

    Parameters:
      `x` 0 < float < ceil(self.radius)

        Distance to be used to compute weight.

class vispy.glsl.build_spatial_filters.Linear(radius=1)

  Bases: `SpatialFilter`

  Linear filter (radius = 1).

  Weight function:

      w(x) = 1 - x

  weight(x)

    Return filter weight for a distance x.

    Parameters:
      `x` 0 < float < ceil(self.radius)

        Distance to be used to compute weight.

class vispy.glsl.build_spatial_filters.Mitchell(b=0.3333333333333333, c=0.3333333333333333)

  Bases: `SpatialFilter`

  Mitchell-Netravali filter (radius = 2).

  Weight function:

             |  0 ≤ x < 1: p0 + x^2*(p2 + x*p3)
      w(x) = |  1 ≤ x < 2: q0 + x*(q1 + x*(q2 + x*q3))
             |  2 ≤ x    : 0

  weight(x)

    Return filter weight for a distance x.

    Parameters:
      `x` 0 < float < ceil(self.radius)

        Distance to be used to compute weight.

class vispy.glsl.build_spatial_filters.Quadric

  Bases: `SpatialFilter`

  Quadric filter (radius = 1.5).

  Weight function:

             |  0 ≤ x < 0.5: 0.75 - x*x
      w(x) = |  0.5 ≤ x < 1.5: 0.5 - (x-1.5)^2
             |  1.5 ≤ x      : 0

  weight(x)

    Return filter weight for a distance x.

    Parameters:
      `x` 0 < float < ceil(self.radius)

        Distance to be used to compute weight.

class vispy.glsl.build_spatial_filters.Sinc

  Bases: `SpatialFilter`

  Sinc filter (radius = 4).

  weight(x)

    Return filter weight for a distance x.

    Parameters:
      `x` 0 < float < ceil(self.radius)

        Distance to be used to compute weight.

class vispy.glsl.build_spatial_filters.SpatialFilter(radius=1)

  Bases: `object`

  call_code(index)
  kernel(size=2048)
  weight(x)

    Return filter weight for a distance x.

    Parameters:
      `x` 0 < float < ceil(self.radius)

        Distance to be used to compute weight.

class vispy.glsl.build_spatial_filters.Spline16

  Bases: `SpatialFilter`

  Spline16 filter (radius = 2).

  Weight function:

             |  0 ≤ x < 1: ((x-9/5)*x - 1/5)*x + 1
      w(x) = |
             |  1 ≤ x < 2: ((-1/3*(x-1) + 4/5)*(x-1) - 7/15 )*(x-1)

  weight(x)

    Return filter weight for a distance x.

    Parameters:
      `x` 0 < float < ceil(self.radius)

        Distance to be used to compute weight.

class vispy.glsl.build_spatial_filters.Spline36

  Bases: `SpatialFilter`

  Spline36 filter (radius = 3).

  Weight function:

             |  0 ≤ x < 1: ((13/11*x - 453/209)*x -3/209)*x +1
      w(x) = |  1 ≤ x < 2: ((-6/11*(x-1) - 270/209)*(x-1) -156/209)*(x-1)
             |  2 ≤ x < 3: (( 1/11*(x-2) - 45/209)*(x-2) + 26/209)*(x-2)

  weight(x)

    Return filter weight for a distance x.

    Parameters:
      `x` 0 < float < ceil(self.radius)

        Distance to be used to compute weight.

vispy.glsl.build_spatial_filters.generate_filter_code(radius)

vispy.glsl.build_spatial_filters.main()

previous

vispy.glsl package

next

vispy.io package