Який найкращий алгоритм зменшення масштабу зображення (якісно)?

Я хочу з'ясувати, який алгоритм найкращий, який можна використовувати для зменшення розміру растрової картинки. З найкращим я маю на увазі той, який дає найкращі результати. Я знаю про бікубік, але чи є щось краще ще? Наприклад, я чув від деяких людей, що Adobe Lightroom має якийсь власний алгоритм, який дає кращі результати, ніж стандартний бікубічний, який я використовував. На жаль, я хотів би сам використовувати цей алгоритм у своєму програмному забезпеченні, тому ретельно охороняється комерційна таємниця Adobe не допоможе.

Додано:

Я перевірив Paint.NET і, на мій подив, здається, що Super Sampling краще, ніж bicubic при зменшенні розміру зображення. Це змушує мене задуматись, чи не потрібні взагалі алгоритми інтерполяції.

Це також нагадало мені алгоритм, який я сам "винайшов", але ніколи не реалізовував. Я припускаю, що у нього також є назва (оскільки щось таке тривіальне не може бути ідеєю лише мене), але я не зміг знайти його серед популярних. Супер вибірка була найближчою.

Ідея полягає в наступному - для кожного пікселя в цільовому зображенні підрахуйте, де він знаходився б на вихідному зображенні. Ймовірно, він би накладав один або кілька інших пікселів. Тоді можна було б розрахувати площі та кольори цих пікселів. Потім, щоб отримати колір цільового пікселя, можна просто обчислити середнє значення цих кольорів, додавши їх площі як "ваги". Отже, якби цільовий піксель покривав 1/3 жовтого вихідного пікселя та 1/4 зеленого вихідного пікселя, я отримав би (1/3 * жовтий + 1/4 * зелений) / (1/3 + 1/4).

Це, природно, було б досить обчислювально, але воно повинно бути якомога ближче до ідеалу, ні?

Чи існує назва цього алгоритму?

На жаль, я не можу знайти посилання на оригінальне опитування, але, оскільки голлівудські кінематографісти переходили від фільму до цифрових зображень, цього питання виникало багато, тому хтось (можливо, SMPTE, можливо, ASC) зібрав купу професійних кінематографістів і показав їм кадри які були масштабовані за допомогою різних алгоритмів. Результати полягали в тому, що для цих професіоналів, які дивляться на величезні кінофільми, було консенсусом, що Мітчелл (також відомий як високоякісний Catmull-Rom) є найкращим для масштабування, а sinc - найкращим для зменшення. Але sinc - це теоретичний фільтр, який йде до нескінченності і, отже, не може бути повністю реалізований, тому я не знаю, що вони насправді мали на увазі під словом "sinc". Ймовірно, це стосується усіченої версії sinc. Ланцошє одним з декількох практичних варіантів sinc, який намагається покращити його просто скорочення, і є, мабуть, найкращим вибором за замовчуванням для масштабування нерухомих зображень. Але, як зазвичай, це залежить від зображення та того, що ви хочете: зменшення малюнка лінії для збереження ліній - це, наприклад, випадок, коли ви можете віддати перевагу акценту на збереженні країв, які були б небажаними при зменшенні фотографії квітів.

Є хороший приклад результатів різних алгоритмів у Кембриджі в кольорі .

Люди fxguide зібрали багато інформації про алгоритми масштабування (поряд з багатьма іншими матеріалами про композицію та іншу обробку зображень), на яку варто поглянути. Вони також включають тестові зображення, які можуть бути корисними для проведення власних тестів.

Тепер ImageMagick має великий посібник із передискретизації фільтрів, якщо ви дійсно хочете в нього потрапити.

Іронічно, що є більше суперечок щодо зменшення зображення, що теоретично можна зробити ідеально, оскільки ви лише викидаєте інформацію, ніж про масштабування, де ви намагаєтеся додати інформацію, яка не т існувати. Але починайте з Lanczos.

Існує дискретизація Ланцоша, яка є повільнішою, ніж бікубічна, але дає зображення вищої якості.

(Бі-) лінійна та (бі-) кубічна передискретизація є не просто потворною, але жахливо некоректною при зменшенні масштабу на коефіцієнт менше 1/2. Вони призведуть до дуже поганих псевдонімів, схожих на те, що ви отримаєте, якщо зменшите показник у 1/2 рази, а потім скористайтеся зниженням вибірки найближчого сусіда.

