[Matlab] graduated filter toepassen en warpen van afbeelding

[Kid Jansen]

Ik zou graag willen weten of het mogelijk is om een soort graduated filter zoals je die in bijvoorbeeld Lightroom hebt toe te passen op een afbeelding in Matlab en vervolgens de afbeelding te warpen zoals dat met Warp (Bulge) kan in Photoshop?


Een stukje achtergrond: ik loop al ruim een jaar te spelen met de gedachte om een artikel te schrijven voor TFT Central over beeldschermen / TV's met gebogen panelen. Ik wil daarbij zowel de voordelen als de nadelen uitlichten van een gebogen paneel ten opzichte van een vlak paneel.

Het grootste voordeel van gebogen panelen is dat bij zeer brede schermen die resulteren in een erg wijde beeldhoek de inkijkhoek voor content aan de randen van het scherm significant afneemt. Voor schermen die geen perfecte kijkhoeken hebben heeft dit een grote positieve invloed op de weergave.

Ik heb dit getracht te illustreren in de onderstaande afbeeldingen welke uitgaan van het nieuw aangekondigde 49" 32:9 paneel van Samsung (zie ook dit artikel). In beide gevallen gaat het om hetzelfde formaat paneel en dezelfde kijkafstand, maar ondanks dat de beeldhoek met het gebogen scherm wijder is (93,70° tegenover 85,33°) is de inkijkhoek langs de randen ruim anderhalf keer kleiner (27,78° tegenover 42,66°).

(klik voor groot)

(klik voor groot)

Stel dat ik uit ga van dit origineel:

(klik voor groot)

Dan zou dat er op het vlakke scherm zo uit kunnen zien vanaf die kijkafstand:

(klik voor groot)

Ik heb in Lightroom een graduated filter van de linker rand naar het midden en van de rechter rand naar het midden toegepast, in beide gevallen met Exposure -1,00 en Contrast -100.


Op het gebogen scherm zou het er dan zou uitzien:

(klik voor groot)

Ik heb hiervoor eerst uitgerekend hoe de vervorming en vanaf die kijkafstand uit zou zien en dat met Solidworks en Photoshop gesimuleerd. Vervolgens heb ik de afname van de helderheid en het contrast gesimuleerd in Lightroom, zoals ik dat ook voor de simulatie van het vlakke scherm had gedaan, alleen dan met Exposure -0,65 en Contrast -65.


De bedoeling is om hetzelfde te doen in Matlab, maar dan nauwkeurig, op basis van functies en metingen. Is zoiets mogelijk? En zo ja, zouden jullie me dan een zetje in de goede richting kunnen geven zodat ik weet waar ik moet zoeken?

Ik kom nu iedere keer uit op imgradient - gradient magnitude and direction of an image, maar dat lijkt iets anders te doen dan wat ik zoek.

Informatie over m'n Matlab versie en geïnstalleerde toolboxes staan hieronder.

code:

MATLAB                                                Version 8.5        (R2015a)
Simulink                                              Version 8.5        (R2015a)
Communications System Toolbox                         Version 6.0        (R2015a)
Computer Vision System Toolbox                        Version 6.2        (R2015a)
Control System Toolbox                                Version 9.9        (R2015a)
Curve Fitting Toolbox                                 Version 3.5.1      (R2015a)
DSP System Toolbox                                    Version 9.0        (R2015a)
Data Acquisition Toolbox                              Version 3.7        (R2015a)
Global Optimization Toolbox                           Version 3.3.1      (R2015a)
Image Acquisition Toolbox                             Version 4.9        (R2015a)
Image Processing Toolbox                              Version 9.2        (R2015a)
Instrument Control Toolbox                            Version 3.7        (R2015a)
MATLAB Report Generator                               Version 4.1        (R2015a)
Mapping Toolbox                                       Version 4.1        (R2015a)
Neural Network Toolbox                                Version 8.3        (R2015a)
Optimization Toolbox                                  Version 7.2        (R2015a)
Parallel Computing Toolbox                            Version 6.6        (R2015a)
Partial Differential Equation Toolbox                 Version 2.0        (R2015a)
Phased Array System Toolbox                           Version 3.0        (R2015a)
Signal Processing Toolbox                             Version 7.0        (R2015a)
SimDriveline                                          Version 2.8        (R2015a)
SimElectronics                                        Version 2.7        (R2015a)
SimEvents                                             Version 4.4        (R2015a)
SimMechanics                                          Version 4.6        (R2015a)
SimPowerSystems                                       Version 6.3        (R2015a)
Simscape                                              Version 3.13       (R2015a)
Simulink 3D Animation                                 Version 7.3        (R2015a)
Simulink Control Design                               Version 4.2        (R2015a)
Simulink Design Optimization                          Version 2.7        (R2015a)
Simulink Report Generator                             Version 4.1        (R2015a)
Stateflow                                             Version 8.5        (R2015a)
Statistics and Machine Learning Toolbox               Version 10.0       (R2015a)
Symbolic Math Toolbox                                 Version 6.2        (R2015a)
Wavelet Toolbox                                       Version 4.14.1     (R2015a)

[fiftyhillswest]

Je zou wellicht iets kunnen doen met de surface functie, waarmee je je plaatje kan mappen naar de binnenkant van een cilinder (deze zou dan overeen moeten komen met de eigenschappen van je monitor)

[ Voor 3% gewijzigd door fiftyhillswest op 31-01-2016 16:19 ]

[Skyaero]

Ik heb geen specifieke kennis van image processing, dus misschien dat LightRoom slimmere algoritmes gebruikt dan ik kan bedenken.

Wat je feitelijk aan het doen bent is het coördinaatstelsel aan het veranderen. Daarvoor gebruik je een transformatiematrix.

Elk kleurpunt heeft een x en y positie. Omdat het hier om pixels gaat is het een simpele enumeratie (0,0), (0,1) ... (0,n); (1,0), (1,1), .. (1,n) etc.

Met een transformatiematrix reken de nieuwe positie uit:

(u, v) = T (x, y)

Nu zullen u en v geen integers zijn, waardoor je de pixels niet kunt tekenen. Je zult nu interpolatie moeten toepassen zodat je je nieuwe image krijgt.

[Kid Jansen]

fiftyhillswest schreef op zondag 31 januari 2016 @ 16:18:
Je zou wellicht iets kunnen doen met de surface functie, waarmee je je plaatje kan mappen naar de binnenkant van een cilinder (deze zou dan overeen moeten komen met de eigenschappen van je monitor)

Zoiets had ik wel al aan gedacht, maar een probleem waar ik dan tegenaan zou kunnen lopen is het viewpoint correct krijgen. Het gaat mij er namelijk uiteindelijk niet om dat het scherm correct in een 3D ruimte staat, maar dat de 2D uitvoer correct is. Van die 2D uitvoer weet ik al hoe die er uit zien op basis van formaat scherm, straal van curve en kijkafstand.

Ik heb datzelfde probleem in Solidworks. Normaal gesproken zal een gebogen scherm in Solidworks er van voren nog steeds als een rechthoek uitzien, maar zelfs met de Perspective instelling aan krijg ik het niet zoals die simulatie van het gebogen scherm in m'n vorige post. Daarom bereken ik eerst gewoon hoe die er uit moet zien en teken het dan in 2D. Vervolgens leg ik er in Photoshop de afbeelding overheen en warp ik die zodat die matcht met de berekende vorm uit Solidworks.

Maar als ik in Matlab dus niet alleen de richting van waaruit je naar een 3D object kijkt, maar ook de (relatieve) afstand tot dat object kan instellen, zodat die vervorming klopt, dan zou dat zelfs de voorkeur hebben. Dan neem je namelijk ook automatisch al mee dat pixels langs de randen smaller lijken dan in het midden doordat je er onder een hoek tegenaan kijkt.

Maar dit gaat alleen nog maar om de vervorming en dat is eigenlijk het minder belangrijke deel van het totale probleem, omdat ik dat al nauwkeurig kan simuleren met een combinatie van Solidworks en Photoshop. Het belangrijke deel is de helderheid- en contrastafname wanneer een pixel onder een hoek wordt bekeken correct simuleren.

Ik weet voor elke pixelkolom al onder welke hoek die wordt bekeken voor zowel vlakke als gebogen schermen (ervan uitgaande dat ik complete set beginparameters heb en dus volledig gedefinieerd model). Op basis van metingen kan ik wel een functie bepalen die de relatie beschrijft tussen de afname in helderheid/contrast en de inkijkhoek. En het moet ook wel lukken om een formule te bepalen die de RGB waarden omzet naar de gecorrigeerde RGB waarden voor een bepaalde afname in helderheid en contrast.

Die drie combineren geeft een formule die de gecorrigeerde RGB waarden bepaalt op basis van de originele RGB waarden en pixelkolom.

Skyaero schreef op zondag 31 januari 2016 @ 16:49:
verhaal

Dit lijkt dan een veiligere optie, omdat die net zoals wat ik nu doe meteen in 2D werkt in plaats van dat je in 3D met het scherm en viewpoint aan de slag moet.

[narotic]

Kid Jansen schreef op zondag 31 januari 2016 @ 18:41:
[...]
Maar dit gaat alleen nog maar om de vervorming en dat is eigenlijk het minder belangrijke deel van het totale probleem, omdat ik dat al nauwkeurig kan simuleren met een combinatie van Solidworks en Photoshop. Het belangrijke deel is de helderheid- en contrastafname wanneer een pixel onder een hoek wordt bekeken correct simuleren.

Ik weet voor elke pixelkolom al onder welke hoek die wordt bekeken voor zowel vlakke als gebogen schermen (ervan uitgaande dat ik complete set beginparameters heb en dus volledig gedefinieerd model). Op basis van metingen kan ik wel een functie bepalen die de relatie beschrijft tussen de afname in helderheid/contrast en de inkijkhoek. En het moet ook wel lukken om een formule te bepalen die de RGB waarden omzet naar de gecorrigeerde RGB waarden voor een bepaalde afname in helderheid en contrast.

In Matlab zal de image gewoon een matrix van RGB waarden zijn (lengte x breedte x 3), dus waarom niet gewoon deze aanpassen aan de hand van de functie die je hebt door middel van een simpele for-loop over de coordinaten?

Als ik je goed begrepen hebt hou je echter alleen rekening met de horizontale kijkhoek, terwijl er natuurlijk ook een verticale kijkhoek is. Deze is wat minder groot dan de horizontale, maar afhankelijk van de technologie is het kleurverloop vaak anders in de verticale as dan in de horizontale as. Sterker nog, bij veel TN schermen is de afwijking verre van symmetrisch (van boven krijg je een geheel andere vervorming dan van onderen).

[Kid Jansen]

narotic schreef op zondag 31 januari 2016 @ 21:49:
In Matlab zal de image gewoon een matrix van RGB waarden zijn (lengte x breedte x 3), dus waarom niet gewoon deze aanpassen aan de hand van de functie die je hebt door middel van een simpele for-loop over de coordinaten?

For loop is een optie, maar moet ook wel vectorized kunnen denk ik.

Als ik je goed begrepen hebt hou je echter alleen rekening met de horizontale kijkhoek, terwijl er natuurlijk ook een verticale kijkhoek is. Deze is wat minder groot dan de horizontale, maar afhankelijk van de technologie is het kleurverloop vaak anders in de verticale as dan in de horizontale as. Sterker nog, bij veel TN schermen is de afwijking verre van symmetrisch (van boven krijg je een geheel andere vervorming dan van onderen).

Dat klopt, omdat gebogen beeldschermen in de meeste gevallen een beeldverhouding hebben van 21:9 en Samsung komt dus zelfs met panelen van 32:9. Daarnaast gebruiken deze panelen in alle gevallen een paneeltechnologie uit de IPS of VA-familie. Gebogen TN panelen bestaan niet.

Ik zou de verticale inkijkhoek ook wel op kunnen nemen in m'n model, maar de invloed op het resultaat is erg klein. In het gebruikte voorbeeld met het 49" 32:9 Samsung paneel vanaf 65 cm zou de inkijkhoek 27,78° zijn voor een pixel in het midden (verticaal) langs de zijrand en 30,00° voor één van de hoeken. Gezien het verschil in het effect van de inkijkhoek tussen horizontale en verticale richting niet heel groot is bij IPS en VA paneeltechnologieën en het maar zo'n klein verschil geeft in de totale hoek is het niet echt de moeite waard om mee te nemen.

[narotic]

Kid Jansen schreef op zondag 31 januari 2016 @ 23:06:
[...]
For loop is een optie, maar moet ook wel vectorized kunnen denk ik.

Dat kan altijd, maar zulke optimalisaties kun je beter doorvoeren zodra je zeker weet dat de logica klopt. Daarnaast is dat de moeite waard als je veel images wilt bewerken, anders is het vaak de vraag of jij niet meer tijd aan optimaliseren kwijt bent dan jouw computer bespaart in de berekeningen.

Aangezien de kleurvervorming niet netjes lineair zal zijn, zal een standaard matrix transformatie sowieso niet voldoen lijkt me. Als je echter de functie per coordinaat uitgeschreven hebt, dan kun je hoogstwaarschijnlijk wel het een en ander versnellen door de element-wise operaties in matlab te gebruiken in sommige stappen; in ieder geval voor de geometrische berekeningen die je sowieso maar voor 1 rij hoeft te doen.

[ Voor 3% gewijzigd door narotic op 31-01-2016 23:33 ]

[Kid Jansen]

narotic schreef op zondag 31 januari 2016 @ 23:32:
Dat kan altijd, maar zulke optimalisaties kun je beter doorvoeren zodra je zeker weet dat de logica klopt. Daarnaast is dat de moeite waard als je veel images wilt bewerken, anders is het vaak de vraag of jij niet meer tijd aan optimaliseren kwijt bent dan jouw computer bespaart in de berekeningen.

Daar heb je inderdaad een goed punt.

Aangezien de kleurvervorming niet netjes lineair zal zijn, zal een standaard matrix transformatie sowieso niet voldoen zijn lijkt me. Als je echter de functie per coördinaat uitgeschreven hebt, dan kun je hoogstwaarschijnlijk wel het een en ander versnellen door de element-wise operaties in Matlab te gebruiken in sommige stappen; in ieder geval voor de geometrische berekeningen die je sowieso maar voor 1 rij hoeft te doen.

De kleurvervorming zal inderdaad niet lineair zijn en zelfs al was dat wel het geval, dan werd het alsnog niet lineair door de gamma encoding. Element-wise zal dan inderdaad wel makkelijker zijn en met die grootte moet dat nog prima te doen zijn.

Veel bredere voorbeelden dan 2000 pixels zal ik toch niet gebruiken, dus voor 21:9 zit je dan op matrices van rond de 2000x858x3 en voor 32:9 op 2000x562x3.

[Skyaero]

narotic schreef op zondag 31 januari 2016 @ 23:32:
[...]
Dat kan altijd, maar zulke optimalisaties kun je beter doorvoeren zodra je zeker weet dat de logica klopt.
Daarnaast is dat de moeite waard als je veel images wilt bewerken, anders is het vaak de vraag of jij niet meer tijd aan optimaliseren kwijt bent dan jouw computer bespaart in de berekeningen.

Dit is een veelgemaakte denkfout bij mensen die in Matlab werken. Het eerst in een for-loop en daarna proberen om vectorized te doen levert enorm veel meer werk op. Matlab is juist gemaakt om met vectoren en matrices te werken. Het is juist ontworpen om niet al die for-loopjes te hoeven schrijven

Waarom zou je tig for-loops gaan schrijven als je een stelsel van lineaire vergelijkingen (Ax = wilt oplossen, terwijl Matlab dat gewoon voor je kan doen:
x = A \ B

De moeilijkheid die optreed is dat veel mensen ook programmeerkennis hebben in andere talen en deze kennis in Matlab proberen te gebruiken. Matlab is echter geen generieke programmeertaal, maar gemaakt rond lineaire algebra. Dat het tegenwoordig veel meer kan, inclusief connected met databases en het maken van GUI's is mooi meegenomen. Maar in de basis is het nog altijd een Matrix Laboratory.

[ValHallASW]

Er spelen nu twee vragen door elkaar: eentje hoe je contrast/intensiteit per pixel kunt aanpassen en eentje hoe je het vervolgens als curved surface kunt tonen. Ik ga even in op die eerste.

Uit je schets haal ik dat je alleen kijkt naar horizontale kijkhoek (niet de verticale). Ik weet niet precies hoe intensiteit en contrast afhangen van de kijkhoek, maar laat ik heb even simpel modelleren. Ik doe het in numpy-statements (python) aangezien ik de exacte matlab-functies niet ken, maar het zou vergelijkbaar moeten zijn.

Python:

import numpy as np

breedte_mm = 1150 # mm
kijkafstand = 650 # mm

breedte_px = 1920 # px

x = np.linspace(-breedte_mm/2, breedte_mm/2, breedte_px)   # [-575, ..., 575] in 1920 stappen
kijkhoek = np.arctan(x / kijkafstand)

Dat geeft je voor elke pixel de bijbehorende kijkhoek. Ik ga er vervolgens vanuit dat je weet wat de relatie tussen intensiteit, contrast en de kijkhoek is. Ik ga er voor het gemak even vanuit dat dat lineair is:

Python:

I = 1-kijkhoek
dC = -kijkhoek

(met het risico dat je nog even moet goochelen met de assen -- dat hangt er vanaf hoe matlab een RGB afbeelding inleest)

waarna je die per pixel kunt toepassen:

Python:

image = plt.imread('full.jpg')
image_contrast = np.uint8((np.int_(image) - 128) * (1+dC) + 128)
image_intensity = np.uint8(image_contrast * I)

en dan krijg je zoiets:


Dat is vast niet de nette manier om contrast/intensity aan te passen, maar die relatie kan je zelf denk ik beter uitzoeken. Dit zou je in ieder geval een handvast moeten geven over hoe je het in een vector-gebaseerde taal kunt implementeren.


notebook met plotjes en plaatjes: https://gist.github.com/valhallasw/b2fcaa821abb6a6a2793

[Kid Jansen]

Ik denk dat ik voor nu meer dan genoeg informatie heb om mee aan de slag te gaan. Voordat ik het echt kan maken zal ik toch eerst de relatie tussen inkijkhoek en helderheid/contrast moeten onderzoeken en vervolgens bepalen hoe ik op basis daarvan de RGB-waarden moet aanpassen.

Ik heb daar op z'n vroegst pas komend weekend de tijd voor.