SDL::GFX::ImageFilter

Section: User Contributed Perl Documentation (3)
Updated: 2020-07-28
Page Index
 

NAME

SDL::GFX::ImageFilter - image filtering functions  

CATEGORY

TODO, GFX  

METHODS

 

MMX_detect

int gfx_image_MMX_detect()         CODE:
                SDL_imageFilterMMXdetect();
 

MMX_off

void gfx_image_MMX_off()         CODE:
                SDL_imageFilterMMXoff();
 

MMX_on

void gfx_image_MMX_on()         CODE:
                SDL_imageFilterMMXon();
 

add

int gfx_image_add(Src1, Src2, Dest, length)         unsigned char *Src1
        unsigned char *Src2
        unsigned char *Dest
        int length
        CODE:
                RETVAL = SDL_imageFilterAdd(Src1, Src2, Dest, length);
        OUTPUT:
                RETVAL
 

mean

int gfx_image_mean(Src1, Src2, Dest, length)         unsigned char *Src1
        unsigned char *Src2
        unsigned char *Dest
        int length
        CODE:
                RETVAL = SDL_imageFilterMean(Src1, Src2, Dest, length);
        OUTPUT:
                RETVAL
 

sub

int gfx_image_sub(Src1, Src2, Dest, length)         unsigned char *Src1
        unsigned char *Src2
        unsigned char *Dest
        int length
        CODE:
                RETVAL = SDL_imageFilterSub(Src1, Src2, Dest, length);
        OUTPUT:
                RETVAL
 

abs_diff

int gfx_image_abs_diff(Src1, Src2, Dest, length)         unsigned char *Src1
        unsigned char *Src2
        unsigned char *Dest
        int length
        CODE:
                RETVAL = SDL_imageFilterAbsDiff(Src1, Src2, Dest, length);
        OUTPUT:
                RETVAL
 

mult

int gfx_image_mult(Src1, Src2, Dest, length)         unsigned char *Src1
        unsigned char *Src2
        unsigned char *Dest
        int length
        CODE:
                RETVAL = SDL_imageFilterMult(Src1, Src2, Dest, length);
        OUTPUT:
                RETVAL
 

mult_nor

int gfx_image_mult_nor(Src1, Src2, Dest, length)         unsigned char *Src1
        unsigned char *Src2
        unsigned char *Dest
        int length
        CODE:
                RETVAL = SDL_imageFilterMultNor(Src1, Src2, Dest, length);
        OUTPUT:
                RETVAL
 

mult_div_by_2

int gfx_image_mult_div_by_2(Src1, Src2, Dest, length)         unsigned char *Src1
        unsigned char *Src2
        unsigned char *Dest
        int length
        CODE:
                RETVAL = SDL_imageFilterMultDivby2(Src1, Src2, Dest, length);
        OUTPUT:
                RETVAL
 

mult_div_by_4

int gfx_image_mult_div_by_4(Src1, Src2, Dest, length)         unsigned char *Src1
        unsigned char *Src2
        unsigned char *Dest
        int length
        CODE:
                RETVAL = SDL_imageFilterMultDivby4(Src1, Src2, Dest, length);
        OUTPUT:
                RETVAL
 

bit_and

int gfx_image_bit_and(Src1, Src2, Dest, length)         unsigned char *Src1
        unsigned char *Src2
        unsigned char *Dest
        int length
        CODE:
                RETVAL = SDL_imageFilterBitAnd(Src1, Src2, Dest, length);
        OUTPUT:
                RETVAL
 

bit_or

int gfx_image_bit_or(Src1, Src2, Dest, length)         unsigned char *Src1
        unsigned char *Src2
        unsigned char *Dest
        int length
        CODE:
                RETVAL = SDL_imageFilterBitOr(Src1, Src2, Dest, length);
        OUTPUT:
                RETVAL
 

div

int gfx_image_div(Src1, Src2, Dest, length)         unsigned char *Src1
        unsigned char *Src2
        unsigned char *Dest
        int length
        CODE:
                RETVAL = SDL_imageFilterDiv(Src1, Src2, Dest, length);
        OUTPUT:
                RETVAL
 

bit_negation

int gfx_image_bit_negation(Src1, Dest, length)         unsigned char *Src1
        unsigned char *Dest
        int length
        CODE:
                RETVAL = SDL_imageFilterBitNegation(Src1, Dest, length);
        OUTPUT:
                RETVAL
 

add_byte

int gfx_image_add_byte(Src1, Dest, length, C)         unsigned char *Src1
        unsigned char *Dest
        int length
        unsigned char C
        CODE:
                RETVAL = SDL_imageFilterAddByte(Src1, Dest, length, C);
        OUTPUT:
                RETVAL
 

add_uint

int gfx_image_add_uint(Src1, Dest, length, C)         unsigned char *Src1
        unsigned char *Dest
        int length
        unsigned int C
        CODE:
                RETVAL = SDL_imageFilterAddUint(Src1, Dest, length, C);
        OUTPUT:
                RETVAL
 

add_byte_to_half

