+001: # cython: binding=False, boundscheck=False, wraparound=False, nonecheck=False, cdivision=True,

  __pyx_t_5 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_5) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 002: # cython: optimize.use_switch=True

 003: # encoding: utf-8

 004: 

 005: """

 006:                  GNU GENERAL PUBLIC LICENSE

 007:                        Version 3, 29 June 2007

 008: 

 009:  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>

 010:  Everyone is permitted to copy and distribute verbatim copies

 011:  of this license document, but changing it is not allowed.

 012: 

 013: Copyright Yoann Berenguer

 014: """

 015: 

+016: try:

  {
    /*try:*/ {
/* … */
    }
  }

 017:     cimport cython

 018:     from cython.parallel cimport prange

 019: 

 020: except ImportError:

 021:     raise ImportError("\n<cython> library is missing on your system."

 022:           "\nTry: \n   C:\\pip install cython on a window command prompt.")

 023: 

 024: 

+025: try:

  {
    /*try:*/ {
/* … */
    }
  }

 026:     cimport cython

 027:     from cython.parallel cimport prange

 028:     from cpython cimport PyObject_CallFunctionObjArgs, PyObject, \

 029:         PyList_SetSlice, PyObject_HasAttr, PyObject_IsInstance, \

 030:         PyObject_CallMethod, PyObject_CallObject

 031: 

 032: 

 033: except ImportError:

 034:     raise ImportError("\n<cython> library is missing on your system."

 035:           "\nTry: \n   C:\\pip install cython on a window command prompt.")

 036: 

 037: 

 038: 

+039: try:

  {
    /*try:*/ {
/* … */
    }
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    goto __pyx_L19_try_end;
    __pyx_L14_error:;
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
/* … */
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
    goto __pyx_L1_error;
    __pyx_L19_try_end:;
  }

+040:     import pygame

      __pyx_t_4 = __Pyx_Import(__pyx_n_s_pygame, 0, -1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 40, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_pygame, __pyx_t_4) < 0) __PYX_ERR(0, 40, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+041:     from pygame import Rect

      __pyx_t_4 = PyList_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 41, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_INCREF(__pyx_n_s_Rect);
      __Pyx_GIVEREF(__pyx_n_s_Rect);
      PyList_SET_ITEM(__pyx_t_4, 0, __pyx_n_s_Rect);
      __pyx_t_5 = __Pyx_Import(__pyx_n_s_pygame, __pyx_t_4, -1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 41, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_5, __pyx_n_s_Rect); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 41, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_Rect, __pyx_t_4) < 0) __PYX_ERR(0, 41, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+042:     from pygame.math import Vector2

      __pyx_t_5 = PyList_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 42, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_INCREF(__pyx_n_s_Vector2);
      __Pyx_GIVEREF(__pyx_n_s_Vector2);
      PyList_SET_ITEM(__pyx_t_5, 0, __pyx_n_s_Vector2);
      __pyx_t_4 = __Pyx_Import(__pyx_n_s_pygame_math, __pyx_t_5, -1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 42, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_Vector2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 42, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_Vector2, __pyx_t_5) < 0) __PYX_ERR(0, 42, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+043:     from pygame import Rect, BLEND_RGB_ADD, HWACCEL

      __pyx_t_4 = PyList_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 43, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_INCREF(__pyx_n_s_Rect);
      __Pyx_GIVEREF(__pyx_n_s_Rect);
      PyList_SET_ITEM(__pyx_t_4, 0, __pyx_n_s_Rect);
      __Pyx_INCREF(__pyx_n_s_BLEND_RGB_ADD);
      __Pyx_GIVEREF(__pyx_n_s_BLEND_RGB_ADD);
      PyList_SET_ITEM(__pyx_t_4, 1, __pyx_n_s_BLEND_RGB_ADD);
      __Pyx_INCREF(__pyx_n_s_HWACCEL);
      __Pyx_GIVEREF(__pyx_n_s_HWACCEL);
      PyList_SET_ITEM(__pyx_t_4, 2, __pyx_n_s_HWACCEL);
      __pyx_t_5 = __Pyx_Import(__pyx_n_s_pygame, __pyx_t_4, -1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 43, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_5, __pyx_n_s_Rect); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 43, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_Rect, __pyx_t_4) < 0) __PYX_ERR(0, 43, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_5, __pyx_n_s_BLEND_RGB_ADD); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 43, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_BLEND_RGB_ADD, __pyx_t_4) < 0) __PYX_ERR(0, 43, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_5, __pyx_n_s_HWACCEL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 43, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_HWACCEL, __pyx_t_4) < 0) __PYX_ERR(0, 43, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+044:     from pygame import Surface, SRCALPHA, mask, RLEACCEL

      __pyx_t_5 = PyList_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 44, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_INCREF(__pyx_n_s_Surface);
      __Pyx_GIVEREF(__pyx_n_s_Surface);
      PyList_SET_ITEM(__pyx_t_5, 0, __pyx_n_s_Surface);
      __Pyx_INCREF(__pyx_n_s_SRCALPHA);
      __Pyx_GIVEREF(__pyx_n_s_SRCALPHA);
      PyList_SET_ITEM(__pyx_t_5, 1, __pyx_n_s_SRCALPHA);
      __Pyx_INCREF(__pyx_n_s_mask);
      __Pyx_GIVEREF(__pyx_n_s_mask);
      PyList_SET_ITEM(__pyx_t_5, 2, __pyx_n_s_mask);
      __Pyx_INCREF(__pyx_n_s_RLEACCEL);
      __Pyx_GIVEREF(__pyx_n_s_RLEACCEL);
      PyList_SET_ITEM(__pyx_t_5, 3, __pyx_n_s_RLEACCEL);
      __pyx_t_4 = __Pyx_Import(__pyx_n_s_pygame, __pyx_t_5, -1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 44, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_Surface); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 44, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_Surface, __pyx_t_5) < 0) __PYX_ERR(0, 44, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_SRCALPHA); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 44, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_SRCALPHA, __pyx_t_5) < 0) __PYX_ERR(0, 44, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_mask); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 44, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_mask, __pyx_t_5) < 0) __PYX_ERR(0, 44, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_RLEACCEL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 44, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_RLEACCEL, __pyx_t_5) < 0) __PYX_ERR(0, 44, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+045:     from pygame.transform import rotate, scale, smoothscale

      __pyx_t_4 = PyList_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 45, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_INCREF(__pyx_n_s_rotate);
      __Pyx_GIVEREF(__pyx_n_s_rotate);
      PyList_SET_ITEM(__pyx_t_4, 0, __pyx_n_s_rotate);
      __Pyx_INCREF(__pyx_n_s_scale);
      __Pyx_GIVEREF(__pyx_n_s_scale);
      PyList_SET_ITEM(__pyx_t_4, 1, __pyx_n_s_scale);
      __Pyx_INCREF(__pyx_n_s_smoothscale);
      __Pyx_GIVEREF(__pyx_n_s_smoothscale);
      PyList_SET_ITEM(__pyx_t_4, 2, __pyx_n_s_smoothscale);
      __pyx_t_5 = __Pyx_Import(__pyx_n_s_pygame_transform, __pyx_t_4, -1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 45, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_5, __pyx_n_s_rotate); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 45, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_rotate, __pyx_t_4) < 0) __PYX_ERR(0, 45, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_5, __pyx_n_s_scale); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 45, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_scale, __pyx_t_4) < 0) __PYX_ERR(0, 45, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_5, __pyx_n_s_smoothscale); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 45, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_smoothscale, __pyx_t_4) < 0) __PYX_ERR(0, 45, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+046:     from pygame.surfarray import array3d, pixels3d, array_alpha, pixels_alpha, \

      __pyx_t_5 = PyList_New(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 46, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_INCREF(__pyx_n_s_array3d);
      __Pyx_GIVEREF(__pyx_n_s_array3d);
      PyList_SET_ITEM(__pyx_t_5, 0, __pyx_n_s_array3d);
      __Pyx_INCREF(__pyx_n_s_pixels3d);
      __Pyx_GIVEREF(__pyx_n_s_pixels3d);
      PyList_SET_ITEM(__pyx_t_5, 1, __pyx_n_s_pixels3d);
      __Pyx_INCREF(__pyx_n_s_array_alpha);
      __Pyx_GIVEREF(__pyx_n_s_array_alpha);
      PyList_SET_ITEM(__pyx_t_5, 2, __pyx_n_s_array_alpha);
      __Pyx_INCREF(__pyx_n_s_pixels_alpha);
      __Pyx_GIVEREF(__pyx_n_s_pixels_alpha);
      PyList_SET_ITEM(__pyx_t_5, 3, __pyx_n_s_pixels_alpha);
      __Pyx_INCREF(__pyx_n_s_make_surface);
      __Pyx_GIVEREF(__pyx_n_s_make_surface);
      PyList_SET_ITEM(__pyx_t_5, 4, __pyx_n_s_make_surface);
      __pyx_t_4 = __Pyx_Import(__pyx_n_s_pygame_surfarray, __pyx_t_5, -1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 46, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_array3d); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 46, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_array3d, __pyx_t_5) < 0) __PYX_ERR(0, 46, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_pixels3d); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 46, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_pixels3d, __pyx_t_5) < 0) __PYX_ERR(0, 46, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_array_alpha); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 46, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_array_alpha, __pyx_t_5) < 0) __PYX_ERR(0, 46, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_pixels_alpha); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 46, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_pixels_alpha, __pyx_t_5) < 0) __PYX_ERR(0, 46, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_make_surface); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 46, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_make_surface, __pyx_t_5) < 0) __PYX_ERR(0, 47, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 047:         make_surface

+048:     from pygame.image import frombuffer

      __pyx_t_4 = PyList_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 48, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_INCREF(__pyx_n_s_frombuffer);
      __Pyx_GIVEREF(__pyx_n_s_frombuffer);
      PyList_SET_ITEM(__pyx_t_4, 0, __pyx_n_s_frombuffer);
      __pyx_t_5 = __Pyx_Import(__pyx_n_s_pygame_image, __pyx_t_4, -1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 48, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_5, __pyx_n_s_frombuffer); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 48, __pyx_L14_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_frombuffer, __pyx_t_4) < 0) __PYX_ERR(0, 48, __pyx_L14_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 049: 

+050: except ImportError:

    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ImportError);
    if (__pyx_t_6) {
      __Pyx_AddTraceback("PygameShader.misc", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_7) < 0) __PYX_ERR(0, 50, __pyx_L16_except_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_GOTREF(__pyx_t_7);

+051:     raise ImportError("\n<Pygame> library is missing on your system."

      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 51, __pyx_L16_except_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __PYX_ERR(0, 51, __pyx_L16_except_error)
    }
    goto __pyx_L16_except_error;
    __pyx_L16_except_error:;
/* … */
  __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_s_Pygame_library_is_missing_on_yo); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__28);
  __Pyx_GIVEREF(__pyx_tuple__28);

 052:           "\nTry: \n   C:\\pip install pygame on a window command prompt.")

 053: 

 054: 

 055: # NUMPY IS REQUIRED

+056: try:

  {
    /*try:*/ {
/* … */
    }
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    goto __pyx_L27_try_end;
    __pyx_L22_error:;
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
/* … */
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_2, __pyx_t_1);
    goto __pyx_L1_error;
    __pyx_L27_try_end:;
  }