Особисто я б порекомендував (для області) вибірки усереднення для більшості завдань з зменшення вибірки. Це дуже просто, швидко і майже оптимально. Гауссова передискретизація (з радіусом, вибраним пропорційним зворотній величині коефіцієнта, наприклад, радіус 5 для зменшення дискретизації на 1/5), може дати кращі результати з трохи більшими накладними обчисленнями, і це більш математично обґрунтовано.

Однією з можливих причин використання гауссової передискретизації є те, що, на відміну від більшості інших алгоритмів, вона працює коректно (не вводить артефакти / псевдоніми) як для збільшення, так і для зменшення вибірки, якщо ви вибрали радіус, відповідний фактору передискретизації. В іншому випадку для підтримки обох напрямків вам потрібні два окремі алгоритми - усереднення площі для зменшення дискретизації (яке зменшиться до найближчого сусіда для передискретизації) і щось на зразок (дво-) кубічне для підвищення вибірки (яке зменшиться до найближчого сусіда для зменшення дискретизації). Одним із способів математичного бачення цієї приємної властивості гауссової передискретизації є те, що гауссовий з дуже великим радіусом наближається до усереднення за площею, а гауссовий з дуже малим радіусом апроксимується (бі-) лінійною інтерполяцією.

Я бачив статтю про Slashdot про Швейне різьблення деякий час тому, можливо, варто заглянути.

Вирізання шва - це алгоритм зміни розміру зображення, розроблений Шай Авіданом та Аріелем Шаміром. Цей алгоритм змінює розміри зображення не за допомогою масштабування або обрізання, а за допомогою розумного видалення пікселів із (або додавання пікселів до зображення), які не мають особливого значення.

Описаний вами алгоритм називається лінійною інтерполяцією і є одним із найшвидших алгоритмів, але не найкращий на зображеннях.

Чи існує назва цього алгоритму?

У літературі це може називатися передискретизацією "вікна" або "вікна". Це насправді менш обчислювально дорого, як ви думаєте.

Він також може бути використаний для створення проміжного растрового зображення, яке згодом використовується двокубічною інтерполяцією, щоб уникнути згладжування при зменшенні дискретизації більш ніж на 1/2.

Якщо комусь цікаво, ось моя реалізація алгоритму масштабування усереднення площ на C ++:

void area_averaging_image_scale(uint32_t *dst, int dst_width, int dst_height, const uint32_t *src, int src_width, int src_height)
{
    // 1. Scale horizontally (src -> mid)
    int mid_width  = dst_width,
        mid_height = src_height;
    float src_width_div_by_mid_width = float(src_width) / mid_width;
    float mid_width_div_by_src_width = 1.f / src_width_div_by_mid_width;
    std::vector<uint32_t> mid(mid_width * mid_height);
    for (int y=0; y<mid_height; y++)
        for (int x=0; x<mid_width; x++)
            for (int c=0; c<4; c++) {
                float f = x * src_width_div_by_mid_width;
                int i = int(f);
                float d = ((uint8_t*)&src[i + y*src_width])[c] * (float(i) + 1 - f);
                float end = f + src_width_div_by_mid_width;
                int endi = int(end);
                if (end - float(endi) > 1e-4f) {
                    assert(endi < src_width);
                    d += ((uint8_t*)&src[endi + y*src_width])[c] * (end - float(endi));
                }
                for (i++; i < endi; i++)
                    d += ((uint8_t*)&src[i + y*src_width])[c];
                int r = int(d * mid_width_div_by_src_width + 0.5f);
                assert(r <= 255);
                ((uint8_t*)&mid[x + y*mid_width])[c] = r;
            }

    // 2. Scale vertically (mid -> dst)
    float mid_height_div_by_dst_height = float(mid_height) / dst_height;
    float dst_height_div_by_mid_height = 1.f / mid_height_div_by_dst_height;
    for (int y=0; y<dst_height; y++)
        for (int x=0; x<dst_width; x++)
            for (int c=0; c<4; c++) {
                float f = y * mid_height_div_by_dst_height;
                int i = int(f);
                float d = ((uint8_t*)&mid[x + i*mid_width])[c] * (float(i) + 1 - f);
                float end = f + mid_height_div_by_dst_height;
                int endi = int(end);
                if (end - float(endi) > 1e-4f) {
                    assert(endi < mid_height);
                    d += ((uint8_t*)&mid[x + endi*mid_width])[c] * (end - float(endi));
                }
                for (i++; i < endi; i++)
                    d += ((uint8_t*)&mid[x + i*mid_width])[c];
                int r = int(d * dst_height_div_by_mid_height + 0.5f);
                assert(r <= 255);
                ((uint8_t*)&dst[x + y*dst_width])[c] = r;
            }
}