int gfx_image_add_byte_to_half(Src1, Dest, length, C)         unsigned char *Src1
        unsigned char *Dest
        int length
        unsigned char C
        CODE:
                RETVAL = SDL_imageFilterAddByteToHalf(Src1, Dest, length, C);
        OUTPUT:
                RETVAL
 

sub_byte

int gfx_image_sub_byte(Src1, Dest, length, C)         unsigned char *Src1
        unsigned char *Dest
        int length
        unsigned char C
        CODE:
                RETVAL = SDL_imageFilterSubByte(Src1, Dest, length, C);
        OUTPUT:
                RETVAL
 

sub_uint

int gfx_image_sub_uint(Src1, Dest, length, C)         unsigned char *Src1
        unsigned char *Dest
        int length
        unsigned int C
        CODE:
                RETVAL = SDL_imageFilterSubUint(Src1, Dest, length, C);
        OUTPUT:
                RETVAL
 

shift_right

int gfx_image_shift_right(Src1, Dest, length, N)         unsigned char *Src1
        unsigned char *Dest
        int length
        unsigned char N
        CODE:
                RETVAL = SDL_imageFilterShiftRight(Src1, Dest, length, N);
        OUTPUT:
                RETVAL
 

shift_right_uint

int gfx_image_shift_right_uint(Src1, Dest, length, N)         unsigned char *Src1
        unsigned char *Dest
        int length
        unsigned char N
        CODE:
                RETVAL = SDL_imageFilterShiftRightUint(Src1, Dest, length, N);
        OUTPUT:
                RETVAL
 

mult_by_byte

int gfx_image_mult_by_byte(Src1, Dest, length, C)         unsigned char *Src1
        unsigned char *Dest
        int length
        unsigned char C
        CODE:
                RETVAL = SDL_imageFilterMultByByte(Src1, Dest, length, C);
        OUTPUT:
                RETVAL
 

shift_right_and_mult_by_byte

int gfx_image_shift_right_and_mult_by_byte(Src1, Dest, length, N, C)         unsigned char *Src1
        unsigned char *Dest
        int length
        unsigned char N
        unsigned char C
        CODE:
                RETVAL = SDL_imageFilterShiftRightAndMultByByte(Src1, Dest, length, N, C);
        OUTPUT:
                RETVAL
 

shift_left_byte

int gfx_image_shift_left_byte(Src1, Dest, length, N)         unsigned char *Src1
        unsigned char *Dest
        int length
        unsigned char N
        CODE:
                RETVAL = SDL_imageFilterShiftLeftByte(Src1, Dest, length, N);
        OUTPUT:
                RETVAL
 

shift_left_uint

int gfx_image_shift_left_uint(Src1, Dest, length, N)         unsigned char *Src1
        unsigned char *Dest
        int length
        unsigned char N
        CODE:
                RETVAL = SDL_imageFilterShiftLeftUint(Src1, Dest, length, N);
        OUTPUT:
                RETVAL
 

shift_left

int gfx_image_shift_left(Src1, Dest, length, N)         unsigned char *Src1
        unsigned char *Dest
        int length
        unsigned char N
        CODE:
                RETVAL = SDL_imageFilterShiftLeft(Src1, Dest, length, N);
        OUTPUT:
                RETVAL
 

binarize_using_threshold

int gfx_image_binarize_using_threshold(Src1, Dest, length, T)         unsigned char *Src1
        unsigned char *Dest
        int length
        unsigned char T
        CODE:
                RETVAL = SDL_imageFilterBinarizeUsingThreshold(Src1, Dest, length, T);
        OUTPUT:
                RETVAL
 

clip_to_range

int gfx_image_clip_to_range(Src1, Dest, length, Tmin, Tmax)         unsigned char *Src1
        unsigned char *Dest
        int length
        unsigned char Tmin
        unsigned char Tmax
        CODE:
                RETVAL = SDL_imageFilterClipToRange(Src1, Dest, length, Tmin, Tmax);
        OUTPUT:
                RETVAL
 

normalize_linear

int gfx_image_normalize_linear(Src1, Dest, length, Cmin, Cmax, Nmin, Nmax)         unsigned char *Src1
        unsigned char *Dest
        int length
        int Cmin
        int Cmax
        int Nmin
        int Nmax
        CODE:
                RETVAL = SDL_imageFilterNormalizeLinear(Src1, Dest, length, Cmin, Cmax, Nmin, Nmax);
        OUTPUT:
                RETVAL
 

convolve_kernel_3x3_divide

int gfx_image_convolve_kernel_3x3_divide(Src, Dest, rows, columns, Kernel, Divisor)         unsigned char *Src
        unsigned char *Dest
        int rows
        int columns
        Sint16 *Kernel
        unsigned char Divisor
        CODE:
                RETVAL = SDL_imageFilterConvolveKernel3x3Divide(Src, Dest, rows, columns, Kernel, Divisor);
        OUTPUT:
                RETVAL
 

convolve_kernel_5x5_divide

int gfx_image_convolve_kernel_5x5_divide(Src, Dest, rows, columns, Kernel, Divisor)         unsigned char *Src
        unsigned char *Dest
        int rows
        int columns
        Sint16 *Kernel
        unsigned char Divisor
        CODE:
                RETVAL = SDL_imageFilterConvolveKernel5x5Divide(Src, Dest, rows, columns, Kernel, Divisor);
        OUTPUT:
                RETVAL
 