+057:     import numpy

      __pyx_t_7 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 57, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_numpy, __pyx_t_7) < 0) __PYX_ERR(0, 57, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

+058:     from numpy import ndarray, zeros, empty, uint8, int32, float64, \

      __pyx_t_7 = PyList_New(19); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_INCREF(__pyx_n_s_ndarray);
      __Pyx_GIVEREF(__pyx_n_s_ndarray);
      PyList_SET_ITEM(__pyx_t_7, 0, __pyx_n_s_ndarray);
      __Pyx_INCREF(__pyx_n_s_zeros);
      __Pyx_GIVEREF(__pyx_n_s_zeros);
      PyList_SET_ITEM(__pyx_t_7, 1, __pyx_n_s_zeros);
      __Pyx_INCREF(__pyx_n_s_empty);
      __Pyx_GIVEREF(__pyx_n_s_empty);
      PyList_SET_ITEM(__pyx_t_7, 2, __pyx_n_s_empty);
      __Pyx_INCREF(__pyx_n_s_uint8);
      __Pyx_GIVEREF(__pyx_n_s_uint8);
      PyList_SET_ITEM(__pyx_t_7, 3, __pyx_n_s_uint8);
      __Pyx_INCREF(__pyx_n_s_int32);
      __Pyx_GIVEREF(__pyx_n_s_int32);
      PyList_SET_ITEM(__pyx_t_7, 4, __pyx_n_s_int32);
      __Pyx_INCREF(__pyx_n_s_float64);
      __Pyx_GIVEREF(__pyx_n_s_float64);
      PyList_SET_ITEM(__pyx_t_7, 5, __pyx_n_s_float64);
      __Pyx_INCREF(__pyx_n_s_float32);
      __Pyx_GIVEREF(__pyx_n_s_float32);
      PyList_SET_ITEM(__pyx_t_7, 6, __pyx_n_s_float32);
      __Pyx_INCREF(__pyx_n_s_dstack);
      __Pyx_GIVEREF(__pyx_n_s_dstack);
      PyList_SET_ITEM(__pyx_t_7, 7, __pyx_n_s_dstack);
      __Pyx_INCREF(__pyx_n_s_full);
      __Pyx_GIVEREF(__pyx_n_s_full);
      PyList_SET_ITEM(__pyx_t_7, 8, __pyx_n_s_full);
      __Pyx_INCREF(__pyx_n_s_ones);
      __Pyx_GIVEREF(__pyx_n_s_ones);
      PyList_SET_ITEM(__pyx_t_7, 9, __pyx_n_s_ones);
      __Pyx_INCREF(__pyx_n_s_asarray);
      __Pyx_GIVEREF(__pyx_n_s_asarray);
      PyList_SET_ITEM(__pyx_t_7, 10, __pyx_n_s_asarray);
      __Pyx_INCREF(__pyx_n_s_ascontiguousarray);
      __Pyx_GIVEREF(__pyx_n_s_ascontiguousarray);
      PyList_SET_ITEM(__pyx_t_7, 11, __pyx_n_s_ascontiguousarray);
      __Pyx_INCREF(__pyx_n_s_full_like);
      __Pyx_GIVEREF(__pyx_n_s_full_like);
      PyList_SET_ITEM(__pyx_t_7, 12, __pyx_n_s_full_like);
      __Pyx_INCREF(__pyx_n_s_add);
      __Pyx_GIVEREF(__pyx_n_s_add);
      PyList_SET_ITEM(__pyx_t_7, 13, __pyx_n_s_add);
      __Pyx_INCREF(__pyx_n_s_putmask);
      __Pyx_GIVEREF(__pyx_n_s_putmask);
      PyList_SET_ITEM(__pyx_t_7, 14, __pyx_n_s_putmask);
      __Pyx_INCREF(__pyx_n_s_int16);
      __Pyx_GIVEREF(__pyx_n_s_int16);
      PyList_SET_ITEM(__pyx_t_7, 15, __pyx_n_s_int16);
      __Pyx_INCREF(__pyx_n_s_arange);
      __Pyx_GIVEREF(__pyx_n_s_arange);
      PyList_SET_ITEM(__pyx_t_7, 16, __pyx_n_s_arange);
      __Pyx_INCREF(__pyx_n_s_repeat);
      __Pyx_GIVEREF(__pyx_n_s_repeat);
      PyList_SET_ITEM(__pyx_t_7, 17, __pyx_n_s_repeat);
      __Pyx_INCREF(__pyx_n_s_newaxis);
      __Pyx_GIVEREF(__pyx_n_s_newaxis);
      PyList_SET_ITEM(__pyx_t_7, 18, __pyx_n_s_newaxis);
      __pyx_t_4 = __Pyx_Import(__pyx_n_s_numpy, __pyx_t_7, -1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_ndarray, __pyx_t_7) < 0) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_zeros); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_zeros, __pyx_t_7) < 0) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_empty, __pyx_t_7) < 0) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_uint8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_uint8, __pyx_t_7) < 0) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_int32); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_int32, __pyx_t_7) < 0) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_float64); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_float64, __pyx_t_7) < 0) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_float32, __pyx_t_7) < 0) __PYX_ERR(0, 59, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_dstack); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_dstack, __pyx_t_7) < 0) __PYX_ERR(0, 59, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_full); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_full, __pyx_t_7) < 0) __PYX_ERR(0, 59, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_ones); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_ones, __pyx_t_7) < 0) __PYX_ERR(0, 59, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_asarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_asarray, __pyx_t_7) < 0) __PYX_ERR(0, 59, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_ascontiguousarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_ascontiguousarray, __pyx_t_7) < 0) __PYX_ERR(0, 59, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_full_like); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_full_like, __pyx_t_7) < 0) __PYX_ERR(0, 59, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_add); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_add, __pyx_t_7) < 0) __PYX_ERR(0, 60, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_putmask); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_putmask, __pyx_t_7) < 0) __PYX_ERR(0, 60, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_int16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_int16, __pyx_t_7) < 0) __PYX_ERR(0, 60, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_arange); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_arange, __pyx_t_7) < 0) __PYX_ERR(0, 60, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_repeat); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_repeat, __pyx_t_7) < 0) __PYX_ERR(0, 60, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_newaxis); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L22_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (PyDict_SetItem(__pyx_d, __pyx_n_s_newaxis, __pyx_t_7) < 0) __PYX_ERR(0, 60, __pyx_L22_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 059:         float32, dstack, full, ones, asarray, ascontiguousarray, full_like,\

 060:         add, putmask, int16, arange, repeat, newaxis

+061: except ImportError:

    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ImportError);
    if (__pyx_t_6) {
      __Pyx_AddTraceback("PygameShader.misc", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_7, &__pyx_t_5) < 0) __PYX_ERR(0, 61, __pyx_L24_except_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_GOTREF(__pyx_t_5);

+062:     raise ImportError("\n<numpy> library is missing on your system."

      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 62, __pyx_L24_except_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __PYX_ERR(0, 62, __pyx_L24_except_error)
    }
    goto __pyx_L24_except_error;
    __pyx_L24_except_error:;
/* … */
  __pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_s_numpy_library_is_missing_on_you); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 62, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__29);
  __Pyx_GIVEREF(__pyx_tuple__29);

 063:           "\nTry: \n   C:\\pip install numpy on a window command prompt.")

 064: 

 065: from shader cimport hsv, rgb, minf, struct_rgb_to_hsv

 066: from libc.math cimport round as round_c

 067: from libc.math cimport floor as floor_c, sqrt

 068: from libc.math cimport fabs as abs_c

 069: from libc.stdlib cimport malloc, free

 070: from libc.stdio cimport printf

 071: 

 072: 

+073: import numpy

  __pyx_t_5 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 73, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_numpy, __pyx_t_5) < 0) __PYX_ERR(0, 73, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 074: cimport numpy as np

 075: 

 076: DEF SCHEDULE = 'static'

 077: 

 078: DEF OPENMP = True

 079: # num_threads – The num_threads argument indicates how many threads the team should consist of.

 080: # If not given, OpenMP will decide how many threads to use.

 081: # Typically this is the number of cores available on the machine. However,

 082: # this may be controlled through the omp_set_num_threads() function,

 083: # or through the OMP_NUM_THREADS environment variable.

 084: DEF THREAD_NUMBER = 1

 085: if OPENMP is True:

 086:     DEF THREAD_NUMBER = 8

 087: 

 088: 

 089: @cython.boundscheck(False)

 090: @cython.wraparound(False)

 091: @cython.nonecheck(False)

 092: @cython.cdivision(True)

+093: cpdef swap_channels24_c(surface_, model):

static PyObject *__pyx_pw_12PygameShader_4misc_1swap_channels24_c(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_f_12PygameShader_4misc_swap_channels24_c(PyObject *__pyx_v_surface_, PyObject *__pyx_v_model, CYTHON_UNUSED int __pyx_skip_dispatch) {
  PyObject *__pyx_v_rr = NULL;
  PyObject *__pyx_v_gg = NULL;
  PyObject *__pyx_v_bb = NULL;
  PyObject *__pyx_v_order = NULL;
  Py_ssize_t __pyx_v_width;
  Py_ssize_t __pyx_v_height;
  PyObject *__pyx_v_rgb_ = NULL;
  __Pyx_memviewslice __pyx_v_rgb_array = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_new_array = { 0, 0, { 0 }, { 0 }, { 0 } };
  int __pyx_v_i;
  int __pyx_v_j;
  short __pyx_v_ri;
  short __pyx_v_gi;
  short __pyx_v_bi;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("swap_channels24_c", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_17);
  __Pyx_XDECREF(__pyx_t_18);
  __Pyx_XDECREF(__pyx_t_19);
  __PYX_XDEC_MEMVIEW(&__pyx_t_20, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_21, 1);
  __Pyx_AddTraceback("PygameShader.misc.swap_channels24_c", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_rr);
  __Pyx_XDECREF(__pyx_v_gg);
  __Pyx_XDECREF(__pyx_v_bb);
  __Pyx_XDECREF(__pyx_v_order);
  __Pyx_XDECREF(__pyx_v_rgb_);
  __PYX_XDEC_MEMVIEW(&__pyx_v_rgb_array, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_new_array, 1);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_12PygameShader_4misc_1swap_channels24_c(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_12PygameShader_4misc_swap_channels24_c[] = "\n    THIS PLUGIN ALLOW YOU TO SWAP CHANNEL OF AN IMAGE \n    \n    :param surface_: pygame.Surface\n    :param model: python string; String representing the channel order e.g\n    RGB, RBG, GRB, GBR, BRG, BGR etc. letters can also be replaced by the digit 0\n    to null the entire channel. e.g : 'R0B' -> no green channel\n\n    ";
static PyObject *__pyx_pw_12PygameShader_4misc_1swap_channels24_c(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_surface_ = 0;
  PyObject *__pyx_v_model = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("swap_channels24_c (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_surface,&__pyx_n_s_model,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_surface)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_model)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("swap_channels24_c", 1, 2, 2, 1); __PYX_ERR(0, 93, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "swap_channels24_c") < 0)) __PYX_ERR(0, 93, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_surface_ = values[0];
    __pyx_v_model = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("swap_channels24_c", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 93, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("PygameShader.misc.swap_channels24_c", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_12PygameShader_4misc_swap_channels24_c(__pyx_self, __pyx_v_surface_, __pyx_v_model);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_12PygameShader_4misc_swap_channels24_c(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_surface_, PyObject *__pyx_v_model) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("swap_channels24_c", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_12PygameShader_4misc_swap_channels24_c(__pyx_v_surface_, __pyx_v_model, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 93, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("PygameShader.misc.swap_channels24_c", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 094:     """

 095:     THIS PLUGIN ALLOW YOU TO SWAP CHANNEL OF AN IMAGE 

 096:     

 097:     :param surface_: pygame.Surface

 098:     :param model: python string; String representing the channel order e.g

 099:     RGB, RBG, GRB, GBR, BRG, BGR etc. letters can also be replaced by the digit 0

 100:     to null the entire channel. e.g : 'R0B' -> no green channel

 101: 

 102:     """

+103:     assert PyObject_IsInstance(surface_, Surface), \

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(!Py_OptimizeFlag)) {
    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Surface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 103, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = PyObject_IsInstance(__pyx_v_surface_, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 103, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!(__pyx_t_2 != 0))) {

+104:            'Expecting Surface for argument surface_ got %s ' % type(surface_)

      __pyx_t_1 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Expecting_Surface_for_argument_s, ((PyObject *)Py_TYPE(__pyx_v_surface_))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 104, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      PyErr_SetObject(PyExc_AssertionError, __pyx_t_1);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __PYX_ERR(0, 103, __pyx_L1_error)
    }
  }
  #endif

 105: 

+106:     if len(model) != 3:

  __pyx_t_3 = PyObject_Length(__pyx_v_model); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 106, __pyx_L1_error)
  __pyx_t_2 = ((__pyx_t_3 != 3) != 0);
  if (__pyx_t_2) {
/* … */
  }

+107:         print("\nArgument model is invalid.")

    if (__Pyx_PrintOne(0, __pyx_kp_s_Argument_model_is_invalid) < 0) __PYX_ERR(0, 107, __pyx_L1_error)

+108:         raise ValueError("Choose between RGB, RBG, GRB, GBR, BRG, BGR")

    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(0, 108, __pyx_L1_error)
/* … */
  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_Choose_between_RGB_RBG_GRB_GBR_B); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 108, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple_);
  __Pyx_GIVEREF(__pyx_tuple_);

 109: 

+110:     rr, gg, bb = list(model)

  __pyx_t_1 = PySequence_List(__pyx_v_model); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (1) {
    PyObject* sequence = __pyx_t_1;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 3)) {
      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(0, 110, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    __pyx_t_4 = PyList_GET_ITEM(sequence, 0); 
    __pyx_t_5 = PyList_GET_ITEM(sequence, 1); 
    __pyx_t_6 = PyList_GET_ITEM(sequence, 2); 
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_5);
    __Pyx_INCREF(__pyx_t_6);
    #else
    __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 110, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 110, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    #endif
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  }
  __pyx_v_rr = __pyx_t_4;
  __pyx_t_4 = 0;
  __pyx_v_gg = __pyx_t_5;
  __pyx_t_5 = 0;
  __pyx_v_bb = __pyx_t_6;
  __pyx_t_6 = 0;

+111:     order = {'R' : 0, 'G' : 1, 'B' : 2, '0': -1}

  __pyx_t_1 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_R, __pyx_int_0) < 0) __PYX_ERR(0, 111, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_G, __pyx_int_1) < 0) __PYX_ERR(0, 111, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_B, __pyx_int_2) < 0) __PYX_ERR(0, 111, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_kp_s_0, __pyx_int_neg_1) < 0) __PYX_ERR(0, 111, __pyx_L1_error)
  __pyx_v_order = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

 112: 

 113:     cdef Py_ssize_t width, height

