.. _stdlib_raster: ============================================================ Raster operations (pixel copy, convert, SIMD gather/scatter) ============================================================ .. das:module:: raster SIMD-accelerated pixel operations — gather, scatter, copy, channel conversion, and BPC conversion. ++++++ Gather ++++++ * :ref:`gather (from: int const?; index4: uint4) : int4 ` * :ref:`gather (from: float const?; index4: uint4) : float4 ` * :ref:`gather (from: float const?; index4: int4) : float4 ` * :ref:`gather (from: uint const?; index4: uint4) : uint4 ` * :ref:`gather (from: uint const?; index4: int4) : uint4 ` * :ref:`gather (from: int const?; index4: int4) : int4 ` gather ^^^^^^ .. _function-raster_gather_int_const_q__uint4: .. das:function:: gather(from: int const?; index4: uint4) : int4 .. warning:: This is unsafe operation. Gather pixels from source using an index array into destination. :Arguments: * **from** : int? implicit * **index4** : uint4 .. _function-raster_gather_float_const_q__uint4: .. das:function:: gather(from: float const?; index4: uint4) : float4 .. _function-raster_gather_float_const_q__int4: .. das:function:: gather(from: float const?; index4: int4) : float4 .. _function-raster_gather_uint_const_q__uint4: .. das:function:: gather(from: uint const?; index4: uint4) : uint4 .. _function-raster_gather_uint_const_q__int4: .. das:function:: gather(from: uint const?; index4: int4) : uint4 .. _function-raster_gather_int_const_q__int4: .. das:function:: gather(from: int const?; index4: int4) : int4 +++++++ Scatter +++++++ * :ref:`scatter (to: int?; index4: uint4; from: int4) ` * :ref:`scatter (to: float?; index4: uint4; from: float4) ` * :ref:`scatter (to: float?; index4: int4; from: float4) ` * :ref:`scatter (to: uint?; index4: uint4; from: uint4) ` * :ref:`scatter (to: uint?; index4: int4; from: uint4) ` * :ref:`scatter (to: int?; index4: int4; from: int4) ` scatter ^^^^^^^ .. _function-raster_scatter_int_q__uint4_int4: .. das:function:: scatter(to: int?; index4: uint4; from: int4) .. warning:: This is unsafe operation. Scatter pixels from source to destination using an index array. :Arguments: * **to** : int? implicit * **index4** : uint4 * **from** : int4 .. _function-raster_scatter_float_q__uint4_float4: .. das:function:: scatter(to: float?; index4: uint4; from: float4) .. _function-raster_scatter_float_q__int4_float4: .. das:function:: scatter(to: float?; index4: int4; from: float4) .. _function-raster_scatter_uint_q__uint4_uint4: .. das:function:: scatter(to: uint?; index4: uint4; from: uint4) .. _function-raster_scatter_uint_q__int4_uint4: .. das:function:: scatter(to: uint?; index4: int4; from: uint4) .. _function-raster_scatter_int_q__int4_int4: .. das:function:: scatter(to: int?; index4: int4; from: int4) +++++++++++++++++ Scatter with mask +++++++++++++++++ * :ref:`scatter_neq_mask (to: int?; index4: uint4; from: int4; mask: int4) ` * :ref:`scatter_neq_mask (to: float?; index4: uint4; from: float4; mask: float4) ` * :ref:`scatter_neq_mask (to: float?; index4: int4; from: float4; mask: float4) ` * :ref:`scatter_neq_mask (to: uint?; index4: uint4; from: uint4; mask: uint4) ` * :ref:`scatter_neq_mask (to: uint?; index4: int4; from: uint4; mask: uint4) ` * :ref:`scatter_neq_mask (to: int?; index4: int4; from: int4; mask: int4) ` scatter_neq_mask ^^^^^^^^^^^^^^^^ .. _function-raster_scatter_neq_mask_int_q__uint4_int4_int4: .. das:function:: scatter_neq_mask(to: int?; index4: uint4; from: int4; mask: int4) .. warning:: This is unsafe operation. Scatter pixels to destination where mask value differs from pixel value. :Arguments: * **to** : int? implicit * **index4** : uint4 * **from** : int4 * **mask** : int4 .. _function-raster_scatter_neq_mask_float_q__uint4_float4_float4: .. das:function:: scatter_neq_mask(to: float?; index4: uint4; from: float4; mask: float4) .. _function-raster_scatter_neq_mask_float_q__int4_float4_float4: .. das:function:: scatter_neq_mask(to: float?; index4: int4; from: float4; mask: float4) .. _function-raster_scatter_neq_mask_uint_q__uint4_uint4_uint4: .. das:function:: scatter_neq_mask(to: uint?; index4: uint4; from: uint4; mask: uint4) .. _function-raster_scatter_neq_mask_uint_q__int4_uint4_uint4: .. das:function:: scatter_neq_mask(to: uint?; index4: int4; from: uint4; mask: uint4) .. _function-raster_scatter_neq_mask_int_q__int4_int4_int4: .. das:function:: scatter_neq_mask(to: int?; index4: int4; from: int4; mask: int4) +++++++++++++++ Store with mask +++++++++++++++ * :ref:`store_neq_mask (to: int4?; from: int4; mask: int4) ` * :ref:`store_neq_mask (to: float4?; from: float4; mask: float4) ` * :ref:`store_neq_mask (to: uint4?; from: uint4; mask: uint4) ` store_neq_mask ^^^^^^^^^^^^^^ .. _function-raster_store_neq_mask_int4_q__int4_int4: .. das:function:: store_neq_mask(to: int4?; from: int4; mask: int4) Store a single pixel at indexed positions where mask differs. :Arguments: * **to** : int4? implicit * **from** : int4 * **mask** : int4 .. _function-raster_store_neq_mask_float4_q__float4_float4: .. das:function:: store_neq_mask(to: float4?; from: float4; mask: float4) .. _function-raster_store_neq_mask_uint4_q__uint4_uint4: .. das:function:: store_neq_mask(to: uint4?; from: uint4; mask: uint4) ++++++++++++++ Gather-scatter ++++++++++++++ * :ref:`gather_scatter (to: int?; to_index4: uint4; from: int const?; from_index4: uint4) ` * :ref:`gather_scatter (to: float?; to_index4: uint4; from: float const?; from_index4: uint4) ` * :ref:`gather_scatter (to: float?; to_index4: int4; from: float const?; from_index4: int4) ` * :ref:`gather_scatter (to: uint?; to_index4: uint4; from: uint const?; from_index4: uint4) ` * :ref:`gather_scatter (to: uint?; to_index4: int4; from: uint const?; from_index4: int4) ` * :ref:`gather_scatter (to: int?; to_index4: int4; from: int const?; from_index4: int4) ` gather_scatter ^^^^^^^^^^^^^^ .. _function-raster_gather_scatter_int_q__uint4_int_const_q__uint4: .. das:function:: gather_scatter(to: int?; to_index4: uint4; from: int const?; from_index4: uint4) .. warning:: This is unsafe operation. Gather pixels from source and scatter to destination using index arrays. :Arguments: * **to** : int? implicit * **to_index4** : uint4 * **from** : int? implicit * **from_index4** : uint4 .. _function-raster_gather_scatter_float_q__uint4_float_const_q__uint4: .. das:function:: gather_scatter(to: float?; to_index4: uint4; from: float const?; from_index4: uint4) .. _function-raster_gather_scatter_float_q__int4_float_const_q__int4: .. das:function:: gather_scatter(to: float?; to_index4: int4; from: float const?; from_index4: int4) .. _function-raster_gather_scatter_uint_q__uint4_uint_const_q__uint4: .. das:function:: gather_scatter(to: uint?; to_index4: uint4; from: uint const?; from_index4: uint4) .. _function-raster_gather_scatter_uint_q__int4_uint_const_q__int4: .. das:function:: gather_scatter(to: uint?; to_index4: int4; from: uint const?; from_index4: int4) .. _function-raster_gather_scatter_int_q__int4_int_const_q__int4: .. das:function:: gather_scatter(to: int?; to_index4: int4; from: int const?; from_index4: int4) ++++++++++++++++++++++++ Gather-scatter with mask ++++++++++++++++++++++++ * :ref:`gather_scatter_neq_mask (to: int?; to_index4: uint4; from: int const?; from_index4: uint4; mask: int4) ` * :ref:`gather_scatter_neq_mask (to: float?; to_index4: uint4; from: float const?; from_index4: uint4; mask: float4) ` * :ref:`gather_scatter_neq_mask (to: float?; to_index4: int4; from: float const?; from_index4: int4; mask: float4) ` * :ref:`gather_scatter_neq_mask (to: uint?; to_index4: uint4; from: uint const?; from_index4: uint4; mask: uint4) ` * :ref:`gather_scatter_neq_mask (to: uint?; to_index4: int4; from: uint const?; from_index4: int4; mask: uint4) ` * :ref:`gather_scatter_neq_mask (to: int?; to_index4: int4; from: int const?; from_index4: int4; mask: int4) ` gather_scatter_neq_mask ^^^^^^^^^^^^^^^^^^^^^^^ .. _function-raster_gather_scatter_neq_mask_int_q__uint4_int_const_q__uint4_int4: .. das:function:: gather_scatter_neq_mask(to: int?; to_index4: uint4; from: int const?; from_index4: uint4; mask: int4) .. warning:: This is unsafe operation. Gather-scatter pixels where mask value differs from gathered pixel. :Arguments: * **to** : int? implicit * **to_index4** : uint4 * **from** : int? implicit * **from_index4** : uint4 * **mask** : int4 .. _function-raster_gather_scatter_neq_mask_float_q__uint4_float_const_q__uint4_float4: .. das:function:: gather_scatter_neq_mask(to: float?; to_index4: uint4; from: float const?; from_index4: uint4; mask: float4) .. _function-raster_gather_scatter_neq_mask_float_q__int4_float_const_q__int4_float4: .. das:function:: gather_scatter_neq_mask(to: float?; to_index4: int4; from: float const?; from_index4: int4; mask: float4) .. _function-raster_gather_scatter_neq_mask_uint_q__uint4_uint_const_q__uint4_uint4: .. das:function:: gather_scatter_neq_mask(to: uint?; to_index4: uint4; from: uint const?; from_index4: uint4; mask: uint4) .. _function-raster_gather_scatter_neq_mask_uint_q__int4_uint_const_q__int4_uint4: .. das:function:: gather_scatter_neq_mask(to: uint?; to_index4: int4; from: uint const?; from_index4: int4; mask: uint4) .. _function-raster_gather_scatter_neq_mask_int_q__int4_int_const_q__int4_int4: .. das:function:: gather_scatter_neq_mask(to: int?; to_index4: int4; from: int const?; from_index4: int4; mask: int4) ++++++++++++++++++++++ Gather-store with mask ++++++++++++++++++++++ * :ref:`gather_store_neq_mask (to: int4?; from: int const?; from_index4: uint4; mask: int4) ` * :ref:`gather_store_neq_mask (to: float4?; from: float const?; from_index4: uint4; mask: float4) ` * :ref:`gather_store_neq_mask (to: float4?; from: float const?; from_index4: int4; mask: float4) ` * :ref:`gather_store_neq_mask (to: uint4?; from: uint const?; from_index4: uint4; mask: uint4) ` * :ref:`gather_store_neq_mask (to: uint4?; from: uint const?; from_index4: int4; mask: uint4) ` * :ref:`gather_store_neq_mask (to: int4?; from: int const?; from_index4: int4; mask: int4) ` gather_store_neq_mask ^^^^^^^^^^^^^^^^^^^^^ .. _function-raster_gather_store_neq_mask_int4_q__int_const_q__uint4_int4: .. das:function:: gather_store_neq_mask(to: int4?; from: int const?; from_index4: uint4; mask: int4) .. warning:: This is unsafe operation. Gather from source and store where mask differs, using a single value. :Arguments: * **to** : int4? implicit * **from** : int? implicit * **from_index4** : uint4 * **mask** : int4 .. _function-raster_gather_store_neq_mask_float4_q__float_const_q__uint4_float4: .. das:function:: gather_store_neq_mask(to: float4?; from: float const?; from_index4: uint4; mask: float4) .. _function-raster_gather_store_neq_mask_float4_q__float_const_q__int4_float4: .. das:function:: gather_store_neq_mask(to: float4?; from: float const?; from_index4: int4; mask: float4) .. _function-raster_gather_store_neq_mask_uint4_q__uint_const_q__uint4_uint4: .. das:function:: gather_store_neq_mask(to: uint4?; from: uint const?; from_index4: uint4; mask: uint4) .. _function-raster_gather_store_neq_mask_uint4_q__uint_const_q__int4_uint4: .. das:function:: gather_store_neq_mask(to: uint4?; from: uint const?; from_index4: int4; mask: uint4) .. _function-raster_gather_store_neq_mask_int4_q__int_const_q__int4_int4: .. das:function:: gather_store_neq_mask(to: int4?; from: int const?; from_index4: int4; mask: int4) ++++++++++++++++++++++++ Gather-store with stride ++++++++++++++++++++++++ * :ref:`gather_store_stride (to: int?; stride: int; from: int const?; from_index4: uint4) ` * :ref:`gather_store_stride (to: float?; stride: int; from: float const?; from_index4: uint4) ` * :ref:`gather_store_stride (to: float?; stride: int; from: float const?; from_index4: int4) ` * :ref:`gather_store_stride (to: uint?; stride: int; from: uint const?; from_index4: uint4) ` * :ref:`gather_store_stride (to: uint?; stride: int; from: uint const?; from_index4: int4) ` * :ref:`gather_store_stride (to: int?; stride: int; from: int const?; from_index4: int4) ` gather_store_stride ^^^^^^^^^^^^^^^^^^^ .. _function-raster_gather_store_stride_int_q__int_int_const_q__uint4: .. das:function:: gather_store_stride(to: int?; stride: int; from: int const?; from_index4: uint4) .. warning:: This is unsafe operation. Gather pixels with a stride offset between source elements. :Arguments: * **to** : int? implicit * **stride** : int * **from** : int? implicit * **from_index4** : uint4 .. _function-raster_gather_store_stride_float_q__int_float_const_q__uint4: .. das:function:: gather_store_stride(to: float?; stride: int; from: float const?; from_index4: uint4) .. _function-raster_gather_store_stride_float_q__int_float_const_q__int4: .. das:function:: gather_store_stride(to: float?; stride: int; from: float const?; from_index4: int4) .. _function-raster_gather_store_stride_uint_q__int_uint_const_q__uint4: .. das:function:: gather_store_stride(to: uint?; stride: int; from: uint const?; from_index4: uint4) .. _function-raster_gather_store_stride_uint_q__int_uint_const_q__int4: .. das:function:: gather_store_stride(to: uint?; stride: int; from: uint const?; from_index4: int4) .. _function-raster_gather_store_stride_int_q__int_int_const_q__int4: .. das:function:: gather_store_stride(to: int?; stride: int; from: int const?; from_index4: int4) +++++++++++++++++ Byte gather-store +++++++++++++++++ * :ref:`u8x4_gather_store (to: uint8?; from: uint8 const?; from_index4: int4) ` * :ref:`u8x4_gather_store (to: uint8?; from: uint8 const?; from_index4: uint4) ` u8x4_gather_store ^^^^^^^^^^^^^^^^^ .. _function-raster_u8x4_gather_store_uint8_q__uint8_const_q__int4: .. das:function:: u8x4_gather_store(to: uint8?; from: uint8 const?; from_index4: int4) .. warning:: This is unsafe operation. Gather 4-byte pixels and store to sequential destination. :Arguments: * **to** : uint8? implicit * **from** : uint8? implicit * **from_index4** : int4 .. _function-raster_u8x4_gather_store_uint8_q__uint8_const_q__uint4: .. das:function:: u8x4_gather_store(to: uint8?; from: uint8 const?; from_index4: uint4) +++++++++++++ Copy reversed +++++++++++++ * :ref:`rast_copy_reversed_1 (dst: uint8?; src: uint8 const?; count: int) ` * :ref:`rast_copy_reversed_12 (dst: void?; src: void?; count: int) ` * :ref:`rast_copy_reversed_16 (dst: void?; src: void?; count: int) ` * :ref:`rast_copy_reversed_2 (dst: uint16?; src: uint16 const?; count: int) ` * :ref:`rast_copy_reversed_3 (dst: void?; src: void?; count: int) ` * :ref:`rast_copy_reversed_4 (dst: uint?; src: uint const?; count: int) ` * :ref:`rast_copy_reversed_6 (dst: void?; src: void?; count: int) ` * :ref:`rast_copy_reversed_8 (dst: uint64?; src: uint64 const?; count: int) ` .. _function-raster_rast_copy_reversed_1_uint8_q__uint8_const_q__int: .. das:function:: rast_copy_reversed_1(dst: uint8?; src: uint8 const?; count: int) .. warning:: This is unsafe operation. Copy pixel rows in reverse order (vertical flip) for 1-byte pixels. :Arguments: * **dst** : uint8? implicit * **src** : uint8? implicit * **count** : int .. _function-raster_rast_copy_reversed_12_void_q__void_q__int: .. das:function:: rast_copy_reversed_12(dst: void?; src: void?; count: int) .. warning:: This is unsafe operation. Copy pixel rows in reverse order (vertical flip) for 12-byte pixels. :Arguments: * **dst** : void? implicit * **src** : void? implicit * **count** : int .. _function-raster_rast_copy_reversed_16_void_q__void_q__int: .. das:function:: rast_copy_reversed_16(dst: void?; src: void?; count: int) .. warning:: This is unsafe operation. Copy pixel rows in reverse order (vertical flip) for 16-byte pixels. :Arguments: * **dst** : void? implicit * **src** : void? implicit * **count** : int .. _function-raster_rast_copy_reversed_2_uint16_q__uint16_const_q__int: .. das:function:: rast_copy_reversed_2(dst: uint16?; src: uint16 const?; count: int) .. warning:: This is unsafe operation. Copy pixel rows in reverse order (vertical flip) for 2-byte pixels. :Arguments: * **dst** : uint16? implicit * **src** : uint16? implicit * **count** : int .. _function-raster_rast_copy_reversed_3_void_q__void_q__int: .. das:function:: rast_copy_reversed_3(dst: void?; src: void?; count: int) .. warning:: This is unsafe operation. Copy pixel rows in reverse order (vertical flip) for 3-byte pixels. :Arguments: * **dst** : void? implicit * **src** : void? implicit * **count** : int .. _function-raster_rast_copy_reversed_4_uint_q__uint_const_q__int: .. das:function:: rast_copy_reversed_4(dst: uint?; src: uint const?; count: int) .. warning:: This is unsafe operation. Copy pixel rows in reverse order (vertical flip) for 4-byte pixels. :Arguments: * **dst** : uint? implicit * **src** : uint? implicit * **count** : int .. _function-raster_rast_copy_reversed_6_void_q__void_q__int: .. das:function:: rast_copy_reversed_6(dst: void?; src: void?; count: int) .. warning:: This is unsafe operation. Copy pixel rows in reverse order (vertical flip) for 6-byte pixels. :Arguments: * **dst** : void? implicit * **src** : void? implicit * **count** : int .. _function-raster_rast_copy_reversed_8_uint64_q__uint64_const_q__int: .. das:function:: rast_copy_reversed_8(dst: uint64?; src: uint64 const?; count: int) .. warning:: This is unsafe operation. Copy pixel rows in reverse order (vertical flip) for 8-byte pixels. :Arguments: * **dst** : uint64? implicit * **src** : uint64? implicit * **count** : int +++++++++ Copy rect +++++++++ * :ref:`rast_copy_rect_1 (dst: uint8?; src: uint8 const?; dst_w: int; src_w: int; sx0: int; sy0: int; dx0: int; dy0: int; w: int; h: int) ` * :ref:`rast_copy_rect_12 (dst: void?; src: void?; dst_w: int; src_w: int; sx0: int; sy0: int; dx0: int; dy0: int; w: int; h: int) ` * :ref:`rast_copy_rect_16 (dst: void?; src: void?; dst_w: int; src_w: int; sx0: int; sy0: int; dx0: int; dy0: int; w: int; h: int) ` * :ref:`rast_copy_rect_2 (dst: uint16?; src: uint16 const?; dst_w: int; src_w: int; sx0: int; sy0: int; dx0: int; dy0: int; w: int; h: int) ` * :ref:`rast_copy_rect_3 (dst: void?; src: void?; dst_w: int; src_w: int; sx0: int; sy0: int; dx0: int; dy0: int; w: int; h: int) ` * :ref:`rast_copy_rect_4 (dst: uint?; src: uint const?; dst_w: int; src_w: int; sx0: int; sy0: int; dx0: int; dy0: int; w: int; h: int) ` * :ref:`rast_copy_rect_6 (dst: void?; src: void?; dst_w: int; src_w: int; sx0: int; sy0: int; dx0: int; dy0: int; w: int; h: int) ` * :ref:`rast_copy_rect_8 (dst: uint64?; src: uint64 const?; dst_w: int; src_w: int; sx0: int; sy0: int; dx0: int; dy0: int; w: int; h: int) ` .. _function-raster_rast_copy_rect_1_uint8_q__uint8_const_q__int_int_int_int_int_int_int_int: .. das:function:: rast_copy_rect_1(dst: uint8?; src: uint8 const?; dst_w: int; src_w: int; sx0: int; sy0: int; dx0: int; dy0: int; w: int; h: int) .. warning:: This is unsafe operation. Copy a rectangular region between pixel buffers for 1-byte pixels. :Arguments: * **dst** : uint8? implicit * **src** : uint8? implicit * **dst_w** : int * **src_w** : int * **sx0** : int * **sy0** : int * **dx0** : int * **dy0** : int * **w** : int * **h** : int .. _function-raster_rast_copy_rect_12_void_q__void_q__int_int_int_int_int_int_int_int: .. das:function:: rast_copy_rect_12(dst: void?; src: void?; dst_w: int; src_w: int; sx0: int; sy0: int; dx0: int; dy0: int; w: int; h: int) .. warning:: This is unsafe operation. Copy a rectangular region between pixel buffers for 12-byte pixels. :Arguments: * **dst** : void? implicit * **src** : void? implicit * **dst_w** : int * **src_w** : int * **sx0** : int * **sy0** : int * **dx0** : int * **dy0** : int * **w** : int * **h** : int .. _function-raster_rast_copy_rect_16_void_q__void_q__int_int_int_int_int_int_int_int: .. das:function:: rast_copy_rect_16(dst: void?; src: void?; dst_w: int; src_w: int; sx0: int; sy0: int; dx0: int; dy0: int; w: int; h: int) .. warning:: This is unsafe operation. Copy a rectangular region between pixel buffers for 16-byte pixels. :Arguments: * **dst** : void? implicit * **src** : void? implicit * **dst_w** : int * **src_w** : int * **sx0** : int * **sy0** : int * **dx0** : int * **dy0** : int * **w** : int * **h** : int .. _function-raster_rast_copy_rect_2_uint16_q__uint16_const_q__int_int_int_int_int_int_int_int: .. das:function:: rast_copy_rect_2(dst: uint16?; src: uint16 const?; dst_w: int; src_w: int; sx0: int; sy0: int; dx0: int; dy0: int; w: int; h: int) .. warning:: This is unsafe operation. Copy a rectangular region between pixel buffers for 2-byte pixels. :Arguments: * **dst** : uint16? implicit * **src** : uint16? implicit * **dst_w** : int * **src_w** : int * **sx0** : int * **sy0** : int * **dx0** : int * **dy0** : int * **w** : int * **h** : int .. _function-raster_rast_copy_rect_3_void_q__void_q__int_int_int_int_int_int_int_int: .. das:function:: rast_copy_rect_3(dst: void?; src: void?; dst_w: int; src_w: int; sx0: int; sy0: int; dx0: int; dy0: int; w: int; h: int) .. warning:: This is unsafe operation. Copy a rectangular region between pixel buffers for 3-byte pixels. :Arguments: * **dst** : void? implicit * **src** : void? implicit * **dst_w** : int * **src_w** : int * **sx0** : int * **sy0** : int * **dx0** : int * **dy0** : int * **w** : int * **h** : int .. _function-raster_rast_copy_rect_4_uint_q__uint_const_q__int_int_int_int_int_int_int_int: .. das:function:: rast_copy_rect_4(dst: uint?; src: uint const?; dst_w: int; src_w: int; sx0: int; sy0: int; dx0: int; dy0: int; w: int; h: int) .. warning:: This is unsafe operation. Copy a rectangular region between pixel buffers for 4-byte pixels. :Arguments: * **dst** : uint? implicit * **src** : uint? implicit * **dst_w** : int * **src_w** : int * **sx0** : int * **sy0** : int * **dx0** : int * **dy0** : int * **w** : int * **h** : int .. _function-raster_rast_copy_rect_6_void_q__void_q__int_int_int_int_int_int_int_int: .. das:function:: rast_copy_rect_6(dst: void?; src: void?; dst_w: int; src_w: int; sx0: int; sy0: int; dx0: int; dy0: int; w: int; h: int) .. warning:: This is unsafe operation. Copy a rectangular region between pixel buffers for 6-byte pixels. :Arguments: * **dst** : void? implicit * **src** : void? implicit * **dst_w** : int * **src_w** : int * **sx0** : int * **sy0** : int * **dx0** : int * **dy0** : int * **w** : int * **h** : int .. _function-raster_rast_copy_rect_8_uint64_q__uint64_const_q__int_int_int_int_int_int_int_int: .. das:function:: rast_copy_rect_8(dst: uint64?; src: uint64 const?; dst_w: int; src_w: int; sx0: int; sy0: int; dx0: int; dy0: int; w: int; h: int) .. warning:: This is unsafe operation. Copy a rectangular region between pixel buffers for 8-byte pixels. :Arguments: * **dst** : uint64? implicit * **src** : uint64? implicit * **dst_w** : int * **src_w** : int * **sx0** : int * **sy0** : int * **dx0** : int * **dy0** : int * **w** : int * **h** : int ++++++++++++++++++ Channel conversion ++++++++++++++++++ * :ref:`rast_convert_channels_f32 (dst: float?; src: float const?; num_pixels: int; src_ch: int; dst_ch: int) ` * :ref:`rast_convert_channels_u16 (dst: uint16?; src: uint16 const?; num_pixels: int; src_ch: int; dst_ch: int) ` * :ref:`rast_convert_channels_u8 (dst: uint8?; src: uint8 const?; num_pixels: int; src_ch: int; dst_ch: int) ` .. _function-raster_rast_convert_channels_f32_float_q__float_const_q__int_int_int: .. das:function:: rast_convert_channels_f32(dst: float?; src: float const?; num_pixels: int; src_ch: int; dst_ch: int) .. warning:: This is unsafe operation. Convert between channel counts for float pixel data. :Arguments: * **dst** : float? implicit * **src** : float? implicit * **num_pixels** : int * **src_ch** : int * **dst_ch** : int .. _function-raster_rast_convert_channels_u16_uint16_q__uint16_const_q__int_int_int: .. das:function:: rast_convert_channels_u16(dst: uint16?; src: uint16 const?; num_pixels: int; src_ch: int; dst_ch: int) .. warning:: This is unsafe operation. Convert between channel counts for uint16 pixel data. :Arguments: * **dst** : uint16? implicit * **src** : uint16? implicit * **num_pixels** : int * **src_ch** : int * **dst_ch** : int .. _function-raster_rast_convert_channels_u8_uint8_q__uint8_const_q__int_int_int: .. das:function:: rast_convert_channels_u8(dst: uint8?; src: uint8 const?; num_pixels: int; src_ch: int; dst_ch: int) .. warning:: This is unsafe operation. Convert between channel counts for uint8 pixel data. :Arguments: * **dst** : uint8? implicit * **src** : uint8? implicit * **num_pixels** : int * **src_ch** : int * **dst_ch** : int ++++++++++++++ BPC conversion ++++++++++++++ * :ref:`rast_convert_f32_to_u16 (dst: uint16?; src: float const?; count: int) ` * :ref:`rast_convert_f32_to_u8 (dst: uint8?; src: float const?; count: int) ` * :ref:`rast_convert_u16_to_f32 (dst: float?; src: uint16 const?; count: int) ` * :ref:`rast_convert_u16_to_u8 (dst: uint8?; src: uint16 const?; count: int) ` * :ref:`rast_convert_u8_to_f32 (dst: float?; src: uint8 const?; count: int) ` * :ref:`rast_convert_u8_to_u16 (dst: uint16?; src: uint8 const?; count: int) ` .. _function-raster_rast_convert_f32_to_u16_uint16_q__float_const_q__int: .. das:function:: rast_convert_f32_to_u16(dst: uint16?; src: float const?; count: int) .. warning:: This is unsafe operation. Convert pixel data from float (0.0-1.0) to uint16 (0-65535) with clamping. :Arguments: * **dst** : uint16? implicit * **src** : float? implicit * **count** : int .. _function-raster_rast_convert_f32_to_u8_uint8_q__float_const_q__int: .. das:function:: rast_convert_f32_to_u8(dst: uint8?; src: float const?; count: int) .. warning:: This is unsafe operation. Convert pixel data from float (0.0-1.0) to uint8 (0-255) with clamping. :Arguments: * **dst** : uint8? implicit * **src** : float? implicit * **count** : int .. _function-raster_rast_convert_u16_to_f32_float_q__uint16_const_q__int: .. das:function:: rast_convert_u16_to_f32(dst: float?; src: uint16 const?; count: int) .. warning:: This is unsafe operation. Convert pixel data from uint16 (0-65535) to float (0.0-1.0). :Arguments: * **dst** : float? implicit * **src** : uint16? implicit * **count** : int .. _function-raster_rast_convert_u16_to_u8_uint8_q__uint16_const_q__int: .. das:function:: rast_convert_u16_to_u8(dst: uint8?; src: uint16 const?; count: int) .. warning:: This is unsafe operation. Convert pixel data from uint16 (0-65535) to uint8 (0-255). :Arguments: * **dst** : uint8? implicit * **src** : uint16? implicit * **count** : int .. _function-raster_rast_convert_u8_to_f32_float_q__uint8_const_q__int: .. das:function:: rast_convert_u8_to_f32(dst: float?; src: uint8 const?; count: int) .. warning:: This is unsafe operation. Convert pixel data from uint8 (0-255) to float (0.0-1.0). :Arguments: * **dst** : float? implicit * **src** : uint8? implicit * **count** : int .. _function-raster_rast_convert_u8_to_u16_uint16_q__uint8_const_q__int: .. das:function:: rast_convert_u8_to_u16(dst: uint16?; src: uint8 const?; count: int) .. warning:: This is unsafe operation. Convert pixel data from uint8 (0-255) to uint16 (0-65535). :Arguments: * **dst** : uint16? implicit * **src** : uint8? implicit * **count** : int +++++++++++ Span raster +++++++++++ * :ref:`rast_hspan_masked_solid_u8 (solid: uint8; span: array\; spanOffset: int; tspan: array\; tspanOffset: int; uvY: float; dUVY: float; count: int) ` * :ref:`rast_hspan_masked_u8 (span: array\; spanOffset: int; tspan: array\; tspanOffset: int; uvY: float; dUVY: float; count: int) ` * :ref:`rast_hspan_u8 (span: array\; spanOffset: int; tspan: array\; tspanOffset: int; uvY: float; dUVY: float; count: int) ` .. _function-raster_rast_hspan_masked_solid_u8_uint8_array_ls_uint8_gr__int_array_ls_uint8_gr__int_float_float_int: .. das:function:: rast_hspan_masked_solid_u8(solid: uint8; span: array; spanOffset: int; tspan: array; tspanOffset: int; uvY: float; dUVY: float; count: int) Rasterize a horizontal span of solid color with per-pixel mask. :Arguments: * **solid** : uint8 * **span** : array implicit * **spanOffset** : int * **tspan** : array implicit * **tspanOffset** : int * **uvY** : float * **dUVY** : float * **count** : int .. _function-raster_rast_hspan_masked_u8_array_ls_uint8_gr__int_array_ls_uint8_gr__int_float_float_int: .. das:function:: rast_hspan_masked_u8(span: array; spanOffset: int; tspan: array; tspanOffset: int; uvY: float; dUVY: float; count: int) Rasterize a horizontal span with per-pixel mask. :Arguments: * **span** : array implicit * **spanOffset** : int * **tspan** : array implicit * **tspanOffset** : int * **uvY** : float * **dUVY** : float * **count** : int .. _function-raster_rast_hspan_u8_array_ls_uint8_gr__int_array_ls_uint8_gr__int_float_float_int: .. das:function:: rast_hspan_u8(span: array; spanOffset: int; tspan: array; tspanOffset: int; uvY: float; dUVY: float; count: int) Rasterize a horizontal span of uint8 pixels. :Arguments: * **span** : array implicit * **spanOffset** : int * **tspan** : array implicit * **tspanOffset** : int * **uvY** : float * **dUVY** : float * **count** : int +++++++++ Fill rect +++++++++ * :ref:`rast_fill_rect_1 (dst: uint8?; dst_w: int; dx: int; dy: int; w: int; h: int; val: uint8) ` * :ref:`rast_fill_rect_4 (dst: uint?; dst_w: int; dx: int; dy: int; w: int; h: int; val: uint) ` .. _function-raster_rast_fill_rect_1_uint8_q__int_int_int_int_int_uint8: .. das:function:: rast_fill_rect_1(dst: uint8?; dst_w: int; dx: int; dy: int; w: int; h: int; val: uint8) .. warning:: This is unsafe operation. Fill a rectangle in a 1-channel uint8 image with a solid byte value. Operates on raw pixel data with row width, position, and dimensions. :Arguments: * **dst** : uint8? implicit * **dst_w** : int * **dx** : int * **dy** : int * **w** : int * **h** : int * **val** : uint8 .. _function-raster_rast_fill_rect_4_uint_q__int_int_int_int_int_uint: .. das:function:: rast_fill_rect_4(dst: uint?; dst_w: int; dx: int; dy: int; w: int; h: int; val: uint) .. warning:: This is unsafe operation. Fill a rectangle in a 4-channel RGBA image with a packed uint32 color value. Operates on raw pixel data with row width, position, and dimensions. :Arguments: * **dst** : uint? implicit * **dst_w** : int * **dx** : int * **dy** : int * **w** : int * **h** : int * **val** : uint ++++++++++ Alpha blit ++++++++++ * :ref:`rast_blit_alpha (dst: uint8?; src: uint8 const?; dst_w: int; src_w: int; sx0: int; sy0: int; dx0: int; dy0: int; w: int; h: int; r: uint8; g: uint8; b: uint8) ` .. _function-raster_rast_blit_alpha_uint8_q__uint8_const_q__int_int_int_int_int_int_int_int_uint8_uint8_uint8: .. das:function:: rast_blit_alpha(dst: uint8?; src: uint8 const?; dst_w: int; src_w: int; sx0: int; sy0: int; dx0: int; dy0: int; w: int; h: int; r: uint8; g: uint8; b: uint8) .. warning:: This is unsafe operation. Alpha-blend a 1-channel source onto a 4-channel RGBA destination using SIMD. Each source pixel is the alpha value for blending the given (r,g,b) color. Uses exact integer division by 255. :Arguments: * **dst** : uint8? implicit * **src** : uint8? implicit * **dst_w** : int * **src_w** : int * **sx0** : int * **sy0** : int * **dx0** : int * **dy0** : int * **w** : int * **h** : int * **r** : uint8 * **g** : uint8 * **b** : uint8