#pragma once
#include <cstdint>
#include <Eigen/Eigen>
#include <algorithm>
#include <stdexcept>
#include <cassert>
#include <vector>
#include <cstring>
#include <type_traits>
#include <cmath>
#include <limits>

/**
 * @brief 像素格式信息命名空间
 * 提供sg_pixel_format格式的辅助函数
 */
namespace pixel_format {

/**
 * @brief 获取像素格式的通道数
 *
 * @param format 像素格式
 * @return int 通道数(1=R, 2=RG, 3=RGB, 4=RGBA)
 */
inline int get_channel_count(sg_pixel_format format) {
    switch (format) {
        // 单通道格式 (R)
        case SG_PIXELFORMAT_R8:
        case SG_PIXELFORMAT_R8SN:
        case SG_PIXELFORMAT_R8UI:
        case SG_PIXELFORMAT_R8SI:
        case SG_PIXELFORMAT_R16:
        case SG_PIXELFORMAT_R16SN:
        case SG_PIXELFORMAT_R16UI:
        case SG_PIXELFORMAT_R16SI:
        case SG_PIXELFORMAT_R16F:
        case SG_PIXELFORMAT_R32UI:
        case SG_PIXELFORMAT_R32SI:
        case SG_PIXELFORMAT_R32F:
        case SG_PIXELFORMAT_BC4_R:
        case SG_PIXELFORMAT_BC4_RSN:
        case SG_PIXELFORMAT_EAC_R11:
        case SG_PIXELFORMAT_EAC_R11SN:
        case SG_PIXELFORMAT_DEPTH:
            return 1;

        // 双通道格式 (RG)
        case SG_PIXELFORMAT_RG8:
        case SG_PIXELFORMAT_RG8SN:
        case SG_PIXELFORMAT_RG8UI:
        case SG_PIXELFORMAT_RG8SI:
        case SG_PIXELFORMAT_RG16:
        case SG_PIXELFORMAT_RG16SN:
        case SG_PIXELFORMAT_RG16UI:
        case SG_PIXELFORMAT_RG16SI:
        case SG_PIXELFORMAT_RG16F:
        case SG_PIXELFORMAT_RG32UI:
        case SG_PIXELFORMAT_RG32SI:
        case SG_PIXELFORMAT_RG32F:
        case SG_PIXELFORMAT_BC5_RG:
        case SG_PIXELFORMAT_BC5_RGSN:
        case SG_PIXELFORMAT_EAC_RG11:
        case SG_PIXELFORMAT_EAC_RG11SN:
        case SG_PIXELFORMAT_DEPTH_STENCIL:
            return 2;

        // 三通道格式 (RGB)
        case SG_PIXELFORMAT_RGB9E5:
        case SG_PIXELFORMAT_RG11B10F:
        case SG_PIXELFORMAT_ETC2_RGB8:
        case SG_PIXELFORMAT_ETC2_SRGB8:
        case SG_PIXELFORMAT_BC6H_RGBF:
        case SG_PIXELFORMAT_BC6H_RGBUF:
            return 3;

        // 四通道格式 (RGBA/BGRA)
        case SG_PIXELFORMAT_RGBA8:
        case SG_PIXELFORMAT_SRGB8A8:
        case SG_PIXELFORMAT_RGBA8SN:
        case SG_PIXELFORMAT_RGBA8UI:
        case SG_PIXELFORMAT_RGBA8SI:
        case SG_PIXELFORMAT_BGRA8:
        case SG_PIXELFORMAT_RGB10A2:
        case SG_PIXELFORMAT_RGBA16:
        case SG_PIXELFORMAT_RGBA16SN:
        case SG_PIXELFORMAT_RGBA16UI:
        case SG_PIXELFORMAT_RGBA16SI:
        case SG_PIXELFORMAT_RGBA16F:
        case SG_PIXELFORMAT_RGBA32UI:
        case SG_PIXELFORMAT_RGBA32SI:
        case SG_PIXELFORMAT_RGBA32F:
        case SG_PIXELFORMAT_BC1_RGBA:
        case SG_PIXELFORMAT_BC2_RGBA:
        case SG_PIXELFORMAT_BC3_RGBA:
        case SG_PIXELFORMAT_BC3_SRGBA:
        case SG_PIXELFORMAT_BC7_RGBA:
        case SG_PIXELFORMAT_BC7_SRGBA:
        case SG_PIXELFORMAT_ETC2_RGB8A1:
        case SG_PIXELFORMAT_ETC2_RGBA8:
        case SG_PIXELFORMAT_ETC2_SRGB8A8:
        case SG_PIXELFORMAT_ASTC_4x4_RGBA:
        case SG_PIXELFORMAT_ASTC_4x4_SRGBA:
            return 4;

        default:
            return 0; // 未知/不支持的格式
    }
}

/**
 * @brief 获取像素格式的每像素字节数
 *
 * @param format 像素格式
 * @return int 每像素字节数，压缩格式返回0
 */
inline int get_bytes_per_pixel(sg_pixel_format format) {
    switch (format) {
        // 8位单通道格式
        case SG_PIXELFORMAT_R8:
        case SG_PIXELFORMAT_R8SN:
        case SG_PIXELFORMAT_R8UI:
        case SG_PIXELFORMAT_R8SI:
            return 1;

        // 16位单通道和8位双通道格式
        case SG_PIXELFORMAT_R16:
        case SG_PIXELFORMAT_R16SN:
        case SG_PIXELFORMAT_R16UI:
        case SG_PIXELFORMAT_R16SI:
        case SG_PIXELFORMAT_R16F:
        case SG_PIXELFORMAT_RG8:
        case SG_PIXELFORMAT_RG8SN:
        case SG_PIXELFORMAT_RG8UI:
        case SG_PIXELFORMAT_RG8SI:
            return 2;

        // 32位单通道、16位双通道和8位四通道格式
        case SG_PIXELFORMAT_R32UI:
        case SG_PIXELFORMAT_R32SI:
        case SG_PIXELFORMAT_R32F:
        case SG_PIXELFORMAT_RG16:
        case SG_PIXELFORMAT_RG16SN:
        case SG_PIXELFORMAT_RG16UI:
        case SG_PIXELFORMAT_RG16SI:
        case SG_PIXELFORMAT_RG16F:
        case SG_PIXELFORMAT_RGBA8:
        case SG_PIXELFORMAT_SRGB8A8:
        case SG_PIXELFORMAT_RGBA8SN:
        case SG_PIXELFORMAT_RGBA8UI:
        case SG_PIXELFORMAT_RGBA8SI:
        case SG_PIXELFORMAT_BGRA8:
        case SG_PIXELFORMAT_RGB10A2:
        case SG_PIXELFORMAT_RG11B10F:
        case SG_PIXELFORMAT_RGB9E5:
            return 4;

        // 64位双通道和32位四通道格式
        case SG_PIXELFORMAT_RG32UI:
        case SG_PIXELFORMAT_RG32SI:
        case SG_PIXELFORMAT_RG32F:
        case SG_PIXELFORMAT_RGBA16:
        case SG_PIXELFORMAT_RGBA16SN:
        case SG_PIXELFORMAT_RGBA16UI:
        case SG_PIXELFORMAT_RGBA16SI:
        case SG_PIXELFORMAT_RGBA16F:
            return 8;

        // 128位四通道格式
        case SG_PIXELFORMAT_RGBA32UI:
        case SG_PIXELFORMAT_RGBA32SI:
        case SG_PIXELFORMAT_RGBA32F:
            return 16;

        // 深度格式
        case SG_PIXELFORMAT_DEPTH:
            return 4; // 典型为32位浮点

        case SG_PIXELFORMAT_DEPTH_STENCIL:
            return 4; // 典型为24位深度+8位模板

        // 压缩格式没有固定的每像素字节数
        case SG_PIXELFORMAT_BC1_RGBA:
        case SG_PIXELFORMAT_BC2_RGBA:
        case SG_PIXELFORMAT_BC3_RGBA:
        case SG_PIXELFORMAT_BC3_SRGBA:
        case SG_PIXELFORMAT_BC4_R:
        case SG_PIXELFORMAT_BC4_RSN:
        case SG_PIXELFORMAT_BC5_RG:
        case SG_PIXELFORMAT_BC5_RGSN:
        case SG_PIXELFORMAT_BC6H_RGBF:
        case SG_PIXELFORMAT_BC6H_RGBUF:
        case SG_PIXELFORMAT_BC7_RGBA:
        case SG_PIXELFORMAT_BC7_SRGBA:
        case SG_PIXELFORMAT_ETC2_RGB8:
        case SG_PIXELFORMAT_ETC2_SRGB8:
        case SG_PIXELFORMAT_ETC2_RGB8A1:
        case SG_PIXELFORMAT_ETC2_RGBA8:
        case SG_PIXELFORMAT_ETC2_SRGB8A8:
        case SG_PIXELFORMAT_EAC_R11:
        case SG_PIXELFORMAT_EAC_R11SN:
        case SG_PIXELFORMAT_EAC_RG11:
        case SG_PIXELFORMAT_EAC_RG11SN:
        case SG_PIXELFORMAT_ASTC_4x4_RGBA:
        case SG_PIXELFORMAT_ASTC_4x4_SRGBA:
            return 0; // 压缩格式

        default:
            return 0; // 未知/不支持的格式
    }
}

/**
 * @brief 检查像素格式是否有符号类型
 *
 * @param format 像素格式
 * @return bool 如果是有符号类型(SN/SI)返回true
 */
inline bool is_signed(sg_pixel_format format) {
    switch (format) {
        case SG_PIXELFORMAT_R8SN:
        case SG_PIXELFORMAT_R8SI:
        case SG_PIXELFORMAT_R16SN:
        case SG_PIXELFORMAT_R16SI:
        case SG_PIXELFORMAT_RG8SN:
        case SG_PIXELFORMAT_RG8SI:
        case SG_PIXELFORMAT_R32SI:
        case SG_PIXELFORMAT_RG16SN:
        case SG_PIXELFORMAT_RG16SI:
        case SG_PIXELFORMAT_RGBA8SN:
        case SG_PIXELFORMAT_RGBA8SI:
        case SG_PIXELFORMAT_RG32SI:
        case SG_PIXELFORMAT_RGBA16SN:
        case SG_PIXELFORMAT_RGBA16SI:
        case SG_PIXELFORMAT_RGBA32SI:
        case SG_PIXELFORMAT_BC4_RSN:
        case SG_PIXELFORMAT_BC5_RGSN:
        case SG_PIXELFORMAT_EAC_R11SN:
        case SG_PIXELFORMAT_EAC_RG11SN:
            return true;

        default:
            return false;
    }
}

/**
 * @brief 检查像素格式是否为浮点类型
 *
 * @param format 像素格式
 * @return bool 如果是浮点类型(F)返回true
 */
inline bool is_float(sg_pixel_format format) {
    switch (format) {
        case SG_PIXELFORMAT_R16F:
        case SG_PIXELFORMAT_R32F:
        case SG_PIXELFORMAT_RG16F:
        case SG_PIXELFORMAT_RG32F:
        case SG_PIXELFORMAT_RGBA16F:
        case SG_PIXELFORMAT_RGBA32F:
        case SG_PIXELFORMAT_RG11B10F:
        case SG_PIXELFORMAT_RGB9E5:
        case SG_PIXELFORMAT_BC6H_RGBF:
        case SG_PIXELFORMAT_BC6H_RGBUF:
        case SG_PIXELFORMAT_DEPTH:
        case SG_PIXELFORMAT_DEPTH_STENCIL:
            return true;

        default:
            return false;
    }
}

/**
 * @brief 检查像素格式是否为整数类型
 *
 * @param format 像素格式
 * @return bool 如果是整数类型(UI/SI)返回true
 */
inline bool is_integer(sg_pixel_format format) {
    switch (format) {
        case SG_PIXELFORMAT_R8UI:
        case SG_PIXELFORMAT_R8SI:
        case SG_PIXELFORMAT_R16UI:
        case SG_PIXELFORMAT_R16SI:
        case SG_PIXELFORMAT_RG8UI:
        case SG_PIXELFORMAT_RG8SI:
        case SG_PIXELFORMAT_R32UI:
        case SG_PIXELFORMAT_R32SI:
        case SG_PIXELFORMAT_RG16UI:
        case SG_PIXELFORMAT_RG16SI:
        case SG_PIXELFORMAT_RGBA8UI:
        case SG_PIXELFORMAT_RGBA8SI:
        case SG_PIXELFORMAT_RG32UI:
        case SG_PIXELFORMAT_RG32SI:
        case SG_PIXELFORMAT_RGBA16UI:
        case SG_PIXELFORMAT_RGBA16SI:
        case SG_PIXELFORMAT_RGBA32UI:
        case SG_PIXELFORMAT_RGBA32SI:
            return true;

        default:
            return false;
    }
}

/**
 * @brief 检查像素格式是否为归一化类型
 *
 * @param format 像素格式
 * @return bool 如果是归一化类型(常规/SN)返回true
 */
inline bool is_normalized(sg_pixel_format format) {
    // 不是浮点也不是整数的常规格式通常是归一化的
    return !is_float(format) && !is_integer(format) &&
           format != SG_PIXELFORMAT_NONE &&
           format != _SG_PIXELFORMAT_DEFAULT;
}

/**
 * @brief 检查像素格式是否为sRGB格式
 *
 * @param format 像素格式
 * @return bool 如果是sRGB格式返回true
 */
inline bool is_srgb(sg_pixel_format format) {
    switch (format) {
        case SG_PIXELFORMAT_SRGB8A8:
        case SG_PIXELFORMAT_BC3_SRGBA:
        case SG_PIXELFORMAT_BC7_SRGBA:
        case SG_PIXELFORMAT_ETC2_SRGB8:
        case SG_PIXELFORMAT_ETC2_SRGB8A8:
        case SG_PIXELFORMAT_ASTC_4x4_SRGBA:
            return true;

        default:
            return false;
    }
}

/**
 * @brief 检查像素格式是否为压缩格式
 *
 * @param format 像素格式
 * @return bool 如果是压缩格式返回true
 */
inline bool is_compressed(sg_pixel_format format) {
    switch (format) {
        case SG_PIXELFORMAT_BC1_RGBA:
        case SG_PIXELFORMAT_BC2_RGBA:
        case SG_PIXELFORMAT_BC3_RGBA:
        case SG_PIXELFORMAT_BC3_SRGBA:
        case SG_PIXELFORMAT_BC4_R:
        case SG_PIXELFORMAT_BC4_RSN:
        case SG_PIXELFORMAT_BC5_RG:
        case SG_PIXELFORMAT_BC5_RGSN:
        case SG_PIXELFORMAT_BC6H_RGBF:
        case SG_PIXELFORMAT_BC6H_RGBUF:
        case SG_PIXELFORMAT_BC7_RGBA:
        case SG_PIXELFORMAT_BC7_SRGBA:
        case SG_PIXELFORMAT_ETC2_RGB8:
        case SG_PIXELFORMAT_ETC2_SRGB8:
        case SG_PIXELFORMAT_ETC2_RGB8A1:
        case SG_PIXELFORMAT_ETC2_RGBA8:
        case SG_PIXELFORMAT_ETC2_SRGB8A8:
        case SG_PIXELFORMAT_EAC_R11:
        case SG_PIXELFORMAT_EAC_R11SN:
        case SG_PIXELFORMAT_EAC_RG11:
        case SG_PIXELFORMAT_EAC_RG11SN:
        case SG_PIXELFORMAT_ASTC_4x4_RGBA:
        case SG_PIXELFORMAT_ASTC_4x4_SRGBA:
            return true;

        default:
            return false;
    }
}

/**
 * @brief 检查像素格式是否为深度或模板格式
 *
 * @param format 像素格式
 * @return bool 如果是深度或模板格式返回true
 */
inline bool is_depth_or_stencil(sg_pixel_format format) {
    return format == SG_PIXELFORMAT_DEPTH || format == SG_PIXELFORMAT_DEPTH_STENCIL;
}

/**
 * @brief 获取格式字符串描述
 *
 * @param format 像素格式
 * @return const char* 格式描述
 */
inline const char* get_format_string(sg_pixel_format format) {
    switch (format) {
        case _SG_PIXELFORMAT_DEFAULT: return "DEFAULT";
        case SG_PIXELFORMAT_NONE: return "NONE";
        case SG_PIXELFORMAT_R8: return "R8";
        case SG_PIXELFORMAT_R8SN: return "R8SN";
        case SG_PIXELFORMAT_R8UI: return "R8UI";
        case SG_PIXELFORMAT_R8SI: return "R8SI";
        case SG_PIXELFORMAT_R16: return "R16";
        case SG_PIXELFORMAT_R16SN: return "R16SN";
        case SG_PIXELFORMAT_R16UI: return "R16UI";
        case SG_PIXELFORMAT_R16SI: return "R16SI";
        case SG_PIXELFORMAT_R16F: return "R16F";
        case SG_PIXELFORMAT_RG8: return "RG8";
        case SG_PIXELFORMAT_RG8SN: return "RG8SN";
        case SG_PIXELFORMAT_RG8UI: return "RG8UI";
        case SG_PIXELFORMAT_RG8SI: return "RG8SI";
        case SG_PIXELFORMAT_R32UI: return "R32UI";
        case SG_PIXELFORMAT_R32SI: return "R32SI";
        case SG_PIXELFORMAT_R32F: return "R32F";
        case SG_PIXELFORMAT_RG16: return "RG16";
        case SG_PIXELFORMAT_RG16SN: return "RG16SN";
        case SG_PIXELFORMAT_RG16UI: return "RG16UI";
        case SG_PIXELFORMAT_RG16SI: return "RG16SI";
        case SG_PIXELFORMAT_RG16F: return "RG16F";
        case SG_PIXELFORMAT_RGBA8: return "RGBA8";
        case SG_PIXELFORMAT_SRGB8A8: return "SRGB8A8";
        case SG_PIXELFORMAT_RGBA8SN: return "RGBA8SN";
        case SG_PIXELFORMAT_RGBA8UI: return "RGBA8UI";
        case SG_PIXELFORMAT_RGBA8SI: return "RGBA8SI";
        case SG_PIXELFORMAT_BGRA8: return "BGRA8";
        case SG_PIXELFORMAT_RGB10A2: return "RGB10A2";
        case SG_PIXELFORMAT_RG11B10F: return "RG11B10F";
        case SG_PIXELFORMAT_RGB9E5: return "RGB9E5";
        case SG_PIXELFORMAT_RG32UI: return "RG32UI";
        case SG_PIXELFORMAT_RG32SI: return "RG32SI";
        case SG_PIXELFORMAT_RG32F: return "RG32F";
        case SG_PIXELFORMAT_RGBA16: return "RGBA16";
        case SG_PIXELFORMAT_RGBA16SN: return "RGBA16SN";
        case SG_PIXELFORMAT_RGBA16UI: return "RGBA16UI";
        case SG_PIXELFORMAT_RGBA16SI: return "RGBA16SI";
        case SG_PIXELFORMAT_RGBA16F: return "RGBA16F";
        case SG_PIXELFORMAT_RGBA32UI: return "RGBA32UI";
        case SG_PIXELFORMAT_RGBA32SI: return "RGBA32SI";
        case SG_PIXELFORMAT_RGBA32F: return "RGBA32F";
        case SG_PIXELFORMAT_DEPTH: return "DEPTH";
        case SG_PIXELFORMAT_DEPTH_STENCIL: return "DEPTH_STENCIL";
        case SG_PIXELFORMAT_BC1_RGBA: return "BC1_RGBA";
        case SG_PIXELFORMAT_BC2_RGBA: return "BC2_RGBA";
        case SG_PIXELFORMAT_BC3_RGBA: return "BC3_RGBA";
        case SG_PIXELFORMAT_BC3_SRGBA: return "BC3_SRGBA";
        case SG_PIXELFORMAT_BC4_R: return "BC4_R";
        case SG_PIXELFORMAT_BC4_RSN: return "BC4_RSN";
        case SG_PIXELFORMAT_BC5_RG: return "BC5_RG";
        case SG_PIXELFORMAT_BC5_RGSN: return "BC5_RGSN";
        case SG_PIXELFORMAT_BC6H_RGBF: return "BC6H_RGBF";
        case SG_PIXELFORMAT_BC6H_RGBUF: return "BC6H_RGBUF";
        case SG_PIXELFORMAT_BC7_RGBA: return "BC7_RGBA";
        case SG_PIXELFORMAT_BC7_SRGBA: return "BC7_SRGBA";
        case SG_PIXELFORMAT_ETC2_RGB8: return "ETC2_RGB8";
        case SG_PIXELFORMAT_ETC2_SRGB8: return "ETC2_SRGB8";
        case SG_PIXELFORMAT_ETC2_RGB8A1: return "ETC2_RGB8A1";
        case SG_PIXELFORMAT_ETC2_RGBA8: return "ETC2_RGBA8";
        case SG_PIXELFORMAT_ETC2_SRGB8A8: return "ETC2_SRGB8A8";
        case SG_PIXELFORMAT_EAC_R11: return "EAC_R11";
        case SG_PIXELFORMAT_EAC_R11SN: return "EAC_R11SN";
        case SG_PIXELFORMAT_EAC_RG11: return "EAC_RG11";
        case SG_PIXELFORMAT_EAC_RG11SN: return "EAC_RG11SN";
        case SG_PIXELFORMAT_ASTC_4x4_RGBA: return "ASTC_4x4_RGBA";
        case SG_PIXELFORMAT_ASTC_4x4_SRGBA: return "ASTC_4x4_SRGBA";
        default: return "UNKNOWN";
    }
}

} // namespace pixel_format