+114:     width, height = surface_.get_size()

  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_surface_, __pyx_n_s_get_size); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 114, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
    if (likely(__pyx_t_5)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_6, function);
    }
  }
  __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 114, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
    PyObject* sequence = __pyx_t_1;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 2)) {
      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(0, 114, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); 
      __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); 
    } else {
      __pyx_t_6 = PyList_GET_ITEM(sequence, 0); 
      __pyx_t_5 = PyList_GET_ITEM(sequence, 1); 
    }
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_5);
    #else
    __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 114, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 114, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    #endif
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 114, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_7 = Py_TYPE(__pyx_t_4)->tp_iternext;
    index = 0; __pyx_t_6 = __pyx_t_7(__pyx_t_4); if (unlikely(!__pyx_t_6)) goto __pyx_L4_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_6);
    index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_4); if (unlikely(!__pyx_t_5)) goto __pyx_L4_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_5);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_4), 2) < 0) __PYX_ERR(0, 114, __pyx_L1_error)
    __pyx_t_7 = NULL;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    goto __pyx_L5_unpacking_done;
    __pyx_L4_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_7 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(0, 114, __pyx_L1_error)
    __pyx_L5_unpacking_done:;
  }
  __pyx_t_3 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_3 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_8 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_8 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_width = __pyx_t_3;
  __pyx_v_height = __pyx_t_8;

 115: 

+116:     try:

  {
    /*try:*/ {
/* … */
    }
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
    goto __pyx_L11_try_end;
    __pyx_L6_error:;
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
/* … */
    __Pyx_XGIVEREF(__pyx_t_9);
    __Pyx_XGIVEREF(__pyx_t_10);
    __Pyx_XGIVEREF(__pyx_t_11);
    __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
    goto __pyx_L1_error;
    __pyx_L7_exception_handled:;
    __Pyx_XGIVEREF(__pyx_t_9);
    __Pyx_XGIVEREF(__pyx_t_10);
    __Pyx_XGIVEREF(__pyx_t_11);
    __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
    __pyx_L11_try_end:;
  }

+117:         rgb_ = pixels3d(surface_)

      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pixels3d); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 117, __pyx_L6_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_6 = NULL;
      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
        __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
        if (likely(__pyx_t_6)) {
          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
          __Pyx_INCREF(__pyx_t_6);
          __Pyx_INCREF(function);
          __Pyx_DECREF_SET(__pyx_t_5, function);
        }
      }
      __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_v_surface_) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_surface_);
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 117, __pyx_L6_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_v_rgb_ = __pyx_t_1;
      __pyx_t_1 = 0;

+118:     except (pygame.error, ValueError):

    __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_6);
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pygame); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 118, __pyx_L8_except_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_error); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 118, __pyx_L8_except_error)
    __Pyx_GOTREF(__pyx_t_12);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_13 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_12) || __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_builtin_ValueError);
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_6);
    __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0;
    if (__pyx_t_13) {
      __Pyx_AddTraceback("PygameShader.misc.swap_channels24_c", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(0, 118, __pyx_L8_except_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_GOTREF(__pyx_t_1);

+119:         try:

      {
        /*try:*/ {
/* … */
        }
        __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
        __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
        __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
        goto __pyx_L21_try_end;
        __pyx_L14_error:;
        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
        __Pyx_XGIVEREF(__pyx_t_14);
        __Pyx_XGIVEREF(__pyx_t_15);
        __Pyx_XGIVEREF(__pyx_t_16);
        __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16);
        goto __pyx_L8_except_error;
        __pyx_L21_try_end:;
      }
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      goto __pyx_L7_exception_handled;
    }
    goto __pyx_L8_except_error;
    __pyx_L8_except_error:;

+120:             rgb_ = array3d(surface_)

          __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_array3d); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 120, __pyx_L14_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_17 = NULL;
          if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
            __pyx_t_17 = PyMethod_GET_SELF(__pyx_t_4);
            if (likely(__pyx_t_17)) {
              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
              __Pyx_INCREF(__pyx_t_17);
              __Pyx_INCREF(function);
              __Pyx_DECREF_SET(__pyx_t_4, function);
            }
          }
          __pyx_t_12 = (__pyx_t_17) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_17, __pyx_v_surface_) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_surface_);
          __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
          if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 120, __pyx_L14_error)
          __Pyx_GOTREF(__pyx_t_12);
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_XDECREF_SET(__pyx_v_rgb_, __pyx_t_12);
          __pyx_t_12 = 0;

+121:         except(pygame.error, ValueError):

        __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_4, &__pyx_t_17);
        __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_n_s_pygame); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 121, __pyx_L16_except_error)
        __Pyx_GOTREF(__pyx_t_18);
        __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_n_s_error); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 121, __pyx_L16_except_error)
        __Pyx_GOTREF(__pyx_t_19);
        __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
        __pyx_t_13 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_12, __pyx_t_19) || __Pyx_PyErr_GivenExceptionMatches(__pyx_t_12, __pyx_builtin_ValueError);
        __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
        __Pyx_ErrRestore(__pyx_t_12, __pyx_t_4, __pyx_t_17);
        __pyx_t_12 = 0; __pyx_t_4 = 0; __pyx_t_17 = 0;
        if (__pyx_t_13) {
          __Pyx_AddTraceback("PygameShader.misc.swap_channels24_c", __pyx_clineno, __pyx_lineno, __pyx_filename);
          if (__Pyx_GetException(&__pyx_t_17, &__pyx_t_4, &__pyx_t_12) < 0) __PYX_ERR(0, 121, __pyx_L16_except_error)
          __Pyx_GOTREF(__pyx_t_17);
          __Pyx_GOTREF(__pyx_t_4);
          __Pyx_GOTREF(__pyx_t_12);

+122:             raise ValueError('\nIncompatible pixel format.')

          __pyx_t_19 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 122, __pyx_L16_except_error)
          __Pyx_GOTREF(__pyx_t_19);
          __Pyx_Raise(__pyx_t_19, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
          __PYX_ERR(0, 122, __pyx_L16_except_error)
        }
        goto __pyx_L16_except_error;
        __pyx_L16_except_error:;
/* … */
  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_Incompatible_pixel_format); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 122, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__2);
  __Pyx_GIVEREF(__pyx_tuple__2);

 123: 

 124:     cdef:

+125:         unsigned char [:, :, :] rgb_array = rgb_

  __pyx_t_20 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_unsigned_char(__pyx_v_rgb_, PyBUF_WRITABLE); if (unlikely(!__pyx_t_20.memview)) __PYX_ERR(0, 125, __pyx_L1_error)
  __pyx_v_rgb_array = __pyx_t_20;
  __pyx_t_20.memview = NULL;
  __pyx_t_20.data = NULL;

+126:         unsigned char [:, :, ::1] new_array = empty((height, width, 3), dtype=uint8)

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 126, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_height); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 126, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_width); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 126, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_12 = PyTuple_New(3); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 126, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_6);
  __Pyx_INCREF(__pyx_int_3);
  __Pyx_GIVEREF(__pyx_int_3);
  PyTuple_SET_ITEM(__pyx_t_12, 2, __pyx_int_3);
  __pyx_t_5 = 0;
  __pyx_t_6 = 0;
  __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 126, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_12);
  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_12);
  __pyx_t_12 = 0;
  __pyx_t_12 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 126, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_uint8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 126, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_12, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 126, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 126, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
  __pyx_t_21 = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_unsigned_char(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_21.memview)) __PYX_ERR(0, 126, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_new_array = __pyx_t_21;
  __pyx_t_21.memview = NULL;
  __pyx_t_21.data = NULL;

+127:         int i=0, j=0

  __pyx_v_i = 0;
  __pyx_v_j = 0;

 128:         short int ri, gi, bi

 129: 

+130:     ri = order[rr]

  __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_order, __pyx_v_rr); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 130, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_22 = __Pyx_PyInt_As_short(__pyx_t_5); if (unlikely((__pyx_t_22 == (short)-1) && PyErr_Occurred())) __PYX_ERR(0, 130, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_ri = __pyx_t_22;

+131:     gi = order[gg]

  __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_order, __pyx_v_gg); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_22 = __Pyx_PyInt_As_short(__pyx_t_5); if (unlikely((__pyx_t_22 == (short)-1) && PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_gi = __pyx_t_22;

+132:     bi = order[bb]

  __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_order, __pyx_v_bb); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 132, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_22 = __Pyx_PyInt_As_short(__pyx_t_5); if (unlikely((__pyx_t_22 == (short)-1) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_bi = __pyx_t_22;

 133: 

+134:     with nogil:

  {
      #ifdef WITH_THREAD
      PyThreadState *_save;
      Py_UNBLOCK_THREADS
      __Pyx_FastGIL_Remember();
      #endif
      /*try:*/ {
/* … */
      /*finally:*/ {
        /*normal exit:*/{
          #ifdef WITH_THREAD
          __Pyx_FastGIL_Forget();
          Py_BLOCK_THREADS
          #endif
          goto __pyx_L26;
        }
        __pyx_L26:;
      }
  }

+135:         for i in prange(width, schedule=SCHEDULE, num_threads=THREAD_NUMBER):

        __pyx_t_8 = __pyx_v_width;
        if ((1 == 0)) abort();
        {
            #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
                #undef likely
                #undef unlikely
                #define likely(x)   (x)
                #define unlikely(x) (x)
            #endif
            __pyx_t_23 = (__pyx_t_8 - 0 + 1 - 1/abs(1)) / 1;
            if (__pyx_t_23 > 0)
            {
                #ifdef _OPENMP
                #pragma omp parallel
                #endif /* _OPENMP */
                {
                    #ifdef _OPENMP
                    #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i) lastprivate(__pyx_v_j) schedule(static) num_threads(8)
                    #endif /* _OPENMP */
                    for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_23; __pyx_t_3++){
                        {
                            __pyx_v_i = (int)(0 + 1 * __pyx_t_3);
                            /* Initialize private variables to invalid values */
                            __pyx_v_j = ((int)0xbad0bad0);

+136:             for j in range(height):

                            __pyx_t_24 = __pyx_v_height;
                            __pyx_t_25 = __pyx_t_24;
                            for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_25; __pyx_t_13+=1) {
                              __pyx_v_j = __pyx_t_13;

+137:                 if ri == -1:

                              __pyx_t_2 = ((__pyx_v_ri == -1L) != 0);
                              if (__pyx_t_2) {
/* … */
                                goto __pyx_L33;
                              }

+138:                     new_array[j, i, 0] = 0

                                __pyx_t_26 = __pyx_v_j;
                                __pyx_t_27 = __pyx_v_i;
                                __pyx_t_28 = 0;
                                *((unsigned char *) ( /* dim=2 */ ((char *) (((unsigned char *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_new_array.data + __pyx_t_26 * __pyx_v_new_array.strides[0]) ) + __pyx_t_27 * __pyx_v_new_array.strides[1]) )) + __pyx_t_28)) )) = 0;

 139:                 else:

+140:                     new_array[j, i, 0] = rgb_array[i, j, ri]

                              /*else*/ {
                                __pyx_t_28 = __pyx_v_i;
                                __pyx_t_27 = __pyx_v_j;
                                __pyx_t_26 = __pyx_v_ri;
                                __pyx_t_29 = __pyx_v_j;
                                __pyx_t_30 = __pyx_v_i;
                                __pyx_t_31 = 0;
                                *((unsigned char *) ( /* dim=2 */ ((char *) (((unsigned char *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_new_array.data + __pyx_t_29 * __pyx_v_new_array.strides[0]) ) + __pyx_t_30 * __pyx_v_new_array.strides[1]) )) + __pyx_t_31)) )) = (*((unsigned char *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rgb_array.data + __pyx_t_28 * __pyx_v_rgb_array.strides[0]) ) + __pyx_t_27 * __pyx_v_rgb_array.strides[1]) ) + __pyx_t_26 * __pyx_v_rgb_array.strides[2]) )));
                              }
                              __pyx_L33:;

 141: 

+142:                 if gi == -1:

                              __pyx_t_2 = ((__pyx_v_gi == -1L) != 0);
                              if (__pyx_t_2) {
/* … */
                                goto __pyx_L34;
                              }

+143:                     new_array[j, i, 1] = 0

                                __pyx_t_26 = __pyx_v_j;
                                __pyx_t_27 = __pyx_v_i;
                                __pyx_t_28 = 1;
                                *((unsigned char *) ( /* dim=2 */ ((char *) (((unsigned char *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_new_array.data + __pyx_t_26 * __pyx_v_new_array.strides[0]) ) + __pyx_t_27 * __pyx_v_new_array.strides[1]) )) + __pyx_t_28)) )) = 0;

 144:                 else:

+145:                     new_array[j, i, 1] = rgb_array[i, j, gi]

                              /*else*/ {
                                __pyx_t_28 = __pyx_v_i;
                                __pyx_t_27 = __pyx_v_j;
                                __pyx_t_26 = __pyx_v_gi;
                                __pyx_t_31 = __pyx_v_j;
                                __pyx_t_30 = __pyx_v_i;
                                __pyx_t_29 = 1;
                                *((unsigned char *) ( /* dim=2 */ ((char *) (((unsigned char *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_new_array.data + __pyx_t_31 * __pyx_v_new_array.strides[0]) ) + __pyx_t_30 * __pyx_v_new_array.strides[1]) )) + __pyx_t_29)) )) = (*((unsigned char *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rgb_array.data + __pyx_t_28 * __pyx_v_rgb_array.strides[0]) ) + __pyx_t_27 * __pyx_v_rgb_array.strides[1]) ) + __pyx_t_26 * __pyx_v_rgb_array.strides[2]) )));
                              }
                              __pyx_L34:;

 146: 