convolve_kernel_7x7_divide

int gfx_image_convolve_kernel_7x7_divide(Src, Dest, rows, columns, Kernel, Divisor)         unsigned char *Src
        unsigned char *Dest
        int rows
        int columns
        Sint16 *Kernel
        unsigned char Divisor
        CODE:
                RETVAL = SDL_imageFilterConvolveKernel7x7Divide(Src, Dest, rows, columns, Kernel, Divisor);
        OUTPUT:
                RETVAL
 

convolve_kernel_9x9_divide

int gfx_image_convolve_kernel_9x9_divide(Src, Dest, rows, columns, Kernel, Divisor)         unsigned char *Src
        unsigned char *Dest
        int rows
        int columns
        Sint16 *Kernel
        unsigned char Divisor
        CODE:
                RETVAL = SDL_imageFilterConvolveKernel9x9Divide(Src, Dest, rows, columns, Kernel, Divisor);
        OUTPUT:
                RETVAL
 

convolve_kernel_3x3_shift_right

int gfx_image_convolve_kernel_3x3_shift_right(Src, Dest, rows, columns, Kernel, NRightShift)         unsigned char *Src
        unsigned char *Dest
        int rows
        int columns
        Sint16 *Kernel
        unsigned char NRightShift
        CODE:
                RETVAL = SDL_imageFilterConvolveKernel3x3ShiftRight(Src, Dest, rows, columns, Kernel, NRightShift);
        OUTPUT:
                RETVAL
 

convolve_kernel_5x5_shift_right

int gfx_image_convolve_kernel_5x5_shift_right(Src, Dest, rows, columns, Kernel, NRightShift)         unsigned char *Src
        unsigned char *Dest
        int rows
        int columns
        Sint16 *Kernel
        unsigned char NRightShift
        CODE:
                RETVAL = SDL_imageFilterConvolveKernel5x5ShiftRight(Src, Dest, rows, columns, Kernel, NRightShift);
        OUTPUT:
                RETVAL
 

convolve_kernel_7x7_shift_right

int gfx_image_convolve_kernel_7x7_shift_right(Src, Dest, rows, columns, Kernel, NRightShift)         unsigned char *Src
        unsigned char *Dest
        int rows
        int columns
        Sint16 *Kernel
        unsigned char NRightShift
        CODE:
                RETVAL = SDL_imageFilterConvolveKernel7x7ShiftRight(Src, Dest, rows, columns, Kernel, NRightShift);
        OUTPUT:
                RETVAL
 

convolve_kernel_9x9_shift_right

int gfx_image_convolve_kernel_9x9_shift_right(Src, Dest, rows, columns, Kernel, NRightShift)         unsigned char *Src
        unsigned char *Dest
        int rows
        int columns
        Sint16 *Kernel
        unsigned char NRightShift
        CODE:
                RETVAL = SDL_imageFilterConvolveKernel9x9ShiftRight(Src, Dest, rows, columns, Kernel, NRightShift);
        OUTPUT:
                RETVAL
 

sobel_x

int gfx_image_sobel_x(Src, Dest, rows, columns)         unsigned char *Src
        unsigned char *Dest
        int rows
        int columns
        CODE:
                RETVAL = SDL_imageFilterSobelX(Src, Dest, rows, columns);
        OUTPUT:
                RETVAL
 

sobel_x_shift_right

int gfx_image_sobel_x_shift_right(Src, Dest, rows, columns, NRightShift)         unsigned char *Src
        unsigned char *Dest
        int rows
        int columns
        unsigned char NRightShift
        CODE:
                RETVAL = SDL_imageFilterSobelXShiftRight(Src, Dest, rows, columns, NRightShift);
        OUTPUT:
                RETVAL
 

align_stack

void gfx_image_align_stack()         CODE:
                SDL_imageFilterAlignStack();
 

restore_stack

void gfx_image_restore_stack()         CODE:
                SDL_imageFilterRestoreStack();
 

AUTHORS

See ``AUTHORS'' in SDL.


 

Index

NAME
CATEGORY
METHODS
MMX_detect
MMX_off
MMX_on
add
mean
sub
abs_diff
mult
mult_nor
mult_div_by_2
mult_div_by_4
bit_and
bit_or
div
bit_negation
add_byte
add_uint
add_byte_to_half
sub_byte
sub_uint
shift_right
shift_right_uint
mult_by_byte
shift_right_and_mult_by_byte
shift_left_byte
shift_left_uint
shift_left
binarize_using_threshold
clip_to_range
normalize_linear
convolve_kernel_3x3_divide
convolve_kernel_5x5_divide
convolve_kernel_7x7_divide
convolve_kernel_9x9_divide
convolve_kernel_3x3_shift_right
convolve_kernel_5x5_shift_right
convolve_kernel_7x7_shift_right
convolve_kernel_9x9_shift_right
sobel_x
sobel_x_shift_right
align_stack
restore_stack
AUTHORS