/**
 * @brief 通用数值类型转换函数
 *
 * 将一个数值类型的值线性映射到另一个数值类型的范围。
 * 保持输入值在源类型范围内的相对位置。
 *
 * @tparam From 源数据类型
 * @tparam To 目标数据类型
 * @param value 要转换的值
 * @return To 转换后的值，范围映射到目标类型的最小值和最大值之间
 */
template<typename From, typename To>
To convert(const From& value) {
    // 如果源和目标类型相同，直接返回
    if constexpr (std::is_same_v<From, To>) {
        return value;
    }

    // 获取 From 和 To 类型的值范围
    const auto source_min = static_cast<double>(std::numeric_limits<From>::lowest());
    const auto source_max = static_cast<double>(std::numeric_limits<From>::max());
    const auto target_min = static_cast<double>(std::numeric_limits<To>::lowest());
    const auto target_max = static_cast<double>(std::numeric_limits<To>::max());

    // 线性映射公式: 将值从源范围映射到目标范围
    const auto normalized = (static_cast<double>(value) - source_min) / (source_max - source_min);
    return static_cast<To>(target_min + normalized * (target_max - target_min));
}

/**
 * @brief 颜色值专用转换函数
 *
 * 专门用于颜色值转换的优化函数，处理以下常见场景：
 * 1. 整数类型到浮点数：通常从[0,255]映射到[0.0,1.0]
 * 2. 浮点数到整数类型：通常从[0.0,1.0]映射到[0,255]
 * 3. 相同类型间转换：直接返回原值
 *
 * 与通用convert函数不同，此函数假设颜色值具有特定的范围和语义。
 *
 * @tparam From 源数据类型
 * @tparam To 目标数据类型
 * @param value 要转换的颜色值
 * @return To 转换后的颜色值
 */