+147:                 if bi == -1:

                              __pyx_t_2 = ((__pyx_v_bi == -1L) != 0);
                              if (__pyx_t_2) {
/* … */
                                goto __pyx_L35;
                              }

+148:                     new_array[j, i, 2] = 0

                                __pyx_t_26 = __pyx_v_j;
                                __pyx_t_27 = __pyx_v_i;
                                __pyx_t_28 = 2;
                                *((unsigned char *) ( /* dim=2 */ ((char *) (((unsigned char *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_new_array.data + __pyx_t_26 * __pyx_v_new_array.strides[0]) ) + __pyx_t_27 * __pyx_v_new_array.strides[1]) )) + __pyx_t_28)) )) = 0;

 149:                 else:

+150:                     new_array[j, i, 2] = rgb_array[i, j, bi]

                              /*else*/ {
                                __pyx_t_28 = __pyx_v_i;
                                __pyx_t_27 = __pyx_v_j;
                                __pyx_t_26 = __pyx_v_bi;
                                __pyx_t_29 = __pyx_v_j;
                                __pyx_t_30 = __pyx_v_i;
                                __pyx_t_31 = 2;
                                *((unsigned char *) ( /* dim=2 */ ((char *) (((unsigned char *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_new_array.data + __pyx_t_29 * __pyx_v_new_array.strides[0]) ) + __pyx_t_30 * __pyx_v_new_array.strides[1]) )) + __pyx_t_31)) )) = (*((unsigned char *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rgb_array.data + __pyx_t_28 * __pyx_v_rgb_array.strides[0]) ) + __pyx_t_27 * __pyx_v_rgb_array.strides[1]) ) + __pyx_t_26 * __pyx_v_rgb_array.strides[2]) )));
                              }
                              __pyx_L35:;
                            }
                        }
                    }
                }
            }
        }
        #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
            #undef likely
            #undef unlikely
            #define likely(x)   __builtin_expect(!!(x), 1)
            #define unlikely(x) __builtin_expect(!!(x), 0)
        #endif
      }

 151: 

+152:     return frombuffer(new_array, (width, height), 'RGB')

  __Pyx_XDECREF(__pyx_r);
  __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_n_s_frombuffer); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 152, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_6 = __pyx_memoryview_fromslice(__pyx_v_new_array, 3, (PyObject *(*)(char *)) __pyx_memview_get_unsigned_char, (int (*)(char *, PyObject *)) __pyx_memview_set_unsigned_char, 0);; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 152, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_width); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_height); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_17 = PyTuple_New(2); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 152, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_17, 1, __pyx_t_4);
  __pyx_t_1 = 0;
  __pyx_t_4 = 0;
  __pyx_t_4 = NULL;
  __pyx_t_13 = 0;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_12))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_12);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_12, function);
      __pyx_t_13 = 1;
    }
  }
  #if CYTHON_FAST_PYCALL
  if (PyFunction_Check(__pyx_t_12)) {
    PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_t_6, __pyx_t_17, __pyx_n_s_RGB};
    __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_12, __pyx_temp+1-__pyx_t_13, 3+__pyx_t_13); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 152, __pyx_L1_error)
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  } else
  #endif
  #if CYTHON_FAST_PYCCALL
  if (__Pyx_PyFastCFunction_Check(__pyx_t_12)) {
    PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_t_6, __pyx_t_17, __pyx_n_s_RGB};
    __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_12, __pyx_temp+1-__pyx_t_13, 3+__pyx_t_13); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 152, __pyx_L1_error)
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  } else
  #endif
  {
    __pyx_t_1 = PyTuple_New(3+__pyx_t_13); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    if (__pyx_t_4) {
      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4); __pyx_t_4 = NULL;
    }
    __Pyx_GIVEREF(__pyx_t_6);
    PyTuple_SET_ITEM(__pyx_t_1, 0+__pyx_t_13, __pyx_t_6);
    __Pyx_GIVEREF(__pyx_t_17);
    PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_13, __pyx_t_17);
    __Pyx_INCREF(__pyx_n_s_RGB);
    __Pyx_GIVEREF(__pyx_n_s_RGB);
    PyTuple_SET_ITEM(__pyx_t_1, 2+__pyx_t_13, __pyx_n_s_RGB);
    __pyx_t_6 = 0;
    __pyx_t_17 = 0;
    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 152, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  }
  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

 153: 

 154: 

 155: 

 156: 

 157: @cython.boundscheck(False)

 158: @cython.wraparound(False)

 159: @cython.nonecheck(False)

 160: @cython.cdivision(True)

+161: cpdef create_horizontal_gradient_1d(

static PyObject *__pyx_pw_12PygameShader_4misc_3create_horizontal_gradient_1d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_f_12PygameShader_4misc_create_horizontal_gradient_1d(int __pyx_v_value, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_12PygameShader_4misc_create_horizontal_gradient_1d *__pyx_optional_args) {
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_8, 1);
  __Pyx_AddTraceback("PygameShader.misc.create_horizontal_gradient_1d", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __PYX_XDEC_MEMVIEW(&__pyx_v_diff_, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_row, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_rgb_gradient, 1);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_12PygameShader_4misc_3create_horizontal_gradient_1d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_12PygameShader_4misc_2create_horizontal_gradient_1d[] = "\n    CREATE AN ARRAY FILLED WITH A GRADIENT COLOR  \n    \n    :param value      : integer; Size of the gradient 1d width\n    :param start_color: tuple; Tuple containing the starting RGB color \n    :param end_color  : tuple; Tuple containing the RGB values of the final color\n    :return           : numpy.ndarray 2D array shape (w, 3) of type uint8 (unsigned char) \n     containing all the pixels \n    ";
static PyObject *__pyx_pw_12PygameShader_4misc_3create_horizontal_gradient_1d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_value;
  PyObject *__pyx_v_start_color = 0;
  PyObject *__pyx_v_end_color = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("create_horizontal_gradient_1d (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_value,&__pyx_n_s_start_color,&__pyx_n_s_end_color,0};
    PyObject* values[3] = {0,0,0};
/* … */
  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_12PygameShader_4misc_2create_horizontal_gradient_1d(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_value, PyObject *__pyx_v_start_color, PyObject *__pyx_v_end_color) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("create_horizontal_gradient_1d", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2.__pyx_n = 2;
  __pyx_t_2.start_color = __pyx_v_start_color;
  __pyx_t_2.end_color = __pyx_v_end_color;
  __pyx_t_1 = __pyx_f_12PygameShader_4misc_create_horizontal_gradient_1d(__pyx_v_value, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("PygameShader.misc.create_horizontal_gradient_1d", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 162:         int value,

+163:         tuple start_color=(255, 0, 0),

  PyObject *__pyx_v_start_color = ((PyObject*)__pyx_tuple__3);
/* … */
  __pyx_tuple__3 = PyTuple_Pack(3, __pyx_int_255, __pyx_int_0, __pyx_int_0); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 163, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__3);
  __Pyx_GIVEREF(__pyx_tuple__3);
/* … */
    values[1] = ((PyObject*)__pyx_tuple__3);

+164:         tuple end_color=(0, 255, 0)

  PyObject *__pyx_v_end_color = ((PyObject*)__pyx_tuple__4);
  __Pyx_memviewslice __pyx_v_diff_ = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_row = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_rgb_gradient = { 0, 0, { 0 }, { 0 }, { 0 } };
  float __pyx_v_start[3];
  int __pyx_v_i;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("create_horizontal_gradient_1d", 0);
  if (__pyx_optional_args) {
    if (__pyx_optional_args->__pyx_n > 0) {
      __pyx_v_start_color = __pyx_optional_args->start_color;
      if (__pyx_optional_args->__pyx_n > 1) {
        __pyx_v_end_color = __pyx_optional_args->end_color;
      }
    }
  }
/* … */
    values[2] = ((PyObject*)__pyx_tuple__4);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_start_color);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_end_color);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_horizontal_gradient_1d") < 0)) __PYX_ERR(0, 161, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_value = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_value == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 162, __pyx_L3_error)
    __pyx_v_start_color = ((PyObject*)values[1]);
    __pyx_v_end_color = ((PyObject*)values[2]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("create_horizontal_gradient_1d", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 161, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("PygameShader.misc.create_horizontal_gradient_1d", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_start_color), (&PyTuple_Type), 1, "start_color", 1))) __PYX_ERR(0, 163, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_end_color), (&PyTuple_Type), 1, "end_color", 1))) __PYX_ERR(0, 164, __pyx_L1_error)
  __pyx_r = __pyx_pf_12PygameShader_4misc_2create_horizontal_gradient_1d(__pyx_self, __pyx_v_value, __pyx_v_start_color, __pyx_v_end_color);
/* … */
  __pyx_tuple__4 = PyTuple_Pack(3, __pyx_int_0, __pyx_int_255, __pyx_int_0); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 164, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__4);
  __Pyx_GIVEREF(__pyx_tuple__4);

 165: ):

 166:     """

 167:     CREATE AN ARRAY FILLED WITH A GRADIENT COLOR  

 168:     

 169:     :param value      : integer; Size of the gradient 1d width

 170:     :param start_color: tuple; Tuple containing the starting RGB color 

 171:     :param end_color  : tuple; Tuple containing the RGB values of the final color

 172:     :return           : numpy.ndarray 2D array shape (w, 3) of type uint8 (unsigned char) 

 173:      containing all the pixels 

 174:     """

 175:     cdef:

 176:         float [:] diff_ =  \

+177:             numpy.array(end_color, dtype=float32) - \

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 177, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__pyx_v_end_color);
  __Pyx_GIVEREF(__pyx_v_end_color);
  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_end_color);
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 177, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 177, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 177, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* … */
  __pyx_t_2 = PyNumber_Subtract(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 177, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_t_2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 177, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_diff_ = __pyx_t_6;
  __pyx_t_6.memview = NULL;
  __pyx_t_6.data = NULL;

+178:             numpy.array(start_color, dtype=float32)

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_v_start_color);
  __Pyx_GIVEREF(__pyx_v_start_color);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_start_color);
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 178, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 178, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 178, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 178, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+179:         float [::1] row = numpy.arange(value, dtype=float32) / (value - 1.0)

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 179, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_arange); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 179, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 179, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 179, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 179, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_float32); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(0, 179, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble((__pyx_v_value - 1.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 179, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 179, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_dc_float(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 179, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_row = __pyx_t_7;
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;

+180:         unsigned char [:, ::1] rgb_gradient = empty((value, 3), dtype=uint8)

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 180, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 180, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 180, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
  __Pyx_INCREF(__pyx_int_3);
  __Pyx_GIVEREF(__pyx_int_3);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_3);
  __pyx_t_2 = 0;
  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 180, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
  __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 180, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_uint8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 180, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 180, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 180, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_unsigned_char(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_8.memview)) __PYX_ERR(0, 180, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_rgb_gradient = __pyx_t_8;
  __pyx_t_8.memview = NULL;
  __pyx_t_8.data = NULL;

+181:         float [3] start = numpy.array(start_color, dtype=float32)

  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_numpy); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_INCREF(__pyx_v_start_color);
  __Pyx_GIVEREF(__pyx_v_start_color);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_start_color);
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 181, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(__Pyx_carray_from_py_float(__pyx_t_4, __pyx_t_9, 3) < 0)) __PYX_ERR(0, 181, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  memcpy(&(__pyx_v_start[0]), __pyx_t_9, sizeof(__pyx_v_start[0]) * (3));

+182:         int i=0

  __pyx_v_i = 0;

 183: 

+184:     with nogil:

  {
      #ifdef WITH_THREAD
      PyThreadState *_save;
      Py_UNBLOCK_THREADS
      __Pyx_FastGIL_Remember();
      #endif
      /*try:*/ {
/* … */
      /*finally:*/ {
        /*normal exit:*/{
          #ifdef WITH_THREAD
          __Pyx_FastGIL_Forget();
          Py_BLOCK_THREADS
          #endif
          goto __pyx_L5;
        }
        __pyx_L5:;
      }
  }

+185:         for i in prange(value, schedule=SCHEDULE, num_threads=THREAD_NUMBER):

        __pyx_t_10 = __pyx_v_value;
        if ((1 == 0)) abort();
        {
            #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
                #undef likely
                #undef unlikely
                #define likely(x)   (x)
                #define unlikely(x) (x)
            #endif
            __pyx_t_12 = (__pyx_t_10 - 0 + 1 - 1/abs(1)) / 1;
            if (__pyx_t_12 > 0)
            {
                #ifdef _OPENMP
                #pragma omp parallel
                #endif /* _OPENMP */
                {
                    #ifdef _OPENMP
                    #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i) schedule(static) num_threads(8)
                    #endif /* _OPENMP */
                    for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_12; __pyx_t_11++){
                        {
                            __pyx_v_i = (int)(0 + 1 * __pyx_t_11);

+186:                rgb_gradient[i, 0] = <unsigned char>(start[0] + row[i] * diff_[0])

                            __pyx_t_13 = __pyx_v_i;
                            __pyx_t_14 = 0;
                            __pyx_t_15 = __pyx_v_i;
                            __pyx_t_16 = 0;
                            *((unsigned char *) ( /* dim=1 */ ((char *) (((unsigned char *) ( /* dim=0 */ (__pyx_v_rgb_gradient.data + __pyx_t_15 * __pyx_v_rgb_gradient.strides[0]) )) + __pyx_t_16)) )) = ((unsigned char)((__pyx_v_start[0]) + ((*((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_row.data) + __pyx_t_13)) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_diff_.data + __pyx_t_14 * __pyx_v_diff_.strides[0]) ))))));

+187:                rgb_gradient[i, 1] = <unsigned char>(start[1] + row[i] * diff_[1])

                            __pyx_t_14 = __pyx_v_i;
                            __pyx_t_13 = 1;
                            __pyx_t_16 = __pyx_v_i;
                            __pyx_t_15 = 1;
                            *((unsigned char *) ( /* dim=1 */ ((char *) (((unsigned char *) ( /* dim=0 */ (__pyx_v_rgb_gradient.data + __pyx_t_16 * __pyx_v_rgb_gradient.strides[0]) )) + __pyx_t_15)) )) = ((unsigned char)((__pyx_v_start[1]) + ((*((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_row.data) + __pyx_t_14)) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_diff_.data + __pyx_t_13 * __pyx_v_diff_.strides[0]) ))))));

