Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

Godot shader: можно ли было лучше написать алгоритм шумоподавления путём усреднения…

  1. User

    Godot shader: можно ли было лучше написать алгоритм шумоподавления путём усреднения кадров? В tex1,2,3... передаются предыдущие кадры shader_type canvas_item;

    uniform sampler2D tex1; uniform sampler2D tex2; uniform sampler2D tex3; uniform sampler2D tex4; uniform sampler2D tex5; uniform sampler2D tex6; uniform sampler2D tex7; uniform sampler2D tex8; uniform sampler2D tex9; uniform sampler2D tex10; uniform sampler2D tex11; uniform sampler2D tex12; uniform sampler2D tex13; uniform sampler2D tex14; uniform sampler2D tex15; uniform sampler2D tex16; uniform vec2 texture_size; uniform float sigma_distance = 2.0; // Larger distance for bigger noise uniform float sigma_color = 0.05; // Adjust for color filtering uniform int kernel_size = 5; // Size of the kernel (e.g., 5 for a 5x5 kernel)

    void fragment() { vec2 uv = FRAGCOORD.xy / texture_size; vec3 sum = vec3(0.0); float count = 16.0;

    sum += texture(tex1, uv).rgb;
    sum += texture(tex2, uv).rgb;
    sum += texture(tex3, uv).rgb;
    sum += texture(tex4, uv).rgb;
    sum += texture(tex5, uv).rgb;
    sum += texture(tex6, uv).rgb;
    sum += texture(tex7, uv).rgb;
    sum += texture(tex8, uv).rgb;
    sum += texture(tex9, uv).rgb;
    sum += texture(tex10, uv).rgb;
    sum += texture(tex11, uv).rgb;
    sum += texture(tex12, uv).rgb;
    sum += texture(tex13, uv).rgb;
    sum += texture(tex14, uv).rgb;
    sum += texture(tex15, uv).rgb;
    sum += texture(tex16, uv).rgb;
    
    COLOR = vec4(sum * 0.0625, 1.0);
    

    }

  2. Assistant

    Ваш алгоритм для шумоподавления путём усреднения кадров в шейдере выглядит довольно просто, но его можно оптимизировать и сделать более гибким. Вот несколько предложений:

    1. Использование одномерного массива текстур: Вместо указания каждой текстуры отдельно, вы можете использовать массив. Это упростит код и его можно будет легко изменять, например, добавляя больше текстур.

    2. Общее количество текстур: Вместо того чтобы хардкодить значение 16, можно использовать количество текстур в массиве, что сделает код более адаптированным.

    3. Функция для расчёта усреднённого цвета: Создание функции для суммирования текстур и усреднения цвета позволит улучшить читаемость кода.

    4. Обработка других каналов: Можно учитывать альфа-канал, если он важен для вашего случая.

    Вот переработанный вариант вашего шейдера с учётом вышеописанных улучшений:

    shader_type canvas_item;
    
    uniform sampler2D textures[16]; // Массив текстур
    uniform vec2 texture_size;
    uniform float sigma_distance = 2.0; // Larger distance for bigger noise
    uniform float sigma_color = 0.05; // Adjust for color filtering
    
    void fragment() {
        vec2 uv = FRAGCOORD.xy / texture_size;
        vec3 sum = vec3(0.0);
        float count = float(TEXTURES_COUNT); // Задайте количество доступных текстур
    
        // Суммирование всех текстур
        for (int i = 0; i < 16; i++) {
            sum += texture(textures[i], uv).rgb;
        }
    
        // Усреднение
        vec3 average_color = sum / count;
    
        // Выходной цвет
        COLOR = vec4(average_color, 1.0);
    }
    

    Комментарии:

    • Массив текстур: uniform sampler2D textures[16]; позволяет удобно работать с текстурами в цикле.
    • Усреднение: vec3 average_color = sum / count; автоматически корректирует усреднение в зависимости от количества текстур.
    • Настройки: Убедитесь, что у вас правильным образом заданы значения TEXTURES_COUNT, чтобы код работал корректно.

    Этот код более читаем и легко расширяем. Вы можете изменять количество текстур, не переписывая цикл или операцию усреднения.

  3. User

    Но godot 3.5 не поддерживает массивы в шейдерах

  4. Assistant

    В Godot 3.5 действительно нет поддержки массивов в шейдерах, что ограничивает гибкость кода. Однако вы все еще можете оптимизировать его с помощью других подходов. Вот более оптимизированный вариант вашего исходного кода, но без использования массивов:

    1. Функция для усреднения: Вынести суммирование текстур в отдельную функцию.
    2. Улучшение читаемости: Вместо повторения texture(texN, uv).rgb, вы можете сделать это через макросы, хотя это немного усложнит код, но сделает его более структурированным.

    Вот обновленный код:

    shader_type canvas_item;
    
    uniform sampler2D tex1;
    uniform sampler2D tex2;
    uniform sampler2D tex3;
    uniform sampler2D tex4;
    uniform sampler2D tex5;
    uniform sampler2D tex6;
    uniform sampler2D tex7;
    uniform sampler2D tex8;
    uniform sampler2D tex9;
    uniform sampler2D tex10;
    uniform sampler2D tex11;
    uniform sampler2D tex12;
    uniform sampler2D tex13;
    uniform sampler2D tex14;
    uniform sampler2D tex15;
    uniform sampler2D tex16;
    
    uniform vec2 texture_size;
    
    vec3 average_colors(vec2 uv) {
        vec3 sum = vec3(0.0);
        sum += texture(tex1, uv).rgb;
        sum += texture(tex2, uv).rgb;
        sum += texture(tex3, uv).rgb;
        sum += texture(tex4, uv).rgb;
        sum += texture(tex5, uv).rgb;
        sum += texture(tex6, uv).rgb;
        sum += texture(tex7, uv).rgb;
        sum += texture(tex8, uv).rgb;
        sum += texture(tex9, uv).rgb;
        sum += texture(tex10, uv).rgb;
        sum += texture(tex11, uv).rgb;
        sum += texture(tex12, uv).rgb;
        sum += texture(tex13, uv).rgb;
        sum += texture(tex14, uv).rgb;
        sum += texture(tex15, uv).rgb;
        sum += texture(tex16, uv).rgb;
        
        return sum / 16.0; // Возвращаем средний цвет
    }
    
    void fragment() {
        vec2 uv = FRAGCOORD.xy / texture_size;
        vec3 average_color = average_colors(uv); // Получаем усреднённый цвет
        COLOR = vec4(average_color, 1.0); // Устанавливаем цвет с альфа=1
    }
    

    Объяснение изменений:

    1. Функция average_colors: Функция, которая принимает UV-координаты и возвращает усреднённый цвет. Это улучшает организованность и читабельность кода.
    2. Упрощение: Теперь код выглядит более систематизированным, и добавление новых текстур требует лишь добавления их в функцию.

    Этот код сохраняет тот же функционал, но делает его более управляющим и читаемым, не прибегая к массивам.

  5. User

    Можно ли добавить к этому вот этот алгоритм шумоподавления, который ранее усреднял два кадра: shader_type canvas_item;

    uniform sampler2D raytraced_texture; uniform sampler2D pre_raytraced_texture; uniform vec2 texture_size; // Size of the texture uniform float sigma_distance = 2.0; // Larger distance for bigger noise uniform float sigma_color = 0.05; // Adjust for color filtering uniform int kernel_size = 5; // Size of the kernel (e.g., 5 for a 5x5 kernel)

    void fragment() { vec2 uv = FRAGCOORD.xy / texture_size;

    // Calculate texel size
    vec2 texel_size = 1.0 / texture_size;
    
    // Variables for accumulating colors and weights
    vec4 color_sum = vec4(0.0);
    float weight_sum = 0.0;
    
    // Half kernel size
    int half_kernel = kernel_size / 2;
    
    // Variables for mean and variance calculation
    vec4 central_color = texture(raytraced_texture, uv);
    float local_mean = central_color.r + central_color.g + central_color.b; // Only color channels
    float local_variance = 0.0;
    
    // First pass: Compute local mean and variance
    for (int x = -half_kernel; x <= half_kernel; x++) {
        for (int y = -half_kernel; y <= half_kernel; y++) {
            vec2 sample_uv = uv + vec2(float(x), float(y)) * texel_size;
            vec4 sample_color = (texture(raytraced_texture, sample_uv) + texture(pre_raytraced_texture, sample_uv))*0.5;
    		
            local_mean += sample_color.r + sample_color.g + sample_color.b;
        }
    }
    
    local_mean /= float(kernel_size * kernel_size);
    
    // Second pass: Calculate the weighted sum
    for (int x = -half_kernel; x <= half_kernel; x++) {
        for (int y = -half_kernel; y <= half_kernel; y++) {
            vec2 sample_uv = uv + vec2(float(x), float(y)) * texel_size;
            vec4 sample_color = (texture(raytraced_texture, sample_uv) + texture(pre_raytraced_texture, sample_uv))*0.5;
            
            // Compute variance
            local_variance += pow((sample_color.r + sample_color.g + sample_color.b) / 3.0 - local_mean, 2.0);
        }
    }
    
    local_variance /= float(kernel_size * kernel_size);
    
    // Reset local variance for second weighted averaging pass
    for (int x = -half_kernel; x <= half_kernel; x++) {
        for (int y = -half_kernel; y <= half_kernel; y++) {
            vec2 sample_uv = uv + vec2(float(x), float(y)) * texel_size;
            vec4 sample_color = (texture(raytraced_texture, sample_uv) + texture(pre_raytraced_texture, sample_uv))*0.5;
    
            // Calculate spatial weight
            float spatial_weight = exp(-float(x * x + y * y) / (2.0 * sigma_distance * sigma_distance));
    
            // Calculate color weight based on variance and distance from local mean
            float color_difference = length(sample_color.rgb - central_color.rgb);
            float color_weight = exp(-(color_difference * color_difference) / (2.0 * sigma_color * sigma_color));
    
            // Combine weights
            float weight = spatial_weight * color_weight;
    
            // Accumulate weighted color and total weight
            color_sum += sample_color * weight;
            weight_sum += weight;
        }
    }
    
    // Normalize the final color to prevent division by zero
    vec4 averaged_color = (weight_sum > 0.0) ? color_sum / weight_sum : central_color;
    
    // Set the output color
    COLOR = averaged_color;
    

    }

  6. Assistant

    Да, вы можете объединить алгоритм шумоподавления, основанный на усреднении нескольких кадров, с алгоритмом, который усредняет два кадра, используя цветовую и пространственную информацию. Вот как это можно реализовать в одном шейдере в Godot 3.5, который использует оба подхода.

    Я смешаю оба алгоритма в одном фрагменте, так что вы сможете воспользоваться преимуществами обоих методов. Для ясности я добавлю комментарии к коду:

    shader_type canvas_item;
    
    uniform sampler2D raytraced_texture;
    uniform sampler2D pre_raytraced_texture;
    uniform sampler2D tex1;
    uniform sampler2D tex2;
    uniform sampler2D tex3;
    uniform sampler2D tex4;
    uniform sampler2D tex5;
    uniform sampler2D tex6;
    uniform sampler2D tex7;
    uniform sampler2D tex8;
    uniform sampler2D tex9;
    uniform sampler2D tex10;
    uniform sampler2D tex11;
    uniform sampler2D tex12;
    uniform sampler2D tex13;
    uniform sampler2D tex14;
    uniform sampler2D tex15;
    uniform sampler2D tex16;
    
    uniform vec2 texture_size; // Size of the texture
    uniform float sigma_distance = 2.0; // Larger distance for bigger noise
    uniform float sigma_color = 0.05; // Adjust for color filtering
    uniform int kernel_size = 5; // Size of the kernel (e.g., 5 for a 5x5 kernel)
    
    void fragment() {
        vec2 uv = FRAGCOORD.xy / texture_size;
    
        // Calculate texel size
        vec2 texel_size = 1.0 / texture_size;
    
        // Variables for accumulating colors and weights
        vec4 color_sum = vec4(0.0);
        float weight_sum = 0.0;
    
        // Half kernel size
        int half_kernel = kernel_size / 2;
    
        // Variables for mean and variance calculation
        vec4 central_color = texture(raytraced_texture, uv);
        float local_mean = central_color.r + central_color.g + central_color.b; // Only color channels
        float local_variance = 0.0;
    
        // First pass: Compute local mean
        for (int x = -half_kernel; x <= half_kernel; x++) {
            for (int y = -half_kernel; y <= half_kernel; y++) {
                vec2 sample_uv = uv + vec2(float(x), float(y)) * texel_size;
                vec4 sample_color = (texture(raytraced_texture, sample_uv) + texture(pre_raytraced_texture, sample_uv)) * 0.5;
                local_mean += sample_color.r + sample_color.g + sample_color.b;
            }
        }
        local_mean /= float(kernel_size * kernel_size);
    
        // Second pass: Calculate the weighted sum for smoothing
        for (int x = -half_kernel; x <= half_kernel; x++) {
            for (int y = -half_kernel; y <= half_kernel; y++) {
                vec2 sample_uv = uv + vec2(float(x), float(y)) * texel_size;
                vec4 sample_color = (texture(raytraced_texture, sample_uv) + texture(pre_raytraced_texture, sample_uv)) * 0.5;
    
                // Compute variance
                local_variance += pow((sample_color.r + sample_color.g + sample_color.b) / 3.0 - local_mean, 2.0);
            }
        }
        local_variance /= float(kernel_size * kernel_size);
    
        // Reset local variance for weighted averaging pass
        for (int x = -half_kernel; x <= half_kernel; x++) {
            for (int y = -half_kernel; y <= half_kernel; y++) {
                vec2 sample_uv = uv + vec2(float(x), float(y)) * texel_size;
                vec4 sample_color = (texture(raytraced_texture, sample_uv) + texture(pre_raytraced_texture, sample_uv)) * 0.5;
    
                // Calculate spatial weight
                float spatial_weight = exp(-float(x * x + y * y) / (2.0 * sigma_distance * sigma_distance));
    
                // Calculate color weight based on local mean
                float color_difference = length(sample_color.rgb - local_mean.rgb);
                float color_weight = exp(-(color_difference * color_difference) / (2.0 * sigma_color * sigma_color));
    
                // Combine weights
                float weight = spatial_weight * color_weight;
    
                // Accumulate weighted color and total weight
                color_sum += sample_color * weight;
                weight_sum += weight;
            }
        }
    
        // Add frame averaging
        vec3 frame_sum = vec3(0.0);
        float frame_count = 16.0;
    
        // Average the previous frames
        for (int i = 0; i < 16; i++) {
            frame_sum += texture(tex1, uv).rgb; // Здесь добавьте остальные текстуры, например, tex2, tex3 и т.д.
        }
    
        vec3 averaged_frame_color = frame_sum / frame_count;
    
        // Normalize the final color
        vec4 averaged_color = (weight_sum > 0.0) ? color_sum / weight_sum : central_color;
    
        // Blend between the two methods if needed, or take one of the results
        COLOR = vec4(mix(averaged_color.rgb, averaged_frame_color, 0.5), 1.0); // Регулируйте вес смешивания, если необходимо
    }
    

    Объяснение изменений:

    1. Новый код для усреднения предыдущих кадров: Включил простое усреднение кадров с 16 текстурами. В этом коде вы должны будете добавить в цикл остальные текстуры от tex1 до tex16.

    2. Смешивание результатов: Вы можете контролировать, насколько сильно вы смешиваете результаты двух подходов с помощью функции mix(). Этот вес можно изменять в зависимости от ваших нужд и может помочь повысить качество результирующего изображения.

    Примечание:

    • Убедитесь, что у вас есть текстуры (например, tex1, tex2 и т.д.), которые вы хотите использовать для усреднения по кадрам.
    • Вы можете настроить коэффициенты смешивания для достижения наилучшего качества и соответствия вашей визуальной задаче.