template<typename From, typename To>
To color_convert(const From& value) {
    // 如果源和目标类型相同，直接返回
    if constexpr (std::is_same_v<From, To>) {
        return value;
    }

    // 整数到浮点数的映射（如 uint8_t[0,255] 到 float[0.0,1.0]）
    if constexpr (std::is_integral_v<From> && std::is_floating_point_v<To>) {
        // 对于整数颜色值，映射到[0,1]范围
        const auto max_value = static_cast<double>(std::numeric_limits<From>::max());
        return static_cast<To>(static_cast<double>(value) / max_value);
    }

    // 浮点数到整数的映射（如 float[0.0,1.0] 到 uint8_t[0,255]）
    if constexpr (std::is_floating_point_v<From> && std::is_integral_v<To>) {
        // 浮点数颜色值应在[0,1]范围内
        const auto max_value = static_cast<double>(std::numeric_limits<To>::max());
        // 限制输入到[0,1]范围，然后映射到目标整数范围
        double clamped = std::clamp(static_cast<double>(value), 0.0, 1.0);
        return static_cast<To>(clamped * max_value + 0.5); // 加0.5用于四舍五入
    }

    // 整数到整数的映射（如 uint8_t[0,255] 到 uint16_t[0,65535]）
    if constexpr (std::is_integral_v<From> && std::is_integral_v<To>) {
        // 对于不同整数类型之间的转换，保持颜色值的相对比例
        const auto source_max = static_cast<double>(std::numeric_limits<From>::max());
        const auto target_max = static_cast<double>(std::numeric_limits<To>::max());

        // 计算映射比例
        double ratio = target_max / source_max;
        // 映射值并四舍五入
        return static_cast<To>(static_cast<double>(value) * ratio + 0.5);
    }

    // 浮点数到浮点数的映射（如 float 到 double）
    if constexpr (std::is_floating_point_v<From> && std::is_floating_point_v<To>) {
        // 对于颜色值，不同浮点类型通常表示相同范围[0,1]，直接转换
        return static_cast<To>(value);
    }

    // 默认情况，使用简单的强制类型转换（不应触发）
    return static_cast<To>(value);
}

/**
 * @brief 色彩空间转换命名空间
 *
 * 包含各种色彩空间之间的转换函数
 */
namespace color_space {

	/**
	 * @brief RGB转HSV色彩空间
	 *
	 * @tparam T 像素数据类型，通常为浮点类型
	 * @param r 红色分量 [0,1]
	 * @param g 绿色分量 [0,1]
	 * @param b 蓝色分量 [0,1]
	 * @param h 输出色相 [0,360)
	 * @param s 输出饱和度 [0,1]
	 * @param v 输出明度 [0,1]
	 */
	template<typename T>
	void rgb_to_hsv(T r, T g, T b, T& h, T& s, T& v) {
		static_assert(std::is_floating_point_v<T>, "RGB to HSV conversion requires floating point type");

		T max_val = std::max({ r, g, b });
		T min_val = std::min({ r, g, b });
		T delta   = max_val - min_val;

		// 计算明度
		v = max_val;

		// 计算饱和度
		if (max_val == 0) { s = 0; }
		else { s = delta / max_val; }

		// 计算色相
		if (delta == 0) {
			h = 0; // 无色相（灰度）
		}
		else if (max_val == r) { h = 60 * std::fmod((g - b) / delta, 6); }
		else if (max_val == g) { h = 60 * ((b - r) / delta + 2); }
		else { // max_val == b
			h = 60 * ((r - g) / delta + 4);
		}

		// 确保色相在0-360范围内
		if (h < 0)
			h += 360;
	}

	/**
	 * @brief HSV转RGB色彩空间
	 *
	 * @tparam T 像素数据类型，通常为浮点类型
	 * @param h 色相 [0,360)
	 * @param s 饱和度 [0,1]
	 * @param v 明度 [0,1]
	 * @param r 输出红色分量 [0,1]
	 * @param g 输出绿色分量 [0,1]
	 * @param b 输出蓝色分量 [0,1]
	 */
	template<typename T>
	void hsv_to_rgb(T h, T s, T v, T& r, T& g, T& b) {
		static_assert(std::is_floating_point_v<T>, "HSV to RGB conversion requires floating point type");

		// 无饱和度，直接返回灰度
		if (s <= 0.0) {
			r = g = b = v;
			return;
		}

		// 将色相转换为0-6范围内
		h      = std::fmod(h, 360) / 60;
		int hi = static_cast<int>(h);
		T   f  = h - hi;

		T p = v * (1 - s);
		T q = v * (1 - s * f);
		T t = v * (1 - s * (1 - f));

		switch (hi) {
			case 0:
				r = v;
				g = t;
				b = p;
				break;
			case 1:
				r = q;
				g = v;
				b = p;
				break;
			case 2:
				r = p;
				g = v;
				b = t;
				break;
			case 3:
				r = p;
				g = q;
				b = v;
				break;
			case 4:
				r = t;
				g = p;
				b = v;
				break;
			default:
				r = v;
				g = p;
				b = q;
				break;
		}
	}