+188:                rgb_gradient[i, 2] = <unsigned char>(start[2] + row[i] * diff_[2])

                            __pyx_t_13 = __pyx_v_i;
                            __pyx_t_14 = 2;
                            __pyx_t_15 = __pyx_v_i;
                            __pyx_t_16 = 2;
                            *((unsigned char *) ( /* dim=1 */ ((char *) (((unsigned char *) ( /* dim=0 */ (__pyx_v_rgb_gradient.data + __pyx_t_15 * __pyx_v_rgb_gradient.strides[0]) )) + __pyx_t_16)) )) = ((unsigned char)((__pyx_v_start[2]) + ((*((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_row.data) + __pyx_t_13)) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_diff_.data + __pyx_t_14 * __pyx_v_diff_.strides[0]) ))))));
                        }
                    }
                }
            }
        }
        #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
            #undef likely
            #undef unlikely
            #define likely(x)   __builtin_expect(!!(x), 1)
            #define unlikely(x) __builtin_expect(!!(x), 0)
        #endif
      }

 189: 

+190:     return asarray(rgb_gradient)

  __Pyx_XDECREF(__pyx_r);
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_asarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 190, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = __pyx_memoryview_fromslice(__pyx_v_rgb_gradient, 2, (PyObject *(*)(char *)) __pyx_memview_get_unsigned_char, (int (*)(char *, PyObject *)) __pyx_memview_set_unsigned_char, 0);; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 190, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_4 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_5);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 190, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

 191: 

 192: 

 193: 

 194: @cython.boundscheck(False)

 195: @cython.wraparound(False)

 196: @cython.nonecheck(False)

 197: @cython.cdivision(True)

+198: cpdef object horizontal_grad3d(

static PyObject *__pyx_pw_12PygameShader_4misc_5horizontal_grad3d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_f_12PygameShader_4misc_horizontal_grad3d(int __pyx_v_width, int __pyx_v_height, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_12PygameShader_4misc_horizontal_grad3d *__pyx_optional_args) {
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_8, 1);
  __Pyx_XDECREF(__pyx_t_21);
  __Pyx_XDECREF(__pyx_t_22);
  __Pyx_AddTraceback("PygameShader.misc.horizontal_grad3d", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __PYX_XDEC_MEMVIEW(&__pyx_v_diff_, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_row, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_rgb_gradient, 1);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_12PygameShader_4misc_5horizontal_grad3d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_12PygameShader_4misc_4horizontal_grad3d[] = "\n    CREATE A GRADIENT FROM TWO COLORS\n\n    :param width      : integer; width of the new surface in pixels\n    :param height     : integer; height of the new surface in pixels\n    :param start_color: tuple; Value RGB, Starting color\n    :param end_color  : tuple; value RGB, ending color or final color\n    :return           : Surface; pygame.Surface format 24 bit \n    size width x height converted for fast blit\n    ";
static PyObject *__pyx_pw_12PygameShader_4misc_5horizontal_grad3d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_width;
  int __pyx_v_height;
  PyObject *__pyx_v_start_color = 0;
  PyObject *__pyx_v_end_color = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("horizontal_grad3d (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_width,&__pyx_n_s_height,&__pyx_n_s_start_color,&__pyx_n_s_end_color,0};
    PyObject* values[4] = {0,0,0,0};
/* … */
  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_12PygameShader_4misc_4horizontal_grad3d(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_width, int __pyx_v_height, PyObject *__pyx_v_start_color, PyObject *__pyx_v_end_color) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("horizontal_grad3d", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2.__pyx_n = 2;
  __pyx_t_2.start_color = __pyx_v_start_color;
  __pyx_t_2.end_color = __pyx_v_end_color;
  __pyx_t_1 = __pyx_f_12PygameShader_4misc_horizontal_grad3d(__pyx_v_width, __pyx_v_height, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 198, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("PygameShader.misc.horizontal_grad3d", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 199:         int width,

 200:         int height,

+201:         tuple start_color=(255, 0, 0),

  PyObject *__pyx_v_start_color = ((PyObject*)__pyx_tuple__3);
/* … */
    values[2] = ((PyObject*)__pyx_tuple__3);

+202:         tuple end_color=(0, 255, 0)

  PyObject *__pyx_v_end_color = ((PyObject*)__pyx_tuple__4);
  __Pyx_memviewslice __pyx_v_diff_ = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_row = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_rgb_gradient = { 0, 0, { 0 }, { 0 }, { 0 } };
  float __pyx_v_start[3];
  int __pyx_v_i;
  int __pyx_v_j;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("horizontal_grad3d", 0);
  if (__pyx_optional_args) {
    if (__pyx_optional_args->__pyx_n > 0) {
      __pyx_v_start_color = __pyx_optional_args->start_color;
      if (__pyx_optional_args->__pyx_n > 1) {
        __pyx_v_end_color = __pyx_optional_args->end_color;
      }
    }
  }
/* … */
    values[3] = ((PyObject*)__pyx_tuple__4);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_width)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_height)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("horizontal_grad3d", 0, 2, 4, 1); __PYX_ERR(0, 198, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_start_color);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_end_color);
          if (value) { values[3] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "horizontal_grad3d") < 0)) __PYX_ERR(0, 198, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_width = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_width == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 199, __pyx_L3_error)
    __pyx_v_height = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_height == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 200, __pyx_L3_error)
    __pyx_v_start_color = ((PyObject*)values[2]);
    __pyx_v_end_color = ((PyObject*)values[3]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("horizontal_grad3d", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 198, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("PygameShader.misc.horizontal_grad3d", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_start_color), (&PyTuple_Type), 1, "start_color", 1))) __PYX_ERR(0, 201, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_end_color), (&PyTuple_Type), 1, "end_color", 1))) __PYX_ERR(0, 202, __pyx_L1_error)
  __pyx_r = __pyx_pf_12PygameShader_4misc_4horizontal_grad3d(__pyx_self, __pyx_v_width, __pyx_v_height, __pyx_v_start_color, __pyx_v_end_color);

 203: ):

 204:     """

 205:     CREATE A GRADIENT FROM TWO COLORS

 206: 

 207:     :param width      : integer; width of the new surface in pixels

 208:     :param height     : integer; height of the new surface in pixels

 209:     :param start_color: tuple; Value RGB, Starting color

 210:     :param end_color  : tuple; value RGB, ending color or final color

 211:     :return           : Surface; pygame.Surface format 24 bit 

 212:     size width x height converted for fast blit

 213:     """

 214:     cdef:

 215:         float [:] diff_ =  \

+216:             numpy.array(end_color, dtype=float32) - \

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 216, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 216, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 216, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__pyx_v_end_color);
  __Pyx_GIVEREF(__pyx_v_end_color);
  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_end_color);
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 216, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 216, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 216, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 216, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* … */
  __pyx_t_2 = PyNumber_Subtract(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 216, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_t_2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 216, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_diff_ = __pyx_t_6;
  __pyx_t_6.memview = NULL;
  __pyx_t_6.data = NULL;

+217:             numpy.array(start_color, dtype=float32)

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 217, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 217, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 217, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_v_start_color);
  __Pyx_GIVEREF(__pyx_v_start_color);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_start_color);
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 217, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 217, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 217, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 217, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+218:         float [::1] row = numpy.arange(width, dtype=float32) / (width - 1.0)

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_arange); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_width); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_float32); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble((__pyx_v_width - 1.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_dc_float(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 218, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_row = __pyx_t_7;
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;

+219:         unsigned char [:, :, ::1] rgb_gradient = empty((width, height, 3), dtype=uint8)

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 219, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_width); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 219, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_height); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 219, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 219, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
  __Pyx_INCREF(__pyx_int_3);
  __Pyx_GIVEREF(__pyx_int_3);
  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_int_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 219, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5);
  __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 219, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_uint8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 219, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(0, 219, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 219, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_unsigned_char(__pyx_t_2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_8.memview)) __PYX_ERR(0, 219, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_rgb_gradient = __pyx_t_8;
  __pyx_t_8.memview = NULL;
  __pyx_t_8.data = NULL;

+220:         float [3] start = numpy.array(start_color, dtype=float32)

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_v_start_color);
  __Pyx_GIVEREF(__pyx_v_start_color);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_start_color);
  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 220, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(__Pyx_carray_from_py_float(__pyx_t_4, __pyx_t_9, 3) < 0)) __PYX_ERR(0, 220, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  memcpy(&(__pyx_v_start[0]), __pyx_t_9, sizeof(__pyx_v_start[0]) * (3));

+221:         int i=0, j=0

  __pyx_v_i = 0;
  __pyx_v_j = 0;

 222: 

+223:     with nogil:

  {
      #ifdef WITH_THREAD
      PyThreadState *_save;
      Py_UNBLOCK_THREADS
      __Pyx_FastGIL_Remember();
      #endif
      /*try:*/ {
/* … */
      /*finally:*/ {
        /*normal exit:*/{
          #ifdef WITH_THREAD
          __Pyx_FastGIL_Forget();
          Py_BLOCK_THREADS
          #endif
          goto __pyx_L5;
        }
        __pyx_L5:;
      }
  }

+224:         for i in prange(width, schedule='static', num_threads=THREAD_NUMBER):

        __pyx_t_10 = __pyx_v_width;
        if ((1 == 0)) abort();
        {
            #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
                #undef likely
                #undef unlikely
                #define likely(x)   (x)
                #define unlikely(x) (x)
            #endif
            __pyx_t_12 = (__pyx_t_10 - 0 + 1 - 1/abs(1)) / 1;
            if (__pyx_t_12 > 0)
            {
                #ifdef _OPENMP
                #pragma omp parallel
                #endif /* _OPENMP */
                {
                    #ifdef _OPENMP
                    #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i) lastprivate(__pyx_v_j) schedule(static) num_threads(8)
                    #endif /* _OPENMP */
                    for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_12; __pyx_t_11++){
                        {
                            __pyx_v_i = (int)(0 + 1 * __pyx_t_11);
                            /* Initialize private variables to invalid values */
                            __pyx_v_j = ((int)0xbad0bad0);

+225:             for j in range(height):

                            __pyx_t_13 = __pyx_v_height;
                            __pyx_t_14 = __pyx_t_13;
                            for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) {
                              __pyx_v_j = __pyx_t_15;

+226:                rgb_gradient[i, j, 0] = <unsigned char>(start[0] + row[i] * diff_[0])

                              __pyx_t_16 = __pyx_v_i;
                              __pyx_t_17 = 0;
                              __pyx_t_18 = __pyx_v_i;
                              __pyx_t_19 = __pyx_v_j;
                              __pyx_t_20 = 0;
                              *((unsigned char *) ( /* dim=2 */ ((char *) (((unsigned char *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rgb_gradient.data + __pyx_t_18 * __pyx_v_rgb_gradient.strides[0]) ) + __pyx_t_19 * __pyx_v_rgb_gradient.strides[1]) )) + __pyx_t_20)) )) = ((unsigned char)((__pyx_v_start[0]) + ((*((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_row.data) + __pyx_t_16)) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_diff_.data + __pyx_t_17 * __pyx_v_diff_.strides[0]) ))))));

+227:                rgb_gradient[i, j, 1] = <unsigned char>(start[1] + row[i] * diff_[1])

                              __pyx_t_17 = __pyx_v_i;
                              __pyx_t_16 = 1;
                              __pyx_t_20 = __pyx_v_i;
                              __pyx_t_19 = __pyx_v_j;
                              __pyx_t_18 = 1;
                              *((unsigned char *) ( /* dim=2 */ ((char *) (((unsigned char *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rgb_gradient.data + __pyx_t_20 * __pyx_v_rgb_gradient.strides[0]) ) + __pyx_t_19 * __pyx_v_rgb_gradient.strides[1]) )) + __pyx_t_18)) )) = ((unsigned char)((__pyx_v_start[1]) + ((*((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_row.data) + __pyx_t_17)) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_diff_.data + __pyx_t_16 * __pyx_v_diff_.strides[0]) ))))));

