aboutsummaryrefslogtreecommitdiffstats
path: root/libgamma_native_method.pyx
diff options
context:
space:
mode:
authorMattias Andrée <maandree@kth.se>2022-07-21 14:53:18 +0200
committerMattias Andrée <maandree@kth.se>2022-07-21 14:53:18 +0200
commit3be28b4e8f75190d30e311f0e69da714cac62cc5 (patch)
tree95374a0ac30802f838e0fee1d7c686b66dd26b11 /libgamma_native_method.pyx
parentRemove dist (diff)
downloadpylibgamma-3be28b4e8f75190d30e311f0e69da714cac62cc5.tar.gz
pylibgamma-3be28b4e8f75190d30e311f0e69da714cac62cc5.tar.bz2
pylibgamma-3be28b4e8f75190d30e311f0e69da714cac62cc5.tar.xz
Change license to ISC, change style, improve makefile1.1.3
Signed-off-by: Mattias Andrée <maandree@kth.se>
Diffstat (limited to 'libgamma_native_method.pyx')
-rw-r--r--libgamma_native_method.pyx616
1 files changed, 616 insertions, 0 deletions
diff --git a/libgamma_native_method.pyx b/libgamma_native_method.pyx
new file mode 100644
index 0000000..96eee7c
--- /dev/null
+++ b/libgamma_native_method.pyx
@@ -0,0 +1,616 @@
+# -*- python -*-
+# See LICENSE file for copyright and license details.
+cimport cython
+
+from libc.stdint cimport *
+from libc.stdlib cimport malloc
+from libc.stddef cimport size_t
+from libc.errno cimport errno
+
+
+cdef extern from "include-libgamma.h":
+ ctypedef struct libgamma_gamma_ramps8_t:
+ # Gamma ramp structure for 8-bit gamma ramps
+ size_t red_size # The size of `red`
+ size_t green_size # The size of `green`
+ size_t blue_size # The size of `blue`
+ uint8_t *red # The gamma ramp for the red channel
+ uint8_t *green # The gamma ramp for the green channel
+ uint8_t *blue # The gamma ramp for the blue channel
+
+ ctypedef struct libgamma_gamma_ramps16_t:
+ # Gamma ramp structure for 16-bit gamma ramps
+ size_t red_size # The size of `red`
+ size_t green_size # The size of `green`
+ size_t blue_size # The size of `blue`
+ uint16_t *red # The gamma ramp for the red channel
+ uint16_t *green # The gamma ramp for the green channel
+ uint16_t *blue # The gamma ramp for the blue channel
+
+ ctypedef struct libgamma_gamma_ramps32_t:
+ # Gamma ramp structure for 32-bit gamma ramps
+ size_t red_size # The size of `red`
+ size_t green_size # The size of `green`
+ size_t blue_size # The size of `blue`
+ uint32_t *red # The gamma ramp for the red channel
+ uint32_t *green # The gamma ramp for the green channel
+ uint32_t *blue # The gamma ramp for the blue channel
+
+ ctypedef struct libgamma_gamma_ramps64_t:
+ # Gamma ramp structure for 64-bit gamma ramps
+ size_t red_size # The size of `red`
+ size_t green_size # The size of `green`
+ size_t blue_size # The size of `blue`
+ uint64_t *red # The gamma ramp for the red channel
+ uint64_t *green # The gamma ramp for the green channel
+ uint64_t *blue # The gamma ramp for the blue channel
+
+ ctypedef struct libgamma_gamma_rampsf_t:
+ # Gamma ramp structure for `float` gamma ramps
+ size_t red_size # The size of `red`
+ size_t green_size # The size of `green`
+ size_t blue_size # The size of `blue`
+ float *red # The gamma ramp for the red channel
+ float *green # The gamma ramp for the green channel
+ float *blue # The gamma ramp for the blue channel
+
+ ctypedef struct libgamma_gamma_rampsd_t:
+ # Gamma ramp structure for `double` gamma ramps
+ size_t red_size # The size of `red`
+ size_t green_size # The size of `green`
+ size_t blue_size # The size of `blue`
+ double *red # The gamma ramp for the red channel
+ double *green # The gamma ramp for the green channel
+ double *blue # The gamma ramp for the blue channel
+
+cdef extern int libgamma_gamma_ramps8_initialise(libgamma_gamma_ramps8_t *this) nogil
+'''
+Initialise a gamma ramp in the proper way that allows all adjustment
+methods to read from and write to it without causing segmentation violation
+
+The input must have `red_size`, `green_size` and `blue_size`
+set to the sizes of the gamma ramps that should be allocated
+
+@param this The gamma ramps
+@return Zero on success, -1 on allocation error, `errno` will be set accordingly
+'''
+
+cdef extern void libgamma_gamma_ramps8_free(libgamma_gamma_ramps8_t *this) nogil
+'''
+Release resources that are held by a gamma ramp strcuture that
+has been allocated by `libgamma_gamma_ramps8_initialise` or
+otherwise initialises in the proper manner, as well as release
+the pointer to the structure
+
+@param this The gamma ramps
+'''
+
+cdef extern int libgamma_gamma_ramps16_initialise(libgamma_gamma_ramps16_t *this) nogil
+'''
+Initialise a gamma ramp in the proper way that allows all adjustment
+methods to read from and write to it without causing segmentation violation
+
+The input must have `red_size`, `green_size` and `blue_size`
+set to the sizes of the gamma ramps that should be allocated
+
+@param this The gamma ramps
+@return Zero on success, -1 on allocation error, `errno` will be set accordingly
+'''
+
+cdef extern void libgamma_gamma_ramps16_free(libgamma_gamma_ramps16_t *this) nogil
+'''
+Release resources that are held by a gamma ramp strcuture that
+has been allocated by `libgamma_gamma_ramps16_initialise` or
+otherwise initialises in the proper manner, as well as release
+the pointer to the structure
+
+@param this The gamma ramps
+'''
+
+cdef extern int libgamma_gamma_ramps32_initialise(libgamma_gamma_ramps32_t *this) nogil
+'''
+Initialise a gamma ramp in the proper way that allows all adjustment
+methods to read from and write to it without causing segmentation violation
+
+The input must have `red_size`, `green_size` and `blue_size`
+set to the sizes of the gamma ramps that should be allocated
+
+@param this The gamma ramps
+@return Zero on success, -1 on allocation error, `errno` will be set accordingly
+'''
+
+cdef extern void libgamma_gamma_ramps32_free(libgamma_gamma_ramps32_t *this) nogil
+'''
+Release resources that are held by a gamma ramp strcuture that
+has been allocated by `libgamma_gamma_ramps32_initialise` or
+otherwise initialises in the proper manner, as well as release
+the pointer to the structure
+
+@param this The gamma ramps
+'''
+
+cdef extern int libgamma_gamma_ramps64_initialise(libgamma_gamma_ramps64_t *this) nogil
+'''
+Initialise a gamma ramp in the proper way that allows all adjustment
+methods to read from and write to it without causing segmentation violation
+
+The input must have `red_size`, `green_size` and `blue_size`
+set to the sizes of the gamma ramps that should be allocated
+
+@param this The gamma ramps
+@return Zero on success, -1 on allocation error, `errno` will be set accordingly
+'''
+
+cdef extern void libgamma_gamma_ramps64_free(libgamma_gamma_ramps64_t *this) nogil
+'''
+Release resources that are held by a gamma ramp strcuture that
+has been allocated by `libgamma_gamma_ramps64_initialise` or
+otherwise initialises in the proper manner, as well as release
+the pointer to the structure
+
+@param this The gamma ramps
+'''
+
+cdef extern int libgamma_gamma_rampsf_initialise(libgamma_gamma_rampsf_t *this) nogil
+'''
+Initialise a gamma ramp in the proper way that allows all adjustment
+methods to read from and write to it without causing segmentation violation
+
+The input must have `red_size`, `green_size` and `blue_size`
+set to the sizes of the gamma ramps that should be allocated
+
+@param this The gamma ramps
+@return Zero on success, -1 on allocation error, `errno` will be set accordingly
+'''
+
+cdef extern void libgamma_gamma_rampsf_free(libgamma_gamma_rampsf_t *this) nogil
+'''
+Release resources that are held by a gamma ramp strcuture that
+has been allocated by `libgamma_gamma_rampsf_initialise` or
+otherwise initialises in the proper manner, as well as release
+the pointer to the structure
+
+@param this The gamma ramps
+'''
+
+cdef extern int libgamma_gamma_rampsd_initialise(libgamma_gamma_rampsd_t *this) nogil
+'''
+Initialise a gamma ramp in the proper way that allows all adjustment
+methods to read from and write to it without causing segmentation violation
+
+The input must have `red_size`, `green_size` and `blue_size`
+set to the sizes of the gamma ramps that should be allocated
+
+@param this The gamma ramps
+@return Zero on success, -1 on allocation error, `errno` will be set accordingly
+'''
+
+cdef extern void libgamma_gamma_rampsd_free(libgamma_gamma_rampsd_t *this) nogil
+'''
+Release resources that are held by a gamma ramp strcuture that
+has been allocated by `libgamma_gamma_rampsd_initialise` or
+otherwise initialises in the proper manner, as well as release
+the pointer to the structure
+
+@param this The gamma ramps
+'''
+
+
+def libgamma_native_gamma_ramps8_create(red_size : int, green_size : int, blue_size : int):
+ '''
+ Create a gamma ramp in the proper way that allows all adjustment methods
+ to read from and write to it without causing segmentation violation
+
+ @param red_size The size of the gamma ramp for the red channel
+ @param green_size The size of the gamma ramp for the green channel
+ @param blue_size The size of the gamma ramp for the blue channel
+ @return :(int){4}|int The tuple that describes the created data, `errno` on failure:
+ Element 1: The address of the gamma ramp structure
+ Element 2: The address of the gamma ramp for the red channel
+ Element 3: The address of the gamma ramp for the green channel
+ Element 4: The address of the gamma ramp for the blue channel
+ '''
+ cdef void *allocation = malloc(sizeof(libgamma_gamma_ramps8_t))
+ cdef libgamma_gamma_ramps8_t *item = <libgamma_gamma_ramps8_t *>allocation
+ cdef size_t red, green, blue
+ if item is NULL:
+ return int(errno)
+ item.red_size = red_size
+ item.green_size = green_size
+ item.blue_size = blue_size
+ if libgamma_gamma_ramps8_initialise(item) < 0:
+ return int(errno)
+ red = <size_t><void *>(item.red)
+ green = <size_t><void *>(item.green)
+ blue = <size_t><void *>(item.blue)
+ return (int(<size_t>allocation), int(red), int(green), int(blue))
+
+
+def libgamma_native_gamma_ramps8_free(this : int):
+ '''
+ Release resources that are held by a gamma ramp strcuture that
+ has been allocated by `libgamma_native_gamma_ramps8_create` or
+ otherwise created in the proper manner, as well as release the
+ pointer to the structure
+
+ @param this The gamma ramps
+ '''
+ cdef void *address = <void *><size_t>this
+ cdef libgamma_gamma_ramps8_t *item = <libgamma_gamma_ramps8_t *>address
+ libgamma_gamma_ramps8_free(item)
+
+
+def libgamma_native_gamma_ramps8_get(this : int, index : int) -> int:
+ '''
+ Read a stop in a gamma ramp
+
+ @param this The gamma ramp
+ @param index The index of the gamma ramp stop
+ @return The value of the gamma ramp stop
+ '''
+ cdef void *address = <void *><size_t>this
+ cdef uint8_t *ramp = <uint8_t *>address
+ return int(ramp[<size_t>index])
+
+
+def libgamma_native_gamma_ramps8_set(this : int, index : int, value : int):
+ '''
+ Modify a stop in a gamma ramp
+
+ @param this The gamma ramp
+ @param index The index of the gamma ramp stop
+ @param value The value of the gamma ramp stop
+ '''
+ cdef void *address = <void *><size_t>this
+ cdef uint8_t *ramp = <uint8_t *>address
+ ramp[<size_t>index] = <uint8_t>value
+
+
+def libgamma_native_gamma_ramps16_create(red_size : int, green_size : int, blue_size : int):
+ '''
+ Create a gamma ramp in the proper way that allows all adjustment methods
+ to read from and write to it without causing segmentation violation
+
+ @param red_size The size of the gamma ramp for the red channel
+ @param green_size The size of the gamma ramp for the green channel
+ @param blue_size The size of the gamma ramp for the blue channel
+ @return :(int){4}|int The tuple that describes the created data, `errno` on failure:
+ Element 1: The address of the gamma ramp structure
+ Element 2: The address of the gamma ramp for the red channel
+ Element 3: The address of the gamma ramp for the green channel
+ Element 4: The address of the gamma ramp for the blue channel
+ '''
+ cdef void *allocation = malloc(sizeof(libgamma_gamma_ramps16_t))
+ cdef libgamma_gamma_ramps16_t *item = <libgamma_gamma_ramps16_t *>allocation
+ cdef size_t red, green, blue
+ if item is NULL:
+ return int(errno)
+ item.red_size = red_size
+ item.green_size = green_size
+ item.blue_size = blue_size
+ if libgamma_gamma_ramps16_initialise(item) < 0:
+ return int(errno)
+ red = <size_t><void *>(item.red)
+ green = <size_t><void *>(item.green)
+ blue = <size_t><void *>(item.blue)
+ return (int(<size_t>allocation), int(red), int(green), int(blue))
+
+
+def libgamma_native_gamma_ramps16_free(this : int):
+ '''
+ Release resources that are held by a gamma ramp strcuture that
+ has been allocated by `libgamma_native_gamma_ramps16_create` or
+ otherwise created in the proper manner, as well as release the
+ pointer to the structure
+
+ @param this The gamma ramps
+ '''
+ cdef void *address = <void*><size_t>this
+ cdef libgamma_gamma_ramps16_t *item = <libgamma_gamma_ramps16_t *>address
+ libgamma_gamma_ramps16_free(item)
+
+
+def libgamma_native_gamma_ramps16_get(this : int, index : int) -> int:
+ '''
+ Read a stop in a gamma ramp
+
+ @param this The gamma ramp
+ @param index The index of the gamma ramp stop
+ @return The value of the gamma ramp stop
+ '''
+ cdef void *address = <void *><size_t>this
+ cdef uint16_t *ramp = <uint16_t *>address
+ return int(ramp[<size_t>index])
+
+
+def libgamma_native_gamma_ramps16_set(this : int, index : int, value : int):
+ '''
+ Modify a stop in a gamma ramp
+
+ @param this The gamma ramp
+ @param index The index of the gamma ramp stop
+ @param value The value of the gamma ramp stop
+ '''
+ cdef void *address = <void *><size_t>this
+ cdef uint16_t *ramp = <uint16_t *>address
+ ramp[<size_t>index] = <uint16_t>value
+
+
+def libgamma_native_gamma_ramps32_create(red_size : int, green_size : int, blue_size : int):
+ '''
+ Create a gamma ramp in the proper way that allows all adjustment methods
+ to read from and write to it without causing segmentation violation
+
+ @param red_size The size of the gamma ramp for the red channel
+ @param green_size The size of the gamma ramp for the green channel
+ @param blue_size The size of the gamma ramp for the blue channel
+ @return :(int){4}|int The tuple that describes the created data, `errno` on failure:
+ Element 1: The address of the gamma ramp structure
+ Element 2: The address of the gamma ramp for the red channel
+ Element 3: The address of the gamma ramp for the green channel
+ Element 4: The address of the gamma ramp for the blue channel
+ '''
+ cdef void *allocation = malloc(sizeof(libgamma_gamma_ramps32_t))
+ cdef libgamma_gamma_ramps32_t *item = <libgamma_gamma_ramps32_t *>allocation
+ cdef size_t red, green, blue
+ if item is NULL:
+ return int(errno)
+ item.red_size = red_size
+ item.green_size = green_size
+ item.blue_size = blue_size
+ if libgamma_gamma_ramps32_initialise(item) < 0:
+ return int(errno)
+ red = <size_t><void *>(item.red)
+ green = <size_t><void *>(item.green)
+ blue = <size_t><void *>(item.blue)
+ return (int(<size_t>allocation), int(red), int(green), int(blue))
+
+
+def libgamma_native_gamma_ramps32_free(this : int):
+ '''
+ Release resources that are held by a gamma ramp strcuture that
+ has been allocated by `libgamma_native_gamma_ramps32_create` or
+ otherwise created in the proper manner, as well as release the
+ pointer to the structure
+
+ @param this The gamma ramps
+ '''
+ cdef void *address = <void *><size_t>this
+ cdef libgamma_gamma_ramps32_t *item = <libgamma_gamma_ramps32_t *>address
+ libgamma_gamma_ramps32_free(item)
+
+
+def libgamma_native_gamma_ramps32_get(this : int, index : int) -> int:
+ '''
+ Read a stop in a gamma ramp
+
+ @param this The gamma ramp
+ @param index The index of the gamma ramp stop
+ @return The value of the gamma ramp stop
+ '''
+ cdef void *address = <void *><size_t>this
+ cdef uint32_t *ramp = <uint32_t *>address
+ return int(ramp[<size_t>index])
+
+
+def libgamma_native_gamma_ramps32_set(this : int, index : int, value : int):
+ '''
+ Modify a stop in a gamma ramp
+
+ @param this The gamma ramp
+ @param index The index of the gamma ramp stop
+ @param value The value of the gamma ramp stop
+ '''
+ cdef void *address = <void*><size_t>this
+ cdef uint32_t *ramp = <uint32_t *>address
+ ramp[<size_t>index] = <uint32_t>value
+
+
+def libgamma_native_gamma_ramps64_create(red_size : int, green_size : int, blue_size : int):
+ '''
+ Create a gamma ramp in the proper way that allows all adjustment methods
+ to read from and write to it without causing segmentation violation
+
+ @param red_size The size of the gamma ramp for the red channel
+ @param green_size The size of the gamma ramp for the green channel
+ @param blue_size The size of the gamma ramp for the blue channel
+ @return :(int){4}|int The tuple that describes the created data, `errno` on failure:
+ Element 1: The address of the gamma ramp structure
+ Element 2: The address of the gamma ramp for the red channel
+ Element 3: The address of the gamma ramp for the green channel
+ Element 4: The address of the gamma ramp for the blue channel
+ '''
+ cdef void *allocation = malloc(sizeof(libgamma_gamma_ramps64_t))
+ cdef libgamma_gamma_ramps64_t *item = <libgamma_gamma_ramps64_t *>allocation
+ cdef size_t red, green, blue
+ if item is NULL:
+ return int(errno)
+ item.red_size = red_size
+ item.green_size = green_size
+ item.blue_size = blue_size
+ if libgamma_gamma_ramps64_initialise(item) < 0:
+ return int(errno)
+ red = <size_t><void *>(item.red)
+ green = <size_t><void *>(item.green)
+ blue = <size_t><void *>(item.blue)
+ return (int(<size_t>allocation), int(red), int(green), int(blue))
+
+
+def libgamma_native_gamma_ramps64_free(this : int):
+ '''
+ Release resources that are held by a gamma ramp strcuture that
+ has been allocated by `libgamma_native_gamma_ramps64_create` or
+ otherwise created in the proper manner, as well as release the
+ pointer to the structure
+
+ @param this The gamma ramps
+ '''
+ cdef void *address = <void *><size_t>this
+ cdef libgamma_gamma_ramps64_t *item = <libgamma_gamma_ramps64_t *>address
+ libgamma_gamma_ramps64_free(item)
+
+
+def libgamma_native_gamma_ramps64_get(this : int, index : int) -> int:
+ '''
+ Read a stop in a gamma ramp
+
+ @param this The gamma ramp
+ @param index The index of the gamma ramp stop
+ @return The value of the gamma ramp stop
+ '''
+ cdef void *address = <void *><size_t>this
+ cdef uint64_t *ramp = <uint64_t *>address
+ return int(ramp[<size_t>index])
+
+
+def libgamma_native_gamma_ramps64_set(this : int, index : int, value : int):
+ '''
+ Modify a stop in a gamma ramp
+
+ @param this The gamma ramp
+ @param index The index of the gamma ramp stop
+ @param value The value of the gamma ramp stop
+ '''
+ cdef void *address = <void *><size_t>this
+ cdef uint64_t *ramp = <uint64_t *>address
+ ramp[<size_t>index] = <uint64_t>value
+
+
+def libgamma_native_gamma_rampsf_create(red_size : int, green_size : int, blue_size : int):
+ '''
+ Create a gamma ramp in the proper way that allows all adjustment methods
+ to read from and write to it without causing segmentation violation
+
+ @param red_size The size of the gamma ramp for the red channel
+ @param green_size The size of the gamma ramp for the green channel
+ @param blue_size The size of the gamma ramp for the blue channel
+ @return :(int){4}|int The tuple that describes the created data, `errno` on failure:
+ Element 1: The address of the gamma ramp structure
+ Element 2: The address of the gamma ramp for the red channel
+ Element 3: The address of the gamma ramp for the green channel
+ Element 4: The address of the gamma ramp for the blue channel
+ '''
+ cdef void *allocation = malloc(sizeof(libgamma_gamma_rampsf_t))
+ cdef libgamma_gamma_rampsf_t *item = <libgamma_gamma_rampsf_t *>allocation
+ cdef size_t red, green, blue
+ if item is NULL:
+ return int(errno)
+ item.red_size = red_size
+ item.green_size = green_size
+ item.blue_size = blue_size
+ if libgamma_gamma_rampsf_initialise(item) < 0:
+ return int(errno)
+ red = <size_t><void *>(item.red)
+ green = <size_t><void *>(item.green)
+ blue = <size_t><void *>(item.blue)
+ return (int(<size_t>allocation), int(red), int(green), int(blue))
+
+
+def libgamma_native_gamma_rampsf_free(this : int):
+ '''
+ Release resources that are held by a gamma ramp strcuture that
+ has been allocated by `libgamma_native_gamma_rampsf_create` or
+ otherwise created in the proper manner, as well as release the
+ pointer to the structure
+
+ @param this The gamma ramps
+ '''
+ cdef void *address = <void *><size_t>this
+ cdef libgamma_gamma_rampsf_t *item = <libgamma_gamma_rampsf_t *>address
+ libgamma_gamma_rampsf_free(item)
+
+
+def libgamma_native_gamma_rampsf_get(this : int, index : int) -> float:
+ '''
+ Read a stop in a gamma ramp
+
+ @param this The gamma ramp
+ @param index The index of the gamma ramp stop
+ @return The value of the gamma ramp stop
+ '''
+ cdef void *address = <void *><size_t>this
+ cdef float *ramp = <float *>address
+ return float(ramp[<size_t>index])
+
+
+def libgamma_native_gamma_rampsf_set(this : int, index : int, value : float):
+ '''
+ Modify a stop in a gamma ramp
+
+ @param this The gamma ramp
+ @param index The index of the gamma ramp stop
+ @param value The value of the gamma ramp stop
+ '''
+ cdef void *address = <void *><size_t>this
+ cdef float *ramp = <float *>address
+ ramp[<size_t>index] = <float>value
+
+
+def libgamma_native_gamma_rampsd_create(red_size : int, green_size : int, blue_size : int):
+ '''
+ Create a gamma ramp in the proper way that allows all adjustment
+ methods to read from and write to it without causing segmentation violation
+
+ @param red_size The size of the gamma ramp for the red channel
+ @param green_size The size of the gamma ramp for the green channel
+ @param blue_size The size of the gamma ramp for the blue channel
+ @return :(int){4}|int The tuple that describes the created data, `errno` on failure:
+ Element 1: The address of the gamma ramp structure
+ Element 2: The address of the gamma ramp for the red channel
+ Element 3: The address of the gamma ramp for the green channel
+ Element 4: The address of the gamma ramp for the blue channel
+ '''
+ cdef void *allocation = malloc(sizeof(libgamma_gamma_rampsd_t))
+ cdef libgamma_gamma_rampsd_t *item = <libgamma_gamma_rampsd_t *>allocation
+ cdef size_t red, green, blue
+ if item is NULL:
+ return int(errno)
+ item.red_size = red_size
+ item.green_size = green_size
+ item.blue_size = blue_size
+ if libgamma_gamma_rampsd_initialise(item) < 0:
+ return int(errno)
+ red = <size_t><void *>(item.red)
+ green = <size_t><void *>(item.green)
+ blue = <size_t><void *>(item.blue)
+ return (int(<size_t>allocation), int(red), int(green), int(blue))
+
+
+def libgamma_native_gamma_rampsd_free(this : int):
+ '''
+ Release resources that are held by a gamma ramp strcuture that
+ has been allocated by `libgamma_native_gamma_rampsd_create` or
+ otherwise created in the proper manner, as well as release the
+ pointer to the structure
+
+ @param this The gamma ramps
+ '''
+ cdef void *address = <void *><size_t>this
+ cdef libgamma_gamma_rampsd_t *item = <libgamma_gamma_rampsd_t *>address
+ libgamma_gamma_rampsd_free(item)
+
+
+def libgamma_native_gamma_rampsd_get(this : int, index : int) -> float:
+ '''
+ Read a stop in a gamma ramp
+
+ @param this The gamma ramp
+ @param index The index of the gamma ramp stop
+ @return The value of the gamma ramp stop
+ '''
+ cdef void *address = <void *><size_t>this
+ cdef double *ramp = <double *>address
+ return float(ramp[<size_t>index])
+
+
+def libgamma_native_gamma_rampsd_set(this : int, index : int, value : float):
+ '''
+ Modify a stop in a gamma ramp
+
+ @param this The gamma ramp
+ @param index The index of the gamma ramp stop
+ @param value The value of the gamma ramp stop
+ '''
+ cdef void *address = <void *><size_t>this
+ cdef double *ramp = <double *>address
+ ramp[<size_t>index] = <double>value