Farbtransformation: Suche nach Ausdünnungstabellen

Dies ist eine Übersicht über die in Pillow 5.2 eingeführten Funktionen : Verwendung dreidimensionaler Nachschlagetabellen (3D-LUTs) für die Farbtransformation. Diese Technik ist in der Videoverarbeitung und in 3D-Spielen weit verbreitet, aber nur wenige Grafikbibliotheken konnten zuvor mit 3D-LUT-Transformationen aufwarten.

Dreidimensionale Nachschlagetabellen bieten eine große Flexibilität bei der Beschreibung von Farbtransformationen. Vor allem aber werden Transformationen zur gleichen Zeit ausgeführt, unabhängig davon, wie komplex sie sind.

from PIL import Image, ImageFilter

def washout(r, g, b):
    h, s, v = _rgb_to_hsv(r, g, b)
    if 0.3 < h < 0.7:
        s = 0
    return _hsv_to_rgb(h, s, v)

im = Image.open('./Puffins.jpg')
im = im.filter(ImageFilter.Color3DLUT.generate(17, washout))

Eine vollständig in Python geschriebene Funktion gilt für ein 16,6-Megapixel-Bild in 75 ms.

Die Arbeit mit Bildern ist bereits ressourcenintensiv, daher liebe ich Algorithmen, die die Komplexität von Eingabeparametern verringern. Vor fünf Jahren habe ich bei Pillow eine Gaußsche Unschärfe implementiert , die gleichzeitig für jeden Radius funktioniert. Vor nicht allzu langer Zeit habe ich darüber gesprochen, wie Sie das Bild in konstanter Zeit mit minimalem Qualitätsverlust reduzieren können . Heute zeige ich Ihnen, für welche Aufgaben Sie 3D LUT verwenden können, welche Einschränkungen es gibt und welche Leistung Pillow-SIMD erzielt.

Mach es normal - es wird nicht normal sein

: , . - , ( 0 255). , HSV , Hue, , , Saturation, , , Value, . , , Saturation - , . .

? , , . - , , . API, , , , . .

, , . , , , . , : , , , . API — .

- . , . , , , . , , - !

, . . , , RGB #e51288, [229, 18, 136]. — , RGB-. :

. 256³, 16 , 48 . 48 — . , L3 , . , 16 , 16 , , , . ?

, . , -- , . , , , 16³ . 12 , L3, L1 .

? — . , , ( ) .

, , . , , , . , .

3D LUT

, - . : , , , , . . . , -, . .

: , , , . , , .

, , . , , , . , . , , , - ( , ) .

?

, Pillow. API Color3DLUT PIL.ImageFilter. , :

from PIL.ImageFilter import Color3DLUT

table = [(0, 0, 0), (1, 0, 0), (0, 1, 0), (1, 1, 0),
         (0, 0, 1), (1, 0, 1), (0, 1, 1), (1, 1, 1)]
lut = Color3DLUT(2, table)

— . , . :

from PIL import Image
Image.open('in.jpg').filter(lut).save('out.jpg')

, . - , :

— - , generate, . , . 3D-.

def transform(r, g, b):
    r, g, b = (max(r, g, b), g, min(r, g, b))
    avg_v = r * 0.2126 + g * 0.7152 + b * 0.0722
    r += (r - avg_v) * 0.6
    g += (g - avg_v) * 0.6
    b += (b - avg_v) * 0.6
    return r, g, b

lut = Color3DLUT.generate(17, transform)
Image.open('in.jpg').filter(lut).save('out.jpg')

- , . : - , . , . Pillow-lut. rgb_color_enhance, :

from pillow_lut import rgb_color_enhance
lut = rgb_color_enhance(
    11, exposure=1, contrast=0.3, vibrance=-0.2, warmth=0.3)
Image.open('in.jpg').filter(lut).save('out.jpg')

, , ? : .cube ( , ) hald- — , .

Pillow-lut .

from pillow_lut import load_hald_image 
lut = load_hald_image('hald.6.hefe.png')
Image.open('in.jpg').filter(lut).save('out.jpg')

— , , ! , , . rgb_color_enhance , , :

lut = load_hald_image('hald.6.hefe.png')
lut = rgb_color_enhance(
    lut, exposure=1, contrast=0.3, vibrance=-0.2, warmth=0.3)
Image.open('in.jpg').filter(lut).save('out.jpg')

, . rgb_color_enhance. transform_lut, .

, «». ? . , 1, , — . . amplify_lut:

from pillow_lut import load_hald_image, amplify_lut
lut = load_hald_image('hald.6.hefe.png')
lut = amplify_lut(lut, scale=3.0)
Image.open('in.jpg').filter(lut).save('out.jpg')

: , . , ? , ( . : ).

, Pillow 5.2 16- ( ). , . 16- .

, 7 . 21 . , , . , ( 6 ), 2,5 , , . , SIMD-.

. ImageMagick GraphicsMagick. — LittleCMS — icc- . , , . , perf, PrelinEval8, , .

Intel Core i5-8279U.

Pillow-SIMD — Pillow, x86 . 100% Pillow . , , , Pillow 5.4, Pillow-SIMD 7.0. Pillow , . .

Wie aus den Testergebnissen hervorgeht, ist die Farbtransformation in Pillow schneller als in vorhandenen Lösungen und fliegt mit SIMD-Anweisungen in den Weltraum. Ich muss sagen, dass dies immer noch langsamer sein kann als eine gut optimierte Implementierung einer ziemlich großen Anzahl von Transformationen, die in C geschrieben werden könnten. Aber auf der Seite der Suchtabellen, Vielseitigkeit, Einfachheit und stabile Zeit, unabhängig von der Anzahl und Komplexität der Transformationen. Mit einer einfachen API können Sie schnell mit der Verwendung von Farbtransformationen beginnen, und eine spezielle Pillow-Lut-Bibliothek erleichtert das Arbeiten noch weiter.