+228:                rgb_gradient[i, j, 2] = <unsigned char>(start[2] + row[i] * diff_[2])

                              __pyx_t_16 = __pyx_v_i;
                              __pyx_t_17 = 2;
                              __pyx_t_18 = __pyx_v_i;
                              __pyx_t_19 = __pyx_v_j;
                              __pyx_t_20 = 2;
                              *((unsigned char *) ( /* dim=2 */ ((char *) (((unsigned char *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rgb_gradient.data + __pyx_t_18 * __pyx_v_rgb_gradient.strides[0]) ) + __pyx_t_19 * __pyx_v_rgb_gradient.strides[1]) )) + __pyx_t_20)) )) = ((unsigned char)((__pyx_v_start[2]) + ((*((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_row.data) + __pyx_t_16)) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_diff_.data + __pyx_t_17 * __pyx_v_diff_.strides[0]) ))))));
                            }
                        }
                    }
                }
            }
        }
        #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
            #undef likely
            #undef unlikely
            #define likely(x)   __builtin_expect(!!(x), 1)
            #define unlikely(x) __builtin_expect(!!(x), 0)
        #endif
      }

 229: 

+230:     return make_surface(asarray(rgb_gradient)).convert()

  __Pyx_XDECREF(__pyx_r);
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_make_surface); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_asarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 230, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_21 = __pyx_memoryview_fromslice(__pyx_v_rgb_gradient, 3, (PyObject *(*)(char *)) __pyx_memview_get_unsigned_char, (int (*)(char *, PyObject *)) __pyx_memview_set_unsigned_char, 0);; if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 230, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_21);
  __pyx_t_22 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_22 = PyMethod_GET_SELF(__pyx_t_1);
    if (likely(__pyx_t_22)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
      __Pyx_INCREF(__pyx_t_22);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_1, function);
    }
  }
  __pyx_t_5 = (__pyx_t_22) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_22, __pyx_t_21) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_21);
  __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 230, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_1)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_1);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_3 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_1, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_5);
  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_convert); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_4 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 230, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

 231: 

 232: 

 233: 

 234: @cython.boundscheck(False)

 235: @cython.wraparound(False)

 236: @cython.nonecheck(False)

 237: @cython.cdivision(True)

+238: cdef float color_dist_hsv(hsv hsv_1, hsv hsv_2)nogil:

static float __pyx_f_12PygameShader_4misc_color_dist_hsv(struct hsv __pyx_v_hsv_1, struct hsv __pyx_v_hsv_2) {
  float __pyx_r;
/* … */
  /* function exit code */
  __pyx_L0:;
  return __pyx_r;
}

+239:     return (hsv_1.h - hsv_2.h) ** 2 + (hsv_1.s - hsv_2.s) ** 2 + (hsv_1.v - hsv_2.v) ** 2

  __pyx_r = ((powf((__pyx_v_hsv_1.h - __pyx_v_hsv_2.h), 2.0) + powf((__pyx_v_hsv_1.s - __pyx_v_hsv_2.s), 2.0)) + powf((__pyx_v_hsv_1.v - __pyx_v_hsv_2.v), 2.0));
  goto __pyx_L0;

 240: 

 241: 

 242: @cython.boundscheck(False)

 243: @cython.wraparound(False)

 244: @cython.nonecheck(False)

 245: @cython.cdivision(True)

+246: cdef float color_dist_hsl(hsl hsl_1, hsl hsl_2)nogil:

static float __pyx_f_12PygameShader_4misc_color_dist_hsl(struct hsl __pyx_v_hsl_1, struct hsl __pyx_v_hsl_2) {
  float __pyx_r;
/* … */
  /* function exit code */
  __pyx_L0:;
  return __pyx_r;
}

+247:     return (hsl_1.h - hsl_2.h) ** 2 + (hsl_1.s - hsl_2.s) ** 2 + (hsl_1.l - hsl_2.l) ** 2

  __pyx_r = ((powf((__pyx_v_hsl_1.h - __pyx_v_hsl_2.h), 2.0) + powf((__pyx_v_hsl_1.s - __pyx_v_hsl_2.s), 2.0)) + powf((__pyx_v_hsl_1.l - __pyx_v_hsl_2.l), 2.0));
  goto __pyx_L0;

 248: 

 249: 

 250: @cython.boundscheck(False)

 251: @cython.wraparound(False)

 252: @cython.nonecheck(False)

 253: @cython.cdivision(True)

+254: cdef rgb color_diff_hsv(

static struct rgb __pyx_f_12PygameShader_4misc_color_diff_hsv(struct rgb __pyx_v_color0, __Pyx_memviewslice __pyx_v_palette_, Py_ssize_t __pyx_v_p_length) {
  float *__pyx_v_hsv_values;
  int __pyx_v_i;
  struct rgb __pyx_v_color1;
  struct hsv __pyx_v_hsv1;
  struct hsv __pyx_v_hsv2;
  float __pyx_v_minimum;
  int __pyx_v_found;
  struct rgb __pyx_r;
/* … */
  /* function exit code */
  __pyx_L0:;
  return __pyx_r;
}

 255:         rgb color0,

 256:         float [:, :] palette_,

 257:         Py_ssize_t p_length

 258: )nogil:

 259:     """

 260:     FIND THE CLOSEST MATCH FOR A GIVEN COLOR (color0) FROM 

 261:     A COLOR PALETTE (palette_). 

 262:     

 263:     This method is using hsv space to find the closest color from the palette.

 264:     Each colors from the palette are compare with the HSV value of the given color

 265:     and the minimal difference between HSV values represent the closest match. 

 266:     

 267:     :param color0  : struct RGB containing the pixel color 

 268:     :param palette_: numpy.ndarray shape (w, 3) type float32 containing the palette colors RGB 

 269:     range [0 ... 255] 

 270:     :param p_length: integer; size of the given palette or number of colors

 271:     :return: struct RGB containing the new pixel values RGB 

 272:     """

 273: 

 274:     cdef:

 275: 

+276:         float * hsv_values = <float *> malloc(p_length * sizeof(float))

  __pyx_v_hsv_values = ((float *)malloc((__pyx_v_p_length * (sizeof(float)))));

 277:         int i

 278:         rgb color1

 279:         hsv hsv1, hsv2

 280:         float minimum

 281: 

 282: 

 283:     # THE RGB TO HSV VALUE NEVER CHANGE INSIDE THE LOOP

+284:     hsv1 = struct_rgb_to_hsv(

  __pyx_v_hsv1 = struct_rgb_to_hsv((((float)__pyx_v_color0.r) / ((float)255.0)), (((float)__pyx_v_color0.g) / ((float)255.0)), (((float)__pyx_v_color0.b) / ((float)255.0)));

 285:         <float>color0.r / <float>255.0,

 286:         <float>color0.g / <float>255.0,

 287:         <float>color0.b / <float>255.0)

 288: 

 289: 

+290:     for i in range(p_length):

  __pyx_t_1 = __pyx_v_p_length;
  __pyx_t_2 = __pyx_t_1;
  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
    __pyx_v_i = __pyx_t_3;

 291: 

+292:         hsv2 = struct_rgb_to_hsv(

    __pyx_v_hsv2 = struct_rgb_to_hsv((((float)(*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_4 * __pyx_v_palette_.strides[0]) ) + __pyx_t_5 * __pyx_v_palette_.strides[1]) )))) / ((float)255.0)), (((float)(*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_6 * __pyx_v_palette_.strides[0]) ) + __pyx_t_7 * __pyx_v_palette_.strides[1]) )))) / ((float)255.0)), (((float)(*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_8 * __pyx_v_palette_.strides[0]) ) + __pyx_t_9 * __pyx_v_palette_.strides[1]) )))) / ((float)255.0)));

+293:             <float>palette_[ i, 0 ]/ <float>255.0,

    __pyx_t_4 = __pyx_v_i;
    __pyx_t_5 = 0;

+294:             <float>palette_[ i, 1 ]/ <float>255.0,

    __pyx_t_6 = __pyx_v_i;
    __pyx_t_7 = 1;

+295:             <float>palette_[ i, 2 ]/ <float>255.0)

    __pyx_t_8 = __pyx_v_i;
    __pyx_t_9 = 2;

 296: 

+297:         hsv_values[i] = <float>color_dist_hsv(hsv1, hsv2)

    (__pyx_v_hsv_values[__pyx_v_i]) = ((float)__pyx_f_12PygameShader_4misc_color_dist_hsv(__pyx_v_hsv1, __pyx_v_hsv2));
  }

 298: 

+299:     minimum = <float>minf(hsv_values, p_length)

  __pyx_v_minimum = ((float)minf(__pyx_v_hsv_values, __pyx_v_p_length));

 300: 

+301:     cdef bint found = False

  __pyx_v_found = 0;

+302:     for i in range(p_length):

  __pyx_t_1 = __pyx_v_p_length;
  __pyx_t_2 = __pyx_t_1;
  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
    __pyx_v_i = __pyx_t_3;

+303:         if minimum == hsv_values[i]:

    __pyx_t_10 = ((__pyx_v_minimum == (__pyx_v_hsv_values[__pyx_v_i])) != 0);
    if (__pyx_t_10) {
/* … */
    }
  }
  __pyx_L6_break:;

+304:             found = True

      __pyx_v_found = 1;

+305:             break

      goto __pyx_L6_break;

 306: 

+307:     if found:

  __pyx_t_10 = (__pyx_v_found != 0);
  if (__pyx_t_10) {
/* … */
    goto __pyx_L8;
  }

+308:         color1.r = palette_[ i, 0 ]

    __pyx_t_9 = __pyx_v_i;
    __pyx_t_8 = 0;
    __pyx_v_color1.r = (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_9 * __pyx_v_palette_.strides[0]) ) + __pyx_t_8 * __pyx_v_palette_.strides[1]) )));

+309:         color1.g = palette_[ i, 1 ]

    __pyx_t_8 = __pyx_v_i;
    __pyx_t_9 = 1;
    __pyx_v_color1.g = (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_8 * __pyx_v_palette_.strides[0]) ) + __pyx_t_9 * __pyx_v_palette_.strides[1]) )));

+310:         color1.b = palette_[ i, 2 ]

    __pyx_t_9 = __pyx_v_i;
    __pyx_t_8 = 2;
    __pyx_v_color1.b = (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_9 * __pyx_v_palette_.strides[0]) ) + __pyx_t_8 * __pyx_v_palette_.strides[1]) )));

 311:     else:

+312:         color1.r = 0.0

  /*else*/ {
    __pyx_v_color1.r = 0.0;

+313:         color1.g = 0.

    __pyx_v_color1.g = 0.;

+314:         color1.b = 0.

    __pyx_v_color1.b = 0.;
  }
  __pyx_L8:;

 315: 

+316:     free(hsv_values)

  free(__pyx_v_hsv_values);

 317: 

+318:     return color1

  __pyx_r = __pyx_v_color1;
  goto __pyx_L0;

 319: 

 320: 

 321: 

 322: @cython.boundscheck(False)

 323: @cython.wraparound(False)

 324: @cython.nonecheck(False)

 325: @cython.cdivision(True)

+326: cdef rgb color_diff_hsl(

static struct rgb __pyx_f_12PygameShader_4misc_color_diff_hsl(struct rgb __pyx_v_color0, __Pyx_memviewslice __pyx_v_palette_, Py_ssize_t __pyx_v_p_length) {
  float *__pyx_v_hsl_values;
  int __pyx_v_i;
  struct rgb __pyx_v_color1;
  struct hsl __pyx_v_hsl1;
  struct hsl __pyx_v_hsl2;
  float __pyx_v_minimum;
  int __pyx_v_found;
  struct rgb __pyx_r;
/* … */
  /* function exit code */
  __pyx_L0:;
  return __pyx_r;
}

 327:         rgb color0,

 328:         float [:, :] palette_,

 329:         Py_ssize_t p_length

 330: )nogil:

 331:     """

 332: 

 333:     FIND THE CLOSEST MATCH FOR A GIVEN COLOR (color0) FROM 

 334:     A COLOR PALETTE (palette_). 

 335:     

 336:     This method is using HSL color space to find the closest color from the palette.

 337:     Each colors from the palette are compare with the HSL values of the given color

 338:     and the minimal difference between HSL values represent the closest match. 

 339:     

 340:     :param color0  : struct RGB containing the pixel color 

 341:     :param palette_: numpy.ndarray shape (w, 3) type float32 containing the palette colors RGB 

 342:     range [0 ... 255] 

 343:     :param p_length: integer; size of the given palette or number of colors

 344:     :return: struct RGB containing the new pixel values RGB 

 345:     """

 346: 

 347:     cdef:

 348: 