	/**
	 * @brief RGB转HSL色彩空间
	 *
	 * @tparam T 像素数据类型，通常为浮点类型
	 * @param r 红色分量 [0,1]
	 * @param g 绿色分量 [0,1]
	 * @param b 蓝色分量 [0,1]
	 * @param h 输出色相 [0,360)
	 * @param s 输出饱和度 [0,1]
	 * @param l 输出亮度 [0,1]
	 */
	template<typename T>
	void rgb_to_hsl(T r, T g, T b, T& h, T& s, T& l) {
		static_assert(std::is_floating_point_v<T>, "RGB to HSL conversion requires floating point type");

		T max_val = std::max({ r, g, b });
		T min_val = std::min({ r, g, b });
		T delta   = max_val - min_val;

		// 计算亮度
		l = (max_val + min_val) / 2;

		// 计算饱和度
		if (delta == 0) {
			s = 0; // 灰度
		}
		else { s = (l <= 0.5) ? (delta / (max_val + min_val)) : (delta / (2 - max_val - min_val)); }

		// 计算色相
		if (delta == 0) {
			h = 0; // 无色相（灰度）
		}
		else if (max_val == r) { h = 60 * std::fmod((g - b) / delta, 6); }
		else if (max_val == g) { h = 60 * ((b - r) / delta + 2); }
		else { // max_val == b
			h = 60 * ((r - g) / delta + 4);
		}

		// 确保色相在0-360范围内
		if (h < 0)
			h += 360;
	}

	/**
	 * @brief HSL转RGB色彩空间
	 *
	 * @tparam T 像素数据类型，通常为浮点类型
	 * @param h 色相 [0,360)
	 * @param s 饱和度 [0,1]
	 * @param l 亮度 [0,1]
	 * @param r 输出红色分量 [0,1]
	 * @param g 输出绿色分量 [0,1]
	 * @param b 输出蓝色分量 [0,1]
	 */
	template<typename T>
	void hsl_to_rgb(T h, T s, T l, T& r, T& g, T& b) {
		static_assert(std::is_floating_point_v<T>, "HSL to RGB conversion requires floating point type");

		// 无饱和度，直接返回灰度
		if (s <= 0.0) {
			r = g = b = l;
			return;
		}

		T q = (l < 0.5) ? (l * (1 + s)) : (l + s - l * s);
		T p = 2 * l - q;

		// 将色相归一化到[0,1]
		h = std::fmod(h, 360) / 360;

		// 计算RGB
		auto hue_to_rgb = [p, q](T t) {
			if (t < 0)
				t += 1;
			if (t > 1)
				t -= 1;
			if (t < 1 / 6.0)
				return p + (q - p) * 6 * t;
			if (t < 1 / 2.0)
				return q;
			if (t < 2 / 3.0)
				return p + (q - p) * (2 / 3.0 - t) * 6;
			return p;
		};

		r = hue_to_rgb(h + 1 / 3.0);
		g = hue_to_rgb(h);
		b = hue_to_rgb(h - 1 / 3.0);
	}

	/**
	 * @brief RGB转YUV色彩空间 (BT.709标准)
	 *
	 * @tparam T 像素数据类型，通常为浮点类型
	 * @param r 红色分量 [0,1]
	 * @param g 绿色分量 [0,1]
	 * @param b 蓝色分量 [0,1]
	 * @param y 输出亮度分量 [0,1]
	 * @param u 输出色度分量U [-0.5,0.5]
	 * @param v 输出色度分量V [-0.5,0.5]
	 */
	template<typename T>
	void rgb_to_yuv(T r, T g, T b, T& y, T& u, T& v) {
		static_assert(std::is_floating_point_v<T>, "RGB to YUV conversion requires floating point type");

		// BT.709 系数
		y = 0.2126f * r + 0.7152f * g + 0.0722f * b;
		u = -0.09991f * r - 0.33609f * g + 0.436f * b;
		v = 0.615f * r - 0.55861f * g - 0.05639f * b;
	}

	/**
	 * @brief YUV转RGB色彩空间 (BT.709标准)
	 *
	 * @tparam T 像素数据类型，通常为浮点类型
	 * @param y 亮度分量 [0,1]
	 * @param u 色度分量U [-0.5,0.5]
	 * @param v 色度分量V [-0.5,0.5]
	 * @param r 输出红色分量 [0,1]
	 * @param g 输出绿色分量 [0,1]
	 * @param b 输出蓝色分量 [0,1]
	 */
	template<typename T>
	void yuv_to_rgb(T y, T u, T v, T& r, T& g, T& b) {
		static_assert(std::is_floating_point_v<T>, "YUV to RGB conversion requires floating point type");

		// BT.709 逆变换系数
		r = y + 1.28033f * v;
		g = y - 0.21482f * u - 0.38059f * v;
		b = y + 2.12798f * u;

		// 剪裁到[0,1]范围
		r = std::clamp(r, T(0), T(1));
		g = std::clamp(g, T(0), T(1));
		b = std::clamp(b, T(0), T(1));
	}

	/**
	 * @brief RGB转YCbCr色彩空间 (JPEG标准)
	 *
	 * @tparam T 像素数据类型，通常为浮点类型
	 * @param r 红色分量 [0,1]
	 * @param g 绿色分量 [0,1]
	 * @param b 蓝色分量 [0,1]
	 * @param y 输出亮度分量 [0,1]
	 * @param cb 输出蓝色色度分量 [-0.5,0.5]
	 * @param cr 输出红色色度分量 [-0.5,0.5]
	 */
	template<typename T>
	void rgb_to_ycbcr(T r, T g, T b, T& y, T& cb, T& cr) {
		static_assert(std::is_floating_point_v<T>, "RGB to YCbCr conversion requires floating point type");

		// JPEG标准系数
		y  = 0.299f * r + 0.587f * g + 0.114f * b;
		cb = -0.168736f * r - 0.331264f * g + 0.5f * b;
		cr = 0.5f * r - 0.418688f * g - 0.081312f * b;
	}

	/**
	 * @brief YCbCr转RGB色彩空间 (JPEG标准)
	 *
	 * @tparam T 像素数据类型，通常为浮点类型
	 * @param y 亮度分量 [0,1]
	 * @param cb 蓝色色度分量 [-0.5,0.5]
	 * @param cr 红色色度分量 [-0.5,0.5]
	 * @param r 输出红色分量 [0,1]
	 * @param g 输出绿色分量 [0,1]
	 * @param b 输出蓝色分量 [0,1]
	 */
	template<typename T>
	void ycbcr_to_rgb(T y, T cb, T cr, T& r, T& g, T& b) {
		static_assert(std::is_floating_point_v<T>, "YCbCr to RGB conversion requires floating point type");

		// JPEG标准逆变换系数
		r = y + 1.402f * cr;
		g = y - 0.344136f * cb - 0.714136f * cr;
		b = y + 1.772f * cb;

		// 剪裁到[0,1]范围
		r = std::clamp(r, T(0), T(1));
		g = std::clamp(g, T(0), T(1));
		b = std::clamp(b, T(0), T(1));
	}

	/**
	 * @brief sRGB转线性RGB
	 *
	 * @tparam T 像素数据类型，通常为浮点类型
	 * @param srgb sRGB颜色值 [0,1]
	 * @return T 线性RGB颜色值 [0,1]
	 */
	template<typename T>
	T srgb_to_linear(T srgb) {
		static_assert(std::is_floating_point_v<T>, "sRGB to Linear conversion requires floating point type");

		if (srgb <= 0.04045f) { return srgb / 12.92f; }
		else { return std::pow((srgb + 0.055f) / 1.055f, 2.4f); }
	}

	/**
	 * @brief 线性RGB转sRGB
	 *
	 * @tparam T 像素数据类型，通常为浮点类型
	 * @param linear 线性RGB颜色值 [0,1]
	 * @return T sRGB颜色值 [0,1]
	 */
	template<typename T>
	T linear_to_srgb(T linear) {
		static_assert(std::is_floating_point_v<T>, "Linear to sRGB conversion requires floating point type");

		if (linear <= 0.0031308f) { return 12.92f * linear; }
		else { return 1.055f * std::pow(linear, 1.0f / 2.4f) - 0.055f; }
	}

	/**
	 * @brief RGB转XYZ色彩空间 (sRGB标准)
	 *
	 * @tparam T 像素数据类型，通常为浮点类型
	 * @param r 红色分量 [0,1]
	 * @param g 绿色分量 [0,1]
	 * @param b 蓝色分量 [0,1]
	 * @param x 输出X分量
	 * @param y 输出Y分量
	 * @param z 输出Z分量
	 */
	template<typename T>
	void rgb_to_xyz(T r, T g, T b, T& x, T& y, T& z) {
		static_assert(std::is_floating_point_v<T>, "RGB to XYZ conversion requires floating point type");

		// 先将sRGB转换为线性RGB
		r = srgb_to_linear(r);
		g = srgb_to_linear(g);
		b = srgb_to_linear(b);

		// sRGB到XYZ的变换矩阵
		x = 0.4124f * r + 0.3576f * g + 0.1805f * b;
		y = 0.2126f * r + 0.7152f * g + 0.0722f * b;
		z = 0.0193f * r + 0.1192f * g + 0.9505f * b;
	}

	/**
	 * @brief XYZ转RGB色彩空间 (sRGB标准)
	 *
	 * @tparam T 像素数据类型，通常为浮点类型
	 * @param x X分量
	 * @param y Y分量
	 * @param z Z分量
	 * @param r 输出红色分量 [0,1]
	 * @param g 输出绿色分量 [0,1]
	 * @param b 输出蓝色分量 [0,1]
	 */
	template<typename T>
	void xyz_to_rgb(T x, T y, T z, T& r, T& g, T& b) {
		static_assert(std::is_floating_point_v<T>, "XYZ to RGB conversion requires floating point type");

		// XYZ到线性RGB的变换矩阵
		r = 3.2406f * x - 1.5372f * y - 0.4986f * z;
		g = -0.9689f * x + 1.8758f * y + 0.0415f * z;
		b = 0.0557f * x - 0.2040f * y + 1.0570f * z;

		// 剪裁到[0,1]范围
		r = std::clamp(r, T(0), T(1));
		g = std::clamp(g, T(0), T(1));
		b = std::clamp(b, T(0), T(1));

		// 线性RGB转sRGB
		r = linear_to_srgb(r);
		g = linear_to_srgb(g);
		b = linear_to_srgb(b);
	}

	/**
	 * @brief XYZ转CIELAB色彩空间
	 *
	 * @tparam T 像素数据类型，通常为浮点类型
	 * @param x X分量
	 * @param y Y分量
	 * @param z Z分量
	 * @param l 输出亮度L* [0,100]
	 * @param a 输出a*分量 [-128,127]
	 * @param b 输出b*分量 [-128,127]
	 */
	template<typename T>
	void xyz_to_lab(T x, T y, T z, T& l, T& a, T& b) {
		static_assert(std::is_floating_point_v<T>, "XYZ to LAB conversion requires floating point type");

		// 参考白点 (D65)
		const T xn = 0.95047f;
		const T yn = 1.0f;
		const T zn = 1.08883f;

		// 归一化
		x /= xn;
		y /= yn;
		z /= zn;

		// XYZ到Lab的变换
		auto f = [](T t) {
			const T delta = 6.0f / 29.0f;
			return (t > std::pow(delta, 3)) ? std::pow(t, 1.0f / 3.0f) : (t / (3 * std::pow(delta, 2)) + 4.0f / 29.0f);
		};

		l = 116.0f * f(y) - 16.0f;
		a = 500.0f * (f(x) - f(y));
		b = 200.0f * (f(y) - f(z));
	}

	/**
	 * @brief CIELAB转XYZ色彩空间
	 *
	 * @tparam T 像素数据类型，通常为浮点类型
	 * @param l 亮度L* [0,100]
	 * @param a a*分量 [-128,127]
	 * @param b b*分量 [-128,127]
	 * @param x 输出X分量
	 * @param y 输出Y分量
	 * @param z 输出Z分量
	 */
	template<typename T>
	void lab_to_xyz(T l, T a, T b, T& x, T& y, T& z) {
		static_assert(std::is_floating_point_v<T>, "LAB to XYZ conversion requires floating point type");

		// 参考白点 (D65)
		const T xn = 0.95047f;
		const T yn = 1.0f;
		const T zn = 1.08883f;

		// Lab到XYZ的变换
		auto f_inv = [](T t) {
			const T delta = 6.0f / 29.0f;
			return (t > delta) ? std::pow(t, 3) : 3 * std::pow(delta, 2) * (t - 4.0f / 29.0f);
		};

		T fy = (l + 16.0f) / 116.0f;
		T fx = fy + a / 500.0f;
		T fz = fy - b / 200.0f;

		x = xn * f_inv(fx);
		y = yn * f_inv(fy);
		z = zn * f_inv(fz);
	}

	/**
	 * @brief RGB转CMYK色彩空间
	 *
	 * @tparam T 像素数据类型，通常为浮点类型
	 * @param r 红色分量 [0,1]
	 * @param g 绿色分量 [0,1]
	 * @param b 蓝色分量 [0,1]
	 * @param c 输出青色分量 [0,1]
	 * @param m 输出品红分量 [0,1]
	 * @param y 输出黄色分量 [0,1]
	 * @param k 输出黑色分量 [0,1]
	 */
	template<typename T>
	void rgb_to_cmyk(T r, T g, T b, T& c, T& m, T& y, T& k) {
		static_assert(std::is_floating_point_v<T>, "RGB to CMYK conversion requires floating point type");

		k = 1 - std::max({ r, g, b });

		// 避免除以零
		if (std::abs(k - 1) < std::numeric_limits<T>::epsilon()) { c = m = y = 0; }
		else {
			c = (1 - r - k) / (1 - k);
			m = (1 - g - k) / (1 - k);
			y = (1 - b - k) / (1 - k);
		}
	}

	/**
	 * @brief CMYK转RGB色彩空间
	 *
	 * @tparam T 像素数据类型，通常为浮点类型
	 * @param c 青色分量 [0,1]
	 * @param m 品红分量 [0,1]
	 * @param y 黄色分量 [0,1]
	 * @param k 黑色分量 [0,1]
	 * @param r 输出红色分量 [0,1]
	 * @param g 输出绿色分量 [0,1]
	 * @param b 输出蓝色分量 [0,1]
	 */
	template<typename T>
	void cmyk_to_rgb(T c, T m, T y, T k, T& r, T& g, T& b) {
		static_assert(std::is_floating_point_v<T>, "CMYK to RGB conversion requires floating point type");

		r = (1 - c) * (1 - k);
		g = (1 - m) * (1 - k);
		b = (1 - y) * (1 - k);
	}

} // namespace color_space

/**
 * @brief 像素结构体模板
 *
 * 表示具有 N 个通道的像素，每个通道的数据类型为 T。
 * 支持常见的像素操作如访问各个通道、颜色空间转换和像素间运算。
 *
 * @tparam T 像素通道数据类型（如 uint8_t, float 等）
 * @tparam N 像素通道数（如RGB=3, RGBA=4）
 */
template<typename T, int N>
struct pixel {
    using pixel_type = T;
    static constexpr int channel_count = N;

    // 默认构造函数
    pixel() = default;

    // 拷贝构造函数
    pixel(const pixel& rhs) {
        for (int i = 0; i < N; i++) {
            data[i] = rhs.data[i];
        }
    }

    /**
     * @brief 从不同类型的像素转换
     *
     * 使用 color_convert 函数将不同类型的像素转换为当前类型
     *
     * @tparam U 源像素的通道数据类型
     * @tparam N2 源像素的通道数
     * @param rhs 源像素
     */
    template<typename U, int N2>
    pixel(const pixel<U, N2>& rhs) {
        *this = rhs;
    }

    T data[N]; // 像素数据数组

    // 索引访问
    T& operator[](int i) { return data[i]; }
    const T& operator[](int i) const { return data[i]; }

    // RGBA通道访问器
    T& r() { return data[0]; }
    T& g() { return N > 1 ? data[1] : data[0]; }
    T& b() { return N > 2 ? data[2] : data[0]; }
    T& a() { return N > 3 ? data[3] : data[0]; }

    T r() const { return data[0]; }
    T g() const { return N > 1 ? data[1] : data[0]; }
    T b() const { return N > 2 ? data[2] : data[0]; }
    T a() const { return N > 3 ? data[3] : data[0]; }

    /**
     * @brief 计算像素亮度
     *
     * 使用基于人类视觉系统的RGB加权平均值计算亮度
     * 注意：此函数仅适用于至少有3个通道的像素（RGB或RGBA）
     *
     * @return T 亮度值
     */
    T luminance() const {
        static_assert(N >= 3, "Luminance calculation requires at least 3 channels");
        return static_cast<T>(0.2126f * data[0] + 0.7152f * data[1] + 0.0722f * data[2]);
    }

    /**
     * @brief 计算像素灰度
     *
     * 使用RGB通道的简单平均值计算灰度
     * 注意：此函数仅适用于至少有3个通道的像素（RGB或RGBA）
     *
     * @return T 灰度值
     */
    T grayscale() const {
        static_assert(N >= 3, "Grayscale calculation requires at least 3 channels");
        return static_cast<T>((data[0] + data[1] + data[2]) / 3);
    }

    /**
     * @brief 将线性RGB值转换为sRGB值
     *
     * 注意：此函数仅适用于第一个通道
     *
     * @return T sRGB值
     */
    T sRGB() const {
        return static_cast<T>(data[0] <= 0.0031308f ?
               12.92f * data[0] :
               1.055f * std::pow(static_cast<float>(data[0]), 1.0f / 2.4f) - 0.055f);
    }

    /**
     * @brief 将sRGB值转换为线性RGB值
     *
     * 注意：此函数仅适用于第一个通道
     *
     * @return T 线性RGB值
     */
    T linearRGB() const {
        return static_cast<T>(data[0] <= 0.04045f ?
               data[0] / 12.92f :
               std::pow((static_cast<float>(data[0]) + 0.055f) / 1.055f, 2.4f));
    }

    /**
     * @brief 计算像素的Y值（YCbCr颜色空间）
     *
     * 注意：此函数仅适用于至少有3个通道的像素（RGB或RGBA）
     *
     * @return T YCbCr中的Y值
     */
    T YCbCr() const {
        static_assert(N >= 3, "YCbCr calculation requires at least 3 channels");
        return static_cast<T>(0.299f * data[0] + 0.587f * data[1] + 0.114f * data[2]);
    }

    /**
     * @brief 计算像素的Y值（YUV颜色空间）
     *
     * 注意：此函数仅适用于至少有3个通道的像素（RGB或RGBA）
     *
     * @return T YUV中的Y值
     */
    T YUV() const {
        static_assert(N >= 3, "YUV calculation requires at least 3 channels");
        return static_cast<T>(0.299f * data[0] + 0.587f * data[1] + 0.114f * data[2]);
    }

    // 像素间运算操作符
    pixel operator+(const pixel& rhs) const {
        pixel result;
        for (int i = 0; i < N; ++i) {
            result.data[i] = data[i] + rhs.data[i];
        }
        return result;
    }

    pixel operator-(const pixel& rhs) const {
        pixel result;
        for (int i = 0; i < N; ++i) {
            result.data[i] = data[i] - rhs.data[i];
        }
        return result;
    }

    pixel operator*(const pixel& rhs) const {
        pixel result;
        for (int i = 0; i < N; ++i) {
            result.data[i] = data[i] * rhs.data[i];
        }
        return result;
    }

    pixel operator/(const pixel& rhs) const {
        pixel result;
        for (int i = 0; i < N; ++i) {
            result.data[i] = data[i] / rhs.data[i];
        }
        return result;
    }

    pixel& operator+=(const pixel& rhs) {
        for (int i = 0; i < N; ++i) {
            data[i] += rhs.data[i];
        }
        return *this;
    }

    pixel& operator-=(const pixel& rhs) {
        for (int i = 0; i < N; ++i) {
            data[i] -= rhs.data[i];
        }
        return *this;
    }

    pixel& operator*=(const pixel& rhs) {
        for (int i = 0; i < N; ++i) {
            data[i] *= rhs.data[i];
        }
        return *this;
    }

    pixel& operator/=(const pixel& rhs) {
        for (int i = 0; i < N; ++i) {
            data[i] /= rhs.data[i];
        }
        return *this;
    }

    /**
     * @brief 不同类型像素间的赋值操作
     *
     * 使用 color_convert 函数将每个通道从U类型转换为T类型
     *
     * @tparam U 源像素的通道数据类型
     * @tparam N2 源像素的通道数
     * @param rhs 源像素
     * @return pixel<T, N>& 当前像素的引用
     */
    template<typename U, int N2>
    pixel& operator=(const pixel<U, N2>& rhs) {
        constexpr int Num = std::min(N, N2);
        std::memset(data, 0, sizeof(data)); // 先清零所有通道
        for (int i = 0; i < Num; ++i) {
            data[i] = color_convert<U, T>(rhs.data[i]);
        }
        return *this;
    }

    /**
     * @brief 显式类型转换操作符
     *
     * 将当前像素转换为不同类型的像素
     *
     * @tparam U 目标像素的通道数据类型
     * @tparam N2 目标像素的通道数
     * @return pixel<U, N2> 转换后的像素
     */
    template<typename U, int N2>
    explicit operator pixel<U, N2>() const {
        pixel<U, N2> result;
        result = *this;
        return result;
    }

	/**
     * @brief 将RGB像素转换为HSV像素
     *
     * 要求像素至少有3个通道
     *
     * @return pixel<T, 3> HSV像素
     */
    pixel<T, 3> to_hsv() const {
        static_assert(N >= 3, "RGB to HSV conversion requires at least 3 channels");
        static_assert(std::is_floating_point_v<T>, "RGB to HSV conversion requires floating point type");

        pixel<T, 3> result;
        color_space::rgb_to_hsv(data[0], data[1], data[2],
                               result.data[0], result.data[1], result.data[2]);
        return result;
    }

    /**
     * @brief 将HSV像素转换为RGB像素
     *
     * 要求像素至少有3个通道
     *
     * @return pixel<T, 3> RGB像素
     */
    pixel<T, 3> from_hsv() const {
        static_assert(N >= 3, "HSV to RGB conversion requires at least 3 channels");
        static_assert(std::is_floating_point_v<T>, "HSV to RGB conversion requires floating point type");

        pixel<T, 3> result;
        color_space::hsv_to_rgb(data[0], data[1], data[2],
                               result.data[0], result.data[1], result.data[2]);
        return result;
    }

    /**
     * @brief 将RGB像素转换为HSL像素
     *
     * 要求像素至少有3个通道
     *
     * @return pixel<T, 3> HSL像素
     */
    pixel<T, 3> to_hsl() const {
        static_assert(N >= 3, "RGB to HSL conversion requires at least 3 channels");
        static_assert(std::is_floating_point_v<T>, "RGB to HSL conversion requires floating point type");

        pixel<T, 3> result;
        color_space::rgb_to_hsl(data[0], data[1], data[2],
                               result.data[0], result.data[1], result.data[2]);
        return result;
    }

    /**
     * @brief 将HSL像素转换为RGB像素
     *
     * 要求像素至少有3个通道
     *
     * @return pixel<T, 3> RGB像素
     */
    pixel<T, 3> from_hsl() const {
        static_assert(N >= 3, "HSL to RGB conversion requires at least 3 channels");
        static_assert(std::is_floating_point_v<T>, "HSL to RGB conversion requires floating point type");

        pixel<T, 3> result;
        color_space::hsl_to_rgb(data[0], data[1], data[2],
                               result.data[0], result.data[1], result.data[2]);
        return result;
    }

    /**
     * @brief 将RGB像素转换为YUV像素
     *
     * 要求像素至少有3个通道
     *
     * @return pixel<T, 3> YUV像素
     */
    pixel<T, 3> to_yuv() const {
        static_assert(N >= 3, "RGB to YUV conversion requires at least 3 channels");
        static_assert(std::is_floating_point_v<T>, "RGB to YUV conversion requires floating point type");

        pixel<T, 3> result;
        color_space::rgb_to_yuv(data[0], data[1], data[2],
                               result.data[0], result.data[1], result.data[2]);
        return result;
    }

    /**
     * @brief 将YUV像素转换为RGB像素
     *
     * 要求像素至少有3个通道
     *
     * @return pixel<T, 3> RGB像素
     */
    pixel<T, 3> from_yuv() const {
        static_assert(N >= 3, "YUV to RGB conversion requires at least 3 channels");
        static_assert(std::is_floating_point_v<T>, "YUV to RGB conversion requires floating point type");

        pixel<T, 3> result;
        color_space::yuv_to_rgb(data[0], data[1], data[2],
                               result.data[0], result.data[1], result.data[2]);
        return result;
    }

    /**
     * @brief 将RGB像素转换为YCbCr像素
     *
     * 要求像素至少有3个通道
     *
     * @return pixel<T, 3> YCbCr像素
     */
    pixel<T, 3> to_ycbcr() const {
        static_assert(N >= 3, "RGB to YCbCr conversion requires at least 3 channels");
        static_assert(std::is_floating_point_v<T>, "RGB to YCbCr conversion requires floating point type");

        pixel<T, 3> result;
        color_space::rgb_to_ycbcr(data[0], data[1], data[2],
                                 result.data[0], result.data[1], result.data[2]);
        return result;
    }

    /**
     * @brief 将YCbCr像素转换为RGB像素
     *
     * 要求像素至少有3个通道
     *
     * @return pixel<T, 3> RGB像素
     */
    pixel<T, 3> from_ycbcr() const {
        static_assert(N >= 3, "YCbCr to RGB conversion requires at least 3 channels");
        static_assert(std::is_floating_point_v<T>, "YCbCr to RGB conversion requires floating point type");

        pixel<T, 3> result;
        color_space::ycbcr_to_rgb(data[0], data[1], data[2],
                                 result.data[0], result.data[1], result.data[2]);
        return result;
    }

    /**
     * @brief 将RGB像素转换为XYZ像素
     *
     * 要求像素至少有3个通道
     *
     * @return pixel<T, 3> XYZ像素
     */
    pixel<T, 3> to_xyz() const {
        static_assert(N >= 3, "RGB to XYZ conversion requires at least 3 channels");
        static_assert(std::is_floating_point_v<T>, "RGB to XYZ conversion requires floating point type");

        pixel<T, 3> result;
        color_space::rgb_to_xyz(data[0], data[1], data[2],
                               result.data[0], result.data[1], result.data[2]);
        return result;
    }

    /**
     * @brief 将XYZ像素转换为RGB像素
     *
     * 要求像素至少有3个通道
     *
     * @return pixel<T, 3> RGB像素
     */
    pixel<T, 3> from_xyz() const {
        static_assert(N >= 3, "XYZ to RGB conversion requires at least 3 channels");
        static_assert(std::is_floating_point_v<T>, "XYZ to RGB conversion requires floating point type");

        pixel<T, 3> result;
        color_space::xyz_to_rgb(data[0], data[1], data[2],
                               result.data[0], result.data[1], result.data[2]);
        return result;
    }

    /**
     * @brief 将XYZ像素转换为LAB像素
     *
     * 要求像素至少有3个通道
     *
     * @return pixel<T, 3> LAB像素
     */
    pixel<T, 3> xyz_to_lab() const {
        static_assert(N >= 3, "XYZ to LAB conversion requires at least 3 channels");
        static_assert(std::is_floating_point_v<T>, "XYZ to LAB conversion requires floating point type");

        pixel<T, 3> result;
        color_space::xyz_to_lab(data[0], data[1], data[2],
                               result.data[0], result.data[1], result.data[2]);
        return result;
    }

    /**
     * @brief 将LAB像素转换为XYZ像素
     *
     * 要求像素至少有3个通道
     *
     * @return pixel<T, 3> XYZ像素
     */
    pixel<T, 3> lab_to_xyz() const {
        static_assert(N >= 3, "LAB to XYZ conversion requires at least 3 channels");
        static_assert(std::is_floating_point_v<T>, "LAB to XYZ conversion requires floating point type");

        pixel<T, 3> result;
        color_space::lab_to_xyz(data[0], data[1], data[2],
                               result.data[0], result.data[1], result.data[2]);
        return result;
    }

    /**
     * @brief 将RGB像素转换为LAB像素
     *
     * 要求像素至少有3个通道
     *
     * @return pixel<T, 3> LAB像素
     */
    pixel<T, 3> to_lab() const {
        static_assert(N >= 3, "RGB to LAB conversion requires at least 3 channels");
        static_assert(std::is_floating_point_v<T>, "RGB to LAB conversion requires floating point type");

        return to_xyz().xyz_to_lab();
    }

    /**
     * @brief 将LAB像素转换为RGB像素
     *
     * 要求像素至少有3个通道
     *
     * @return pixel<T, 3> RGB像素
     */
    pixel<T, 3> from_lab() const {
        static_assert(N >= 3, "LAB to RGB conversion requires at least 3 channels");
        static_assert(std::is_floating_point_v<T>, "LAB to RGB conversion requires floating point type");

        return lab_to_xyz().from_xyz();
    }

    /**
     * @brief 将RGB像素转换为CMYK像素
     *
     * 要求像素至少有3个通道
     *
     * @return pixel<T, 4> CMYK像素
     */
    pixel<T, 4> to_cmyk() const {
        static_assert(N >= 3, "RGB to CMYK conversion requires at least 3 channels");
        static_assert(std::is_floating_point_v<T>, "RGB to CMYK conversion requires floating point type");

        pixel<T, 4> result;
        color_space::rgb_to_cmyk(data[0],
                                 data[1],
                                 data[2],
                                 result.data[0],
                                 result.data[1],
                                 result.data[2],
                                 result.data[3]);
        return result;
    }

    /**
     * @brief 将CMYK像素转换为RGB像素
     *
     * 要求像素至少有4个通道
     *
     * @return pixel<T, 3> RGB像素
     */
    pixel<T, 3> from_cmyk() const {
        static_assert(N >= 4, "CMYK to RGB conversion requires at least 4 channels");
        static_assert(std::is_floating_point_v<T>, "CMYK to RGB conversion requires floating point type");

        pixel<T, 3> result;
        color_space::cmyk_to_rgb(data[0], data[1], data[2], data[3], result.data[0], result.data[1], result.data[2]);
        return result;
    }

    /**
     * @brief 将sRGB转换为线性RGB
     *
     * 逐通道应用sRGB到线性RGB的转换
     *
     * @return pixel<T, N> 线性RGB像素
     */
    pixel to_linear() const {
        static_assert(std::is_floating_point_v<T>, "sRGB to Linear conversion requires floating point type");

        pixel<T, N> result;
        for (int i = 0; i < N; ++i) {
            result.data[i] = color_space::srgb_to_linear(data[i]);
        }
        return result;
    }

    /**
     * @brief 将线性RGB转换为sRGB
     *
     * 逐通道应用线性RGB到sRGB的转换
     *
     * @return pixel<T, N> sRGB像素
     */
    pixel to_srgb() const {
        static_assert(std::is_floating_point_v<T>, "Linear to sRGB conversion requires floating point type");

        pixel<T, N> result;
        for (int i = 0; i < N; ++i) {
            result.data[i] = color_space::linear_to_srgb(data[i]);
        }
        return result;
    }

    /**
     * @brief 获取与sg_pixel_format相匹配的格式
     *
     * @return sg_pixel_format 匹配的像素格式
     */
    static sg_pixel_format get_format() {
        // 根据模板参数T和N确定对应的sg_pixel_format
        if constexpr (std::is_same_v<T, uint8_t>) {
            if constexpr (N == 1) return SG_PIXELFORMAT_R8;
            if constexpr (N == 2) return SG_PIXELFORMAT_RG8;
            if constexpr (N == 3) return SG_PIXELFORMAT_RGBA8; // 没有RGB8格式，使用RGBA8
            if constexpr (N == 4) return SG_PIXELFORMAT_RGBA8;
        }
        else if constexpr (std::is_same_v<T, int8_t>) {
            if constexpr (N == 1) return SG_PIXELFORMAT_R8SN;
            if constexpr (N == 2) return SG_PIXELFORMAT_RG8SN;
            if constexpr (N == 4) return SG_PIXELFORMAT_RGBA8SN;
        }
        else if constexpr (std::is_same_v<T, uint16_t>) {
            if constexpr (N == 1) return SG_PIXELFORMAT_R16;
            if constexpr (N == 2) return SG_PIXELFORMAT_RG16;
            if constexpr (N == 4) return SG_PIXELFORMAT_RGBA16;
        }
        else if constexpr (std::is_same_v<T, int16_t>) {
            if constexpr (N == 1) return SG_PIXELFORMAT_R16SN;
            if constexpr (N == 2) return SG_PIXELFORMAT_RG16SN;
            if constexpr (N == 4) return SG_PIXELFORMAT_RGBA16SN;
        }
        else if constexpr (std::is_same_v<T, Eigen::half>) {
            if constexpr (N == 1) return SG_PIXELFORMAT_R16F;
            if constexpr (N == 2) return SG_PIXELFORMAT_RG16F;
            if constexpr (N == 4) return SG_PIXELFORMAT_RGBA16F;
        }
        else if constexpr (std::is_same_v<T, float>) {
            if constexpr (N == 1) return SG_PIXELFORMAT_R32F;
            if constexpr (N == 2) return SG_PIXELFORMAT_RG32F;
            if constexpr (N == 4) return SG_PIXELFORMAT_RGBA32F;
        }
        else if constexpr (std::is_same_v<T, uint32_t>) {
            if constexpr (N == 1) return SG_PIXELFORMAT_R32UI;
            if constexpr (N == 2) return SG_PIXELFORMAT_RG32UI;
            if constexpr (N == 4) return SG_PIXELFORMAT_RGBA32UI;
        }
        else if constexpr (std::is_same_v<T, int32_t>) {
            if constexpr (N == 1) return SG_PIXELFORMAT_R32SI;
            if constexpr (N == 2) return SG_PIXELFORMAT_RG32SI;
            if constexpr (N == 4) return SG_PIXELFORMAT_RGBA32SI;
        }

        // 默认情况
        return SG_PIXELFORMAT_NONE;
    }
};

struct image_accessor_interface {
	virtual ~image_accessor_interface() = default;

	virtual void* get_data() = 0;
	virtual const void* get_data() const = 0;
	virtual int get_width() const = 0;
	virtual int get_height() const = 0;
	virtual uint64_t get_row_pitch() const = 0;
	virtual sg_pixel_format get_pixel_format() const = 0;
};

/**
 * @brief 图像访问器
 *
 * 提供对二维像素数组的访问和操作功能
 *
 * @tparam P 像素类型
 */
template<typename P>
struct image_accessor : image_accessor_interface {
    using pixel_type = typename P::pixel_type;
    using value_type = P;

    /**
     * @brief 构造函数
     *
     * @param in_data 图像数据指针
     * @param in_width 图像宽度
     * @param in_height 图像高度
     */
    image_accessor(void* in_data, const int in_width, const int in_height)
            : data(in_data), width(in_width), height(in_height), row_pitch(in_width * sizeof(P)) {}

    /**
     * @brief 使用Eigen向量指定尺寸的构造函数
     *
     * @tparam T Eigen向量的元素类型
     * @param in_data 图像数据指针
     * @param in_size 图像尺寸 (width, height)
     */
    template<typename T>
    image_accessor(void* in_data, const Eigen::Vector2<T>& in_size)
        : data(in_data), width(static_cast<int>(in_size.x())), height(static_cast<int>(in_size.y())),
          row_pitch(static_cast<uint64_t>(in_size.x() * sizeof(P))) {
    }

    /**
     * @brief 将另一个图像复制到此图像
     *
     * 复制区域大小为两个图像尺寸的最小值
     *
     * @tparam T 源像素类型
     * @param rhs 源图像
     */
    template<typename T>
    void copy_from(const image_accessor<T>& rhs) {
        const int temp_width = std::min(width, rhs.width);
        const int temp_height = std::min(height, rhs.height);

        // 当源和目标是相同类型时，可以使用内存拷贝优化
        if constexpr (std::is_same_v<P, T>) {
            auto row_size = temp_width * sizeof(P);
            for (int y = 0; y < temp_height; ++y) {
                auto src_row = rhs.get_row(y);
                auto dst_row = get_row(y);
                std::memcpy(dst_row, src_row, row_size); // 从src_row拷贝，而不是data
            }
        }
        else {
            // 不同类型的像素需要逐个转换
            for (int y = 0; y < temp_height; ++y) {
                for (int x = 0; x < temp_width; ++x) {
                    get_pixel(x, y) = color_convert<T, P>(rhs.get_pixel(x, y));
                }
            }
        }
    }

    /**
     * @brief 将另一个图像的指定区域复制到此图像
     *
     * @tparam T 源像素类型
     * @param rhs 源图像
     * @param rhs_pos 源图像的起始位置 (x, y)
     */
    template<typename T>
    void copy_from(const image_accessor<T>& rhs, const Eigen::Vector2i& rhs_pos) {
        // 确保不会超出源图像边界
        const int temp_width = std::min(width, rhs.width - rhs_pos.x());
        const int temp_height = std::min(height, rhs.height - rhs_pos.y());

        // 检查边界条件
        if (temp_width <= 0 || temp_height <= 0) {
            return; // 没有有效的重叠区域
        }

        for (int y = 0; y < temp_height; ++y) {
            for (int x = 0; x < temp_width; ++x) {
                get_pixel(x, y) = color_convert<T, P>(rhs.get_pixel(x + rhs_pos.x(), y + rhs_pos.y()));
            }
        }
    }

    /**
     * @brief 将另一个图像复制到此图像的指定位置
     *
     * @tparam T 源像素类型
     * @param rhs 源图像
     * @param in_start 目标图像的起始位置 (x, y)
     */
    template<typename T>
    void offset_copy_from(const image_accessor<T>& rhs, const Eigen::Vector2i& in_start) {
        // 确保不会超出目标图像边界
        const int temp_width = std::min(width - in_start.x(), rhs.width);
        const int temp_height = std::min(height - in_start.y(), rhs.height);

        // 检查边界条件
        if (temp_width <= 0 || temp_height <= 0) {
            return; // 没有有效的重叠区域
        }

        // 当源和目标是相同类型时，可以使用内存拷贝优化
        if constexpr (std::is_same_v<P, T>) {
            for (int y = 0; y < temp_height; ++y) {
                auto src_row = rhs.get_row(y);
                auto dst_row = get_row(y + in_start.y()) + in_start.x() * sizeof(P);
                std::memcpy(dst_row, src_row, static_cast<size_t>(temp_width * sizeof(P)));
            }
        }
        else {
            // 不同类型的像素需要逐个转换
            for (int y = 0; y < temp_height; ++y) {
                for (int x = 0; x < temp_width; ++x) {
                    get_pixel(x + in_start.x(), y + in_start.y()) = color_convert<T, P>(rhs.get_pixel(x, y));
                }
            }
        }
    }

    /**
     * @brief 获取指定位置的像素
     *
     * @param x X坐标
     * @param y Y坐标
     * @return P& 像素引用
     * @throws std::out_of_range 如果坐标超出图像范围
     */
    P& get_pixel(const int x, const int y) {
        if (x < 0 || x >= width || y < 0 || y >= height) {
        	// 超出图像范围
            throw std::out_of_range("Pixel access out of bounds.");
        }
        const int pixel_size = sizeof(P);
        const int offset = y * static_cast<int>(row_pitch) + x * pixel_size;
        auto data_ptr = static_cast<uint8_t*>(data) + offset;

        return *reinterpret_cast<P*>(data_ptr);
    }

    /**
     * @brief 获取指定位置的像素（const版本）
     *
     * @param x X坐标
     * @param y Y坐标
     * @return const P& 像素的常量引用
     * @throws std::out_of_range 如果坐标超出图像范围
     */
    const P& get_pixel(const int x, const int y) const {
        return const_cast<image_accessor*>(this)->get_pixel(x, y);
    }

    /**
     * @brief 通过操作符()访问像素
     *
     * @param x X坐标
     * @param y Y坐标
     * @return P& 像素引用
     */
    P& operator()(const int x, const int y) {
        return get_pixel(x, y);
    }

    /**
     * @brief 通过操作符()访问像素（const版本）
     *
     * @param x X坐标
     * @param y Y坐标
     * @return const P& 像素的常量引用
     */
    const P& operator()(const int x, const int y) const {
        return get_pixel(x, y);
    }

    /**
     * @brief 通过Eigen向量访问像素
     *
     * @param pos 位置向量 (x, y)
     * @return P& 像素引用
     */
    P& operator()(const Eigen::Vector2i& pos) {
        return get_pixel(pos.x(), pos.y());
    }

    /**
     * @brief 通过Eigen向量访问像素（const版本）
     *
     * @param pos 位置向量 (x, y)
     * @return const P& 像素的常量引用
     */
    const P& operator()(const Eigen::Vector2i& pos) const {
        return get_pixel(pos.x(), pos.y());
    }

    /**
     * @brief 设置行跨度
     *
     * 允许设置自定义的行跨度以支持内存对齐需求
     *
     * @param in_row_pitch 新的行跨度（必须大于等于 width * sizeof(P)）
     */
    void set_row_pitch(const uint64_t in_row_pitch) {
        assert(in_row_pitch >= static_cast<uint64_t>(width * sizeof(P)));
        row_pitch = in_row_pitch;
    }

    /**
     * @brief 垂直翻转图像
     *
     * 将图像沿水平轴翻转
     */
    void flip_y() {
        std::vector<uint8_t> temp_row(row_pitch);  // 临时存储一行数据

        for (int y = 0; y < height / 2; ++y) {
            // 计算要交换的两行的起始地址
            uint8_t* top_row = static_cast<uint8_t*>(data) + y * row_pitch;
            uint8_t* bottom_row = static_cast<uint8_t*>(data) + (height - 1 - y) * row_pitch;

            // 交换两行数据
            std::memcpy(temp_row.data(), top_row, row_pitch);    // 将 top_row 保存到临时缓冲区
            std::memcpy(top_row, bottom_row, row_pitch);         // 将 bottom_row 移动到 top_row
            std::memcpy(bottom_row, temp_row.data(), row_pitch); // 将临时缓冲区的数据移动到 bottom_row
        }
    }

	virtual const void* get_data() const override {
	    return data;
    }
	virtual void* get_data() override {
	    return data;
    }
	virtual int get_width() const override {
	    return width;
    }
	virtual int get_height() const override {
	    return height;
    }
	virtual uint64_t get_row_pitch() const override {
	    return row_pitch;
    }
	virtual sg_pixel_format get_pixel_format() const override {
	    return P::get_format();
    }

    void* const data;        // 图像数据指针
    const int width;         // 图像宽度
    const int height;        // 图像高度
    uint64_t row_pitch;      // 行跨度，支持内存对齐

private:
    /**
     * @brief 获取指定行的起始地址
     *
     * @param y 行索引
     * @return uint8_t* 行起始地址
     */
    [[nodiscard]] uint8_t* get_row(const int y) const {
        return static_cast<uint8_t*>(data) + y * row_pitch;
    }
};

// 预定义的常用像素类型

// 8位整数类型
using pixel_r8 = pixel<uint8_t, 1>;     // 单通道 8位 (对应 SG_PIXELFORMAT_R8)
using pixel_rg8 = pixel<uint8_t, 2>;    // 双通道 8位 (对应 SG_PIXELFORMAT_RG8)
using pixel_rgb8 = pixel<uint8_t, 3>;   // 三通道 8位 (无直接对应格式)
using pixel_rgba8 = pixel<uint8_t, 4>;  // 四通道 8位 (对应 SG_PIXELFORMAT_RGBA8)
using pixel_a8 = pixel<uint8_t, 1>;     // 单通道 8位 (等同于 pixel_r8)

// 16位整数类型
using pixel_r16 = pixel<uint16_t, 1>;    // 单通道 16位 (对应 SG_PIXELFORMAT_R16)
using pixel_rg16 = pixel<uint16_t, 2>;   // 双通道 16位 (对应 SG_PIXELFORMAT_RG16)
using pixel_rgb16 = pixel<uint16_t, 3>;  // 三通道 16位 (无直接对应格式)
using pixel_rgba16 = pixel<uint16_t, 4>; // 四通道 16位 (对应 SG_PIXELFORMAT_RGBA16)
using pixel_a16 = pixel<uint16_t, 1>;    // 单通道 16位 (等同于 pixel_r16)

// 16位半精度浮点类型
using pixel_r16f = pixel<Eigen::half, 1>;    // 单通道 16位浮点 (对应 SG_PIXELFORMAT_R16F)
using pixel_rg16f = pixel<Eigen::half, 2>;   // 双通道 16位浮点 (对应 SG_PIXELFORMAT_RG16F)
using pixel_rgb16f = pixel<Eigen::half, 3>;  // 三通道 16位浮点 (无直接对应格式)
using pixel_rgba16f = pixel<Eigen::half, 4>; // 四通道 16位浮点 (对应 SG_PIXELFORMAT_RGBA16F)
using pixel_a16f = pixel<Eigen::half, 1>;    // 单通道 16位浮点 (等同于 pixel_r16f)

// 32位浮点类型
using pixel_r = pixel<float, 1>;     // 单通道 32位浮点 (对应 SG_PIXELFORMAT_R32F)
using pixel_rg = pixel<float, 2>;    // 双通道 32位浮点 (对应 SG_PIXELFORMAT_RG32F)
using pixel_rgb = pixel<float, 3>;   // 三通道 32位浮点 (无直接对应格式)
using pixel_rgba = pixel<float, 4>;  // 四通道 32位浮点 (对应 SG_PIXELFORMAT_RGBA32F)
using pixel_a = pixel<float, 1>;     // 单通道 32位浮点 (等同于 pixel_r)

// 8位有符号整数类型
using pixel_r8sn = pixel<int8_t, 1>;    // 单通道 8位有符号 (对应 SG_PIXELFORMAT_R8SN)
using pixel_rg8sn = pixel<int8_t, 2>;   // 双通道 8位有符号 (对应 SG_PIXELFORMAT_RG8SN)
using pixel_rgba8sn = pixel<int8_t, 4>; // 四通道 8位有符号 (对应 SG_PIXELFORMAT_RGBA8SN)

// 16位有符号整数类型
using pixel_r16sn = pixel<int16_t, 1>;    // 单通道 16位有符号 (对应 SG_PIXELFORMAT_R16SN)
using pixel_rg16sn = pixel<int16_t, 2>;   // 双通道 16位有符号 (对应 SG_PIXELFORMAT_RG16SN)
using pixel_rgba16sn = pixel<int16_t, 4>; // 四通道 16位有符号 (对应 SG_PIXELFORMAT_RGBA16SN)