+349:         float * hsl_values = <float *> malloc(p_length * sizeof(float))

  __pyx_v_hsl_values = ((float *)malloc((__pyx_v_p_length * (sizeof(float)))));

 350:         int i

 351:         rgb color1

 352:         hsl hsl1, hsl2

 353:         float minimum

 354: 

 355: 

 356:     # THE RGB TO HSL VALUE NEVER CHANGE INSIDE THE LOOP

+357:     hsl1 = struct_rgb_to_hsl(

  __pyx_v_hsl1 = struct_rgb_to_hsl((((float)__pyx_v_color0.r) / ((float)255.0)), (((float)__pyx_v_color0.g) / ((float)255.0)), (((float)__pyx_v_color0.b) / ((float)255.0)));

 358:         <float>color0.r / <float>255.0,

 359:         <float>color0.g / <float>255.0,

 360:         <float>color0.b / <float>255.0)

 361: 

+362:     for i in prange(p_length):

  __pyx_t_1 = __pyx_v_p_length;
  if ((1 == 0)) abort();
  {
      #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
          #undef likely
          #undef unlikely
          #define likely(x)   (x)
          #define unlikely(x) (x)
      #endif
      __pyx_t_3 = (__pyx_t_1 - 0 + 1 - 1/abs(1)) / 1;
      if (__pyx_t_3 > 0)
      {
          #ifdef _OPENMP
          #pragma omp parallel
          #endif /* _OPENMP */
          {
              #ifdef _OPENMP
              #pragma omp for lastprivate(__pyx_v_hsl2) firstprivate(__pyx_v_i) lastprivate(__pyx_v_i)
              #endif /* _OPENMP */
              for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){
                  {
                      __pyx_v_i = (int)(0 + 1 * __pyx_t_2);

 363: 

+364:         hsl2 = struct_rgb_to_hsl(

                      __pyx_v_hsl2 = struct_rgb_to_hsl((((float)(*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_4 * __pyx_v_palette_.strides[0]) ) + __pyx_t_5 * __pyx_v_palette_.strides[1]) )))) / ((float)255.0)), (((float)(*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_6 * __pyx_v_palette_.strides[0]) ) + __pyx_t_7 * __pyx_v_palette_.strides[1]) )))) / ((float)255.0)), (((float)(*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_8 * __pyx_v_palette_.strides[0]) ) + __pyx_t_9 * __pyx_v_palette_.strides[1]) )))) / ((float)255.0)));

+365:             <float>palette_[ i, 0 ]/ <float>255.0,

                      __pyx_t_4 = __pyx_v_i;
                      __pyx_t_5 = 0;

+366:             <float>palette_[ i, 1 ]/ <float>255.0,

                      __pyx_t_6 = __pyx_v_i;
                      __pyx_t_7 = 1;

+367:             <float>palette_[ i, 2 ]/ <float>255.0)

                      __pyx_t_8 = __pyx_v_i;
                      __pyx_t_9 = 2;

 368: 

+369:         hsl_values[i] = <float>color_dist_hsl(hsl1, hsl2)

                      (__pyx_v_hsl_values[__pyx_v_i]) = ((float)__pyx_f_12PygameShader_4misc_color_dist_hsl(__pyx_v_hsl1, __pyx_v_hsl2));
                  }
              }
          }
      }
  }
  #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
      #undef likely
      #undef unlikely
      #define likely(x)   __builtin_expect(!!(x), 1)
      #define unlikely(x) __builtin_expect(!!(x), 0)
  #endif

 370: 

+371:     minimum = <float>minf(hsl_values, p_length)

  __pyx_v_minimum = ((float)minf(__pyx_v_hsl_values, __pyx_v_p_length));

 372: 

+373:     cdef bint found = False

  __pyx_v_found = 0;

 374: 

+375:     for i in range(p_length):

  __pyx_t_3 = __pyx_v_p_length;
  __pyx_t_2 = __pyx_t_3;
  for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_2; __pyx_t_10+=1) {
    __pyx_v_i = __pyx_t_10;

+376:         if minimum == hsl_values[i]:

    __pyx_t_11 = ((__pyx_v_minimum == (__pyx_v_hsl_values[__pyx_v_i])) != 0);
    if (__pyx_t_11) {
/* … */
    }
  }
  __pyx_L10_break:;

+377:             found = True

      __pyx_v_found = 1;

+378:             break

      goto __pyx_L10_break;

 379: 

+380:     if found:

  __pyx_t_11 = (__pyx_v_found != 0);
  if (__pyx_t_11) {
/* … */
    goto __pyx_L12;
  }

+381:         color1.r = palette_[ i, 0 ]

    __pyx_t_9 = __pyx_v_i;
    __pyx_t_8 = 0;
    __pyx_v_color1.r = (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_9 * __pyx_v_palette_.strides[0]) ) + __pyx_t_8 * __pyx_v_palette_.strides[1]) )));

+382:         color1.g = palette_[ i, 1 ]

    __pyx_t_8 = __pyx_v_i;
    __pyx_t_9 = 1;
    __pyx_v_color1.g = (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_8 * __pyx_v_palette_.strides[0]) ) + __pyx_t_9 * __pyx_v_palette_.strides[1]) )));

+383:         color1.b = palette_[ i, 2 ]

    __pyx_t_9 = __pyx_v_i;
    __pyx_t_8 = 2;
    __pyx_v_color1.b = (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_9 * __pyx_v_palette_.strides[0]) ) + __pyx_t_8 * __pyx_v_palette_.strides[1]) )));

 384:     else:

+385:         color1.r = <float>0.0

  /*else*/ {
    __pyx_v_color1.r = ((float)0.0);

+386:         color1.g = <float>0.0

    __pyx_v_color1.g = ((float)0.0);

+387:         color1.b = <float>0.0

    __pyx_v_color1.b = ((float)0.0);
  }
  __pyx_L12:;

 388: 

+389:     free(hsl_values)

  free(__pyx_v_hsl_values);

 390: 

+391:     return color1

  __pyx_r = __pyx_v_color1;
  goto __pyx_L0;

 392: 

 393: @cython.boundscheck(False)

 394: @cython.wraparound(False)

 395: @cython.nonecheck(False)

 396: @cython.cdivision(True)

+397: cdef rgb close_color(

static struct rgb __pyx_f_12PygameShader_4misc_close_color(struct rgb __pyx_v_colors, __Pyx_memviewslice __pyx_v_palette_, Py_ssize_t __pyx_v_w) {
  int __pyx_v_i;
  float *__pyx_v_tmp_v;
  struct rgb __pyx_v_rgb_;
  float __pyx_v_v_min;
  int __pyx_v_s1;
  int __pyx_v_s2;
  struct hsv __pyx_v_color0_hsv;
  struct hsv __pyx_v_hsv1;
  struct hsv __pyx_v_hsv2;
  struct rgb __pyx_r;
/* … */
  /* function exit code */
  __pyx_L0:;
  return __pyx_r;
}

 398:         rgb colors,

 399:         float [:, :] palette_,

 400:         Py_ssize_t w

 401: )nogil:

 402:     """

 403:     FIND THE NEAREST COLOR MATCHING A GIVEN COLOR 

 404:     

 405:     Iterate over a 2d color palette filled with RGB values (array shape, 

 406:     w, 3) type float32. The palette is not normalised and contains values 

 407:     in range [0...255] 

 408:     During the iteration, the given color is compare with the palette values 

 409:     subtracting each components and summed up to be able to find the smallest 

 410:     value. The original color 'colors' will be replaced with a new color

 411:     from the palette (new RGB components). 

 412:     This algorithm will work if the color palette contains unique RGB components

 413:     For palettes with duplicate color, the algorithm will select the first color 

 414:     corresponding to the sum of the RGB difference between each components

 415:     

 416:     :param colors  : struct RGB; float; Colors define with a struct type of data  

 417:     :param palette_: numpy.array; Palette containing the RGB color values range [0...255]  

 418:     :param w       : integer; size of the palette 

 419:     :return        : struct rgb containing the new RGB values close match from 

 420:     the given color  

 421:     """

 422: 

 423:     cdef:

 424:         int i

+425:         float * tmp_v    = <float *> malloc(w * sizeof(float))

  __pyx_v_tmp_v = ((float *)malloc((__pyx_v_w * (sizeof(float)))));

 426:         rgb rgb_

 427:         float v_min,

 428: 

 429:     # SUM ALL RGB DIFFERENCES

+430:     for i in prange(w):

  __pyx_t_1 = __pyx_v_w;
  if ((1 == 0)) abort();
  {
      #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
          #undef likely
          #undef unlikely
          #define likely(x)   (x)
          #define unlikely(x) (x)
      #endif
      __pyx_t_3 = (__pyx_t_1 - 0 + 1 - 1/abs(1)) / 1;
      if (__pyx_t_3 > 0)
      {
          #ifdef _OPENMP
          #pragma omp parallel
          #endif /* _OPENMP */
          {
              #ifdef _OPENMP
              #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i)
              #endif /* _OPENMP */
              for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){
                  {
                      __pyx_v_i = (int)(0 + 1 * __pyx_t_2);

+431:         tmp_v[ i ] = sqrt((

                      (__pyx_v_tmp_v[__pyx_v_i]) = sqrt(((powf((__pyx_v_colors.r - (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_4 * __pyx_v_palette_.strides[0]) ) + __pyx_t_5 * __pyx_v_palette_.strides[1]) )))), 2.0) + powf((__pyx_v_colors.g - (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_6 * __pyx_v_palette_.strides[0]) ) + __pyx_t_7 * __pyx_v_palette_.strides[1]) )))), 2.0)) + powf((__pyx_v_colors.b - (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_8 * __pyx_v_palette_.strides[0]) ) + __pyx_t_9 * __pyx_v_palette_.strides[1]) )))), 2.0)));
                  }
              }
          }
      }
  }
  #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
      #undef likely
      #undef unlikely
      #define likely(x)   __builtin_expect(!!(x), 1)
      #define unlikely(x) __builtin_expect(!!(x), 0)
  #endif

+432:             colors.r - palette_[ i, 0 ]) ** 2 + \

                      __pyx_t_4 = __pyx_v_i;
                      __pyx_t_5 = 0;

+433:            (colors.g - palette_[ i, 1 ]) ** 2 + \

                      __pyx_t_6 = __pyx_v_i;
                      __pyx_t_7 = 1;

+434:            (colors.b - palette_[ i, 2 ]) ** 2)

                      __pyx_t_8 = __pyx_v_i;
                      __pyx_t_9 = 2;

 435:     # THE MINIMUM VALUE IS THE CLOSEST RGB MATCH

+436:     v_min = <float> minf(tmp_v, w)

  __pyx_v_v_min = ((float)minf(__pyx_v_tmp_v, __pyx_v_w));

 437: 

 438: 

+439:     cdef int s1 = 0

  __pyx_v_s1 = 0;

+440:     cdef int s2 = 0

  __pyx_v_s2 = 0;

 441: 

 442:     # CHECK FIRST SOLUTION

+443:     for i in range(w):

  __pyx_t_3 = __pyx_v_w;
  __pyx_t_2 = __pyx_t_3;
  for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_2; __pyx_t_10+=1) {
    __pyx_v_i = __pyx_t_10;

+444:         if round_c(v_min) == round_c(tmp_v[i]):

    __pyx_t_11 = ((round(__pyx_v_v_min) == round((__pyx_v_tmp_v[__pyx_v_i]))) != 0);
    if (__pyx_t_11) {
/* … */
    }
  }
  __pyx_L10_break:;

+445:             s1 = i

      __pyx_v_s1 = __pyx_v_i;

+446:             break

      goto __pyx_L10_break;

 447: 

 448:     # CHECK FOR COLORS WITH SAME DISTANCE

+449:     for i in range(w):

  __pyx_t_3 = __pyx_v_w;
  __pyx_t_2 = __pyx_t_3;
  for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_2; __pyx_t_10+=1) {
    __pyx_v_i = __pyx_t_10;

+450:         if round_c(v_min) == round_c(tmp_v[i]):

    __pyx_t_11 = ((round(__pyx_v_v_min) == round((__pyx_v_tmp_v[__pyx_v_i]))) != 0);
    if (__pyx_t_11) {
/* … */
    }
  }

+451:             if i != s1:

      __pyx_t_11 = ((__pyx_v_i != __pyx_v_s1) != 0);
      if (__pyx_t_11) {
/* … */
      }

+452:                 s2 = i

        __pyx_v_s2 = __pyx_v_i;

 453: 

 454:     cdef:

 455:         hsv color0_hsv

 456:         hsv hsv1

 457:         hsv hsv2

 458: 

+459:     if s1!= 0 and s2 != 0:

  __pyx_t_12 = ((__pyx_v_s1 != 0) != 0);
  if (__pyx_t_12) {
  } else {
    __pyx_t_11 = __pyx_t_12;
    goto __pyx_L17_bool_binop_done;
  }
  __pyx_t_12 = ((__pyx_v_s2 != 0) != 0);
  __pyx_t_11 = __pyx_t_12;
  __pyx_L17_bool_binop_done:;
  if (__pyx_t_11) {
/* … */
    goto __pyx_L16;
  }

+460:         color0_hsv = struct_rgb_to_hsv(

    __pyx_v_color0_hsv = struct_rgb_to_hsv((__pyx_v_colors.r / ((float)255.0)), (__pyx_v_colors.g / ((float)255.0)), (__pyx_v_colors.b / ((float)255.0)));

 461:             colors.r/<float>255.0,

 462:             colors.g/<float>255.0,

 463:             colors.b/<float>255.0)

+464:         hsv1 = struct_rgb_to_hsv(

    __pyx_v_hsv1 = struct_rgb_to_hsv(((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_9 * __pyx_v_palette_.strides[0]) ) + __pyx_t_8 * __pyx_v_palette_.strides[1]) ))) / ((float)255.0)), ((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_7 * __pyx_v_palette_.strides[0]) ) + __pyx_t_6 * __pyx_v_palette_.strides[1]) ))) / ((float)255.0)), ((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_5 * __pyx_v_palette_.strides[0]) ) + __pyx_t_4 * __pyx_v_palette_.strides[1]) ))) / ((float)255.0)));

+465:             palette_[ s1, 0 ]/<float>255.0,

    __pyx_t_9 = __pyx_v_s1;
    __pyx_t_8 = 0;

+466:             palette_[ s1, 0 ]/<float>255.0,

    __pyx_t_7 = __pyx_v_s1;
    __pyx_t_6 = 0;

+467:             palette_[ s1, 0 ]/<float>255.0)

    __pyx_t_5 = __pyx_v_s1;
    __pyx_t_4 = 0;

+468:         hsv2 = struct_rgb_to_hsv(

    __pyx_v_hsv2 = struct_rgb_to_hsv(((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_4 * __pyx_v_palette_.strides[0]) ) + __pyx_t_5 * __pyx_v_palette_.strides[1]) ))) / ((float)255.0)), ((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_6 * __pyx_v_palette_.strides[0]) ) + __pyx_t_7 * __pyx_v_palette_.strides[1]) ))) / ((float)255.0)), ((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_8 * __pyx_v_palette_.strides[0]) ) + __pyx_t_9 * __pyx_v_palette_.strides[1]) ))) / ((float)255.0)));

+469:             palette_[ s2, 0 ] / <float> 255.0,

    __pyx_t_4 = __pyx_v_s2;
    __pyx_t_5 = 0;

+470:             palette_[ s2, 0 ] / <float> 255.0,

    __pyx_t_6 = __pyx_v_s2;
    __pyx_t_7 = 0;

+471:             palette_[ s2, 0 ] / <float> 255.0)

    __pyx_t_8 = __pyx_v_s2;
    __pyx_t_9 = 0;

+472:         if (color0_hsv.h - hsv1.h) ** 2 <  (color0_hsv.h - hsv2.h) ** 2:

    __pyx_t_11 = ((powf((__pyx_v_color0_hsv.h - __pyx_v_hsv1.h), 2.0) < powf((__pyx_v_color0_hsv.h - __pyx_v_hsv2.h), 2.0)) != 0);
    if (__pyx_t_11) {
/* … */
      goto __pyx_L19;
    }

+473:             i = s1

      __pyx_v_i = __pyx_v_s1;

 474:         else:

+475:             i = s2

    /*else*/ {
      __pyx_v_i = __pyx_v_s2;
    }
    __pyx_L19:;

 476:     else:

+477:         i = s1

  /*else*/ {
    __pyx_v_i = __pyx_v_s1;
  }
  __pyx_L16:;

 478: 

+479:     rgb_.r = palette_[ i, 0 ]

  __pyx_t_9 = __pyx_v_i;
  __pyx_t_8 = 0;
  __pyx_v_rgb_.r = (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_9 * __pyx_v_palette_.strides[0]) ) + __pyx_t_8 * __pyx_v_palette_.strides[1]) )));

+480:     rgb_.g = palette_[ i, 1 ]

  __pyx_t_8 = __pyx_v_i;
  __pyx_t_9 = 1;
  __pyx_v_rgb_.g = (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_8 * __pyx_v_palette_.strides[0]) ) + __pyx_t_9 * __pyx_v_palette_.strides[1]) )));

+481:     rgb_.b = palette_[ i, 2 ]

  __pyx_t_9 = __pyx_v_i;
  __pyx_t_8 = 2;
  __pyx_v_rgb_.b = (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_9 * __pyx_v_palette_.strides[0]) ) + __pyx_t_8 * __pyx_v_palette_.strides[1]) )));

 482: 

+483:     return rgb_

  __pyx_r = __pyx_v_rgb_;
  goto __pyx_L0;

 484: 

 485: 

 486: 

 487: 

 488: @cython.boundscheck(False)

 489: @cython.wraparound(False)

 490: @cython.nonecheck(False)

 491: @cython.cdivision(True)

+492: cdef rgb use_palette(

static struct rgb __pyx_f_12PygameShader_4misc_use_palette(struct rgb __pyx_v_colors, __Pyx_memviewslice __pyx_v_palette_, Py_ssize_t __pyx_v_w) {
  int __pyx_v_i;
  int __pyx_v_j;
  int __pyx_v_k;
  float *__pyx_v_v_red;
  float *__pyx_v_v_green;
  float *__pyx_v_v_blue;
  float __pyx_v_r_min;
  float __pyx_v_g_min;
  float __pyx_v_b_min;
  struct rgb __pyx_v_rgb_;
  struct rgb __pyx_r;
/* … */
  /* function exit code */
  __pyx_L0:;
  return __pyx_r;
}

 493:         rgb colors,

 494:         float [:, :] palette_,

 495:         Py_ssize_t w

 496: )nogil:

 497:     """

 498:     PICKED RGB VALUES FROM A GIVEN PALETTE TO MATCH A GIVEN COLOR

 499:     ** PAINTING MODE **

 500: 

 501:     Picked r, g, b values from a palette by going through every

 502:     elements and picking the closest match for each channels.

 503:     The final color will be not necessary match a color from the palette

 504:     but will have instead, a palette values from each channels.

 505: 

 506: 

 507:     :param colors  : struct; Contains RGB values integer values in range [0..255]

 508:     :param palette_: numpy.array shape (w, 3) type float32 containing RGB colors values

 509:     :param w       : Size of the palette or number of colors available

 510:     :return        : Return a color RGB containing colors from the palette.

 511:     """

 512: 

 513:     cdef:

 514:         int i, j, k

+515:         float * v_red   = <float *> malloc(w * sizeof(float))

  __pyx_v_v_red = ((float *)malloc((__pyx_v_w * (sizeof(float)))));

+516:         float * v_green = <float *> malloc(w * sizeof(float))

  __pyx_v_v_green = ((float *)malloc((__pyx_v_w * (sizeof(float)))));

+517:         float * v_blue  = <float *> malloc(w * sizeof(float))

  __pyx_v_v_blue = ((float *)malloc((__pyx_v_w * (sizeof(float)))));

 518:         float r_min, g_min, b_min

 519:         rgb rgb_

 520: 

 521:     # GO THROUGH EACH CHANNELS OF THE PALETTE AND

 522:     # SUBTRACT VALUES.

+523:     for i in prange(w):

  __pyx_t_1 = __pyx_v_w;
  if ((1 == 0)) abort();
  {
      #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
          #undef likely
          #undef unlikely
          #define likely(x)   (x)
          #define unlikely(x) (x)
      #endif
      __pyx_t_3 = (__pyx_t_1 - 0 + 1 - 1/abs(1)) / 1;
      if (__pyx_t_3 > 0)
      {
          #ifdef _OPENMP
          #pragma omp parallel
          #endif /* _OPENMP */
          {
              #ifdef _OPENMP
              #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i)
              #endif /* _OPENMP */
              for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){
                  {
                      __pyx_v_i = (int)(0 + 1 * __pyx_t_2);

+524:         v_red[i]   = abs_c(colors.r - palette_[i, 0] )

                      __pyx_t_4 = __pyx_v_i;
                      __pyx_t_5 = 0;
                      (__pyx_v_v_red[__pyx_v_i]) = fabs((__pyx_v_colors.r - (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_4 * __pyx_v_palette_.strides[0]) ) + __pyx_t_5 * __pyx_v_palette_.strides[1]) )))));

+525:         v_green[i] = abs_c(colors.g - palette_[i, 1] )

                      __pyx_t_5 = __pyx_v_i;
                      __pyx_t_4 = 1;
                      (__pyx_v_v_green[__pyx_v_i]) = fabs((__pyx_v_colors.g - (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_5 * __pyx_v_palette_.strides[0]) ) + __pyx_t_4 * __pyx_v_palette_.strides[1]) )))));

+526:         v_blue[i]  = abs_c(colors.b - palette_[i, 2] )

                      __pyx_t_4 = __pyx_v_i;
                      __pyx_t_5 = 2;
                      (__pyx_v_v_blue[__pyx_v_i]) = fabs((__pyx_v_colors.b - (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_4 * __pyx_v_palette_.strides[0]) ) + __pyx_t_5 * __pyx_v_palette_.strides[1]) )))));
                  }
              }
          }
      }
  }
  #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
      #undef likely
      #undef unlikely
      #define likely(x)   __builtin_expect(!!(x), 1)
      #define unlikely(x) __builtin_expect(!!(x), 0)
  #endif

 527: 

 528:     # THE FINAL R, G, B VALUES WILL BE A PICKED

 529:     # COLOR FROM EACH CHANNELS CLOSE TO THE ORIGINAL PIXEL

 530:     # VALUE

+531:     r_min = <float> minf(v_red, w)

  __pyx_v_r_min = ((float)minf(__pyx_v_v_red, __pyx_v_w));

+532:     g_min = <float> minf(v_green, w)

  __pyx_v_g_min = ((float)minf(__pyx_v_v_green, __pyx_v_w));

+533:     b_min = <float> minf(v_blue, w)

  __pyx_v_b_min = ((float)minf(__pyx_v_v_blue, __pyx_v_w));

 534: 

 535:     # FIND A RED COLOR FROM THE PALETTE

 536:     # CLOSE TO THE ORIGINAL RED VALUE

+537:     for i in range(w):

  __pyx_t_3 = __pyx_v_w;
  __pyx_t_2 = __pyx_t_3;
  for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_2; __pyx_t_6+=1) {
    __pyx_v_i = __pyx_t_6;

+538:         if v_red[i] == r_min:

    __pyx_t_7 = (((__pyx_v_v_red[__pyx_v_i]) == __pyx_v_r_min) != 0);
    if (__pyx_t_7) {
/* … */
    }
  }
  __pyx_L10_break:;

+539:             break

      goto __pyx_L10_break;

 540: 

 541:     # FIND A GREEN COLOR FROM THE PALETTE

 542:     # CLOSE TO THE ORIGINAL GREEN VALUE

+543:     for j in range(w):

  __pyx_t_3 = __pyx_v_w;
  __pyx_t_2 = __pyx_t_3;
  for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_2; __pyx_t_6+=1) {
    __pyx_v_j = __pyx_t_6;

+544:         if v_green[j] == g_min:

    __pyx_t_7 = (((__pyx_v_v_green[__pyx_v_j]) == __pyx_v_g_min) != 0);
    if (__pyx_t_7) {
/* … */
    }
  }
  __pyx_L13_break:;

+545:             break

      goto __pyx_L13_break;

 546: 

 547:     # FIND A BLUE COLOR FROM THE PALETTE

 548:     # CLOSE TO THE ORIGINAL BLUE VALUE

+549:     for k in range(w):

  __pyx_t_3 = __pyx_v_w;
  __pyx_t_2 = __pyx_t_3;
  for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_2; __pyx_t_6+=1) {
    __pyx_v_k = __pyx_t_6;

+550:         if v_blue[k] == b_min:

    __pyx_t_7 = (((__pyx_v_v_blue[__pyx_v_k]) == __pyx_v_b_min) != 0);
    if (__pyx_t_7) {
/* … */
    }
  }
  __pyx_L16_break:;

+551:             break

      goto __pyx_L16_break;

 552: 

+553:     rgb_.r = palette_[i, 0]

  __pyx_t_5 = __pyx_v_i;
  __pyx_t_4 = 0;
  __pyx_v_rgb_.r = (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_5 * __pyx_v_palette_.strides[0]) ) + __pyx_t_4 * __pyx_v_palette_.strides[1]) )));

+554:     rgb_.g = palette_[j, 1]

  __pyx_t_4 = __pyx_v_j;
  __pyx_t_5 = 1;
  __pyx_v_rgb_.g = (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_4 * __pyx_v_palette_.strides[0]) ) + __pyx_t_5 * __pyx_v_palette_.strides[1]) )));

+555:     rgb_.b = palette_[k, 2]

  __pyx_t_5 = __pyx_v_k;
  __pyx_t_4 = 2;
  __pyx_v_rgb_.b = (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_palette_.data + __pyx_t_5 * __pyx_v_palette_.strides[0]) ) + __pyx_t_4 * __pyx_v_palette_.strides[1]) )));

 556: 

+557:     free(v_red)

  free(__pyx_v_v_red);

+558:     free(v_green)

  free(__pyx_v_v_green);

+559:     free(v_blue)

  free(__pyx_v_v_blue);

 560: 

+561:     return rgb_

  __pyx_r = __pyx_v_rgb_;
  goto __pyx_L0;

 562: