Vaizdo apdorojimas OpenCV

Vaizdo Apdorojimas Opencv



Šiame straipsnyje apžvelgsime vaizdo apdorojimo metodus. Išnagrinėsime kai kurias esmines, bet svarbias kompiuterinio matymo ir mašininio mokymosi temas. Šie pagrindiniai vaizdo apdorojimo metodai gali išspręsti sudėtingas problemas, tokias kaip duomenų rinkiniai. Dėl to yra šeši pagrindiniai vaizdo apdorojimo žingsniai, kurie išvardyti toliau:
  1. Vaizdo vertimas
  2. Vaizdo pasukimas
  3. Vaizdo aritmetika
  4. Vaizdo apvertimas
  5. Vaizdo apkarpymas
  6. Vaizdo dydžio keitimas

Dabar mes išsamiai paaiškinsime visas aukščiau paminėtas vaizdo apdorojimo temas.

1. Vaizdo vertimas

Vaizdo vertimas yra vaizdo apdorojimo metodas, padedantis perkelti vaizdą išilgai x ir y ašių. Galime perkelti vaizdą aukštyn, žemyn, dešinėn, kairėn arba bet kokiu deriniu.







Vertimo matricą galime apibrėžti simboliu M ir pavaizduoti ją matematine forma, kaip parodyta žemiau:





Per šią programą galime suprasti vertimo vaizdo sampratą.





Python kodas: Šios programos pavadinimą išliksime kaip translate.py .

# importuoti reikiamus paketus

importuoti nelygus kaip pvz.

importuoti argparse

importuoti imutil

importuoti cv2

# įgyvendiname argumentų analizatorių

ap_obj = argparse. Argumentų analizatorius ( )

ap_obj. pridėti_argumentą ( '-k' , '--vaizdas' , reikalaujama = Tiesa ,

padėti = 'vaizdo failo vieta' )

args = kurių ( ap_obj. parse_args ( ) )

# įkelkite vaizdą ir parodykite jį ekrane

vaizdas = cv2. perskaitytas ( args [ 'vaizdas' ] )

cv2. imshow ( 'Original_image' , vaizdas )

# Vaizdo vertimas yra NumPy matrica, kuri pateikta žemiau:

# [[1, 0, shiftX], [0, 1, shiftY]]

# Naudosime aukščiau pateiktą NumPy matricą, norėdami perkelti vaizdus išilgai

# x ašies ir y ašies kryptys. Tam turime tiesiog perduoti pikselių reikšmes.

# Šioje programoje vaizdą perkelsime 30 pikselių į dešinę

# ir 70 pikselių į apačią.

vertimo kilimėlis = pvz. plūdė32 ( [ [ 1 , 0 , 30 ] , [ 0 , 1 , 70 ] ] )

image_translation = cv2. warpAffine ( vaizdas , vertimo kilimėlis ,

( vaizdas. figūra [ 1 ] , vaizdas. figūra [ 0 ] ) )

cv2. imshow ( „Vaizdo vertimas žemyn ir dešinėn“ , image_translation )

# dabar naudosime aukščiau pateiktą „NumPy“ matricą, norėdami perkelti vaizdus išilgai

# x ašies (kairėn) ir y ašies (aukštyn) kryptys.

# Čia mes ketiname perkelti vaizdus 50 pikselių į kairę

# ir 90 pikselių į viršų.

vertimo kilimėlis = pvz. plūdė32 ( [ [ 1 , 0 , - penkiasdešimt ] , [ 0 , 1 , - 90 ] ] )

image_translation = cv2. warpAffine ( vaizdas , vertimo kilimėlis ,

( vaizdas. figūra [ 1 ] , vaizdas. figūra [ 0 ] ) )

cv2. imshow ( „Vaizdo vertimas į viršų ir į kairę“ , image_translation )

cv2. palaukKey ( 0 )

1–5 eilutės: Importuojame visus šiai programai reikalingus paketus, tokius kaip OpenCV, argparser ir NumPy. Prašome atkreipti dėmesį, kad yra ir kita biblioteka, kuri yra imutils. Tai nėra OpenCV paketas. Tai tik biblioteka, kuri lengvai parodys tą patį vaizdo apdorojimą.



Bibliotekos imutilai nebus automatiškai įtraukti, kai įdiegsime OpenCV. Taigi, norėdami įdiegti imutils, turime naudoti šį metodą:

pip install imutils

8–15 eilutės: Sukūrėme agrparserį ir įkėlėme vaizdą.

24–25 eilutės: Šioje programos dalyje vyksta vertimas. Vertimo matrica nurodo, kiek pikselių vaizdas bus perkeltas aukštyn arba žemyn, į kairę ar dešinę. Kadangi OpenCV reikalauja, kad matricos reikšmė būtų slankiojo kablelio masyve, vertimo matrica paima reikšmes slankiojo kablelio matricose.

Pirmoji vertimo matricos eilutė atrodo taip:

Ši matricos eilutė skirta x ašiai. Vertė t x nuspręs, ar vaizdas bus perkeltas į kairę ar į dešinę pusę. Jei perduodame neigiamą reikšmę, tai reiškia, kad vaizdas bus perkeltas į kairę pusę, o jei reikšmė yra teigiama, tai reiškia, kad vaizdas bus perkeltas į dešinę.

Dabar apibrėžsime antrąją matricos eilutę taip:

Ši matricos eilutė skirta y ašiai. Vertė t Y nuspręs, ar vaizdas bus perkeltas aukštyn ar žemyn. Jei perduodame neigiamą reikšmę, tai reiškia, kad vaizdas bus perkeltas į viršų, o jei vertė yra teigiama, tai reiškia, kad vaizdas bus perkeltas į neigiamą pusę.

Ankstesnės programos 24 eilutėje apibrėžiame t x = 30 ir t Y = 70. Taigi vaizdą perkeliame 30 pikselių į dešinę ir 70 pikselių žemyn.

Tačiau pagrindinis vaizdo vertimo procesas vyksta 25 eilutėje, kur apibrėžiame vertimo matricą cv2.warpAffine . Šioje funkcijoje perduodame tris parametrus: pirmasis parametras yra vaizdas, antrasis parametras yra vertimo matrica, o trečiasis parametras yra vaizdo matmenys.

27 eilutė: 27 eilutėje bus rodomas rezultatas išvestyje.

Dabar įdiegsime kitą vertimo matricą kairėje ir aukštyn pusėje. Tam turime apibrėžti reikšmes neigiamai.

33–34 eilutės: Ankstesnėje programoje 33 eilutėje apibrėžiame t x = -50 ir t Y = -90. Taigi vaizdą perkeliame 50 pikselių į kairę pusę ir 90 pikselių į viršų. Tačiau pagrindinis vaizdo vertimo procesas vyksta 34 eilutėje, kur apibrėžiame vertimo matricą cv2.warpAffine .

36 eilutė : 36 eilutėje bus rodomas rezultatas, kaip parodyta išvestyje.

Norėdami paleisti ankstesnį kodą, turime nurodyti vaizdo kelią, kaip nurodyta toliau.

Išvestis: python translate.py –vaizdas squirrel.jpg

Dabar mes įdiegsime tą pačią vaizdų vertimo programą naudodami imutil biblioteka. Šią biblioteką labai paprasta naudoti vaizdams apdoroti. Šioje bibliotekoje mes neturime galvoti apie cv2.warpAffine nes ši biblioteka tuo pasirūpins. Taigi įgyvendinkime šią vaizdų vertimo programą naudodami imutils biblioteką.

Python kodas: Šios programos pavadinimą išliksime kaip translate_imutils.py .

# importuoti reikiamus paketus

importuoti nelygus kaip pvz.

importuoti argparse

importuoti imutil

importuoti cv2

# Ši funkcija įgyvendina vaizdo vertimą ir

# grąžina išverstą vaizdą į iškvietimo funkciją.

def išversti ( vaizdas , x , Y ) :

vertimo_matrica = pvz. plūdė32 ( [ [ 1 , 0 , x ] , [ 0 , 1 , Y ] ] )

image_translation = cv2. warpAffine ( vaizdas , vertimo_matrica ,

( vaizdas. figūra [ 1 ] , vaizdas. figūra [ 0 ] ) )

grąžinti image_translation

# sukonstruoti argumentų analizatorių ir išanalizuoti argumentus

ap = argparse. Argumentų analizatorius ( )

ap. pridėti_argumentą ( '-i' , '--vaizdas' , reikalaujama = Tiesa , padėti = „Kelias į vaizdą“ )

args = kurių ( ap. parse_args ( ) )

# įkelkite vaizdą ir parodykite jį ekrane

vaizdas = cv2. perskaitytas ( args [ 'vaizdas' ] )

cv2. imshow ( 'Original_image' , vaizdas )

image_translation = imutil. išversti ( vaizdas , 10 , 70 )

cv2. imshow ( 'Vaizdo vertimas į dešinę ir neigiamą pusę' ,

image_translation )

cv2. palaukKey ( 0 )

9–13 eilutės: Šioje programos dalyje vyksta vertimas. Vertimo matrica informuoja, kiek pikselių vaizdas bus perkeltas aukštyn arba žemyn, į kairę ar dešinę.

Šios eilutės jau buvo paaiškintos, bet dabar mes sukursime funkciją, pavadintą translate () ir į ją atsiųsime tris skirtingus parametrus. Pats vaizdas yra pirmasis parametras. Vertimo matricos x ir y reikšmės atitinka antrąjį ir trečiąjį parametrus.

Pastaba : Nereikia apibrėžti šios vertimo funkcijos programoje, nes ji jau įtraukta į imutils bibliotekos paketą. Naudojau jį programoje, kad būtų aiškus paaiškinimas. Šią funkciją galime iškviesti tiesiogiai su imutilais, kaip parodyta 24 eilutėje.

24 eilutė: Ankstesnė programa parodys, kad 24 eilutėje apibrėžiame tx = 10 ir ty = 70. Taigi vaizdą perkeliame 10 pikselių į dešinę ir 70 pikselių žemyn.

Šioje programoje mums nerūpi jokios cv2.warpAffine funkcijos, nes jos jau yra imutils bibliotekos pakete.

Norėdami paleisti ankstesnį kodą, turime nurodyti vaizdo kelią, kaip nurodyta toliau:

Išvestis:

python imutils. py --vaizdo voverė. jpg

2. Vaizdo pasukimas

Ankstesnėje pamokoje (arba bet kurioje kombinacijoje) nagrinėjome, kaip išversti (t. y. perkelti) vaizdą aukštyn, žemyn, kairėn ir dešinėn. Toliau aptarsime pasukimą, susijusį su vaizdo apdorojimu.

Vaizdas pasukamas kampu, teta, procese, vadinamame sukimu. Kampas, kuriuo pasukame vaizdą, bus pavaizduotas teta. Be to, vėliau pateiksiu pasukimo patogumo funkciją, kad pasukti vaizdus būtų paprasčiau.

Panašiai kaip vertimas ir, ko gero, nenuostabu, sukimas kampu, teta nustatoma sudarant matricą M tokiu formatu:

Ši matrica gali pasukti vektorinį teta laipsniais (prieš laikrodžio rodyklę) aplink nurodytą (x, y) dekarto plokštumą. Paprastai pagal šį scenarijų pradinė vieta būtų paveikslo centras, tačiau iš tikrųjų bet kurį atsitiktinį (x, y) tašką galime priskirti savo sukimosi centrui.

Tada pasuktas paveikslėlis R sukuriamas iš pradinio vaizdo I naudojant paprastą matricos dauginimą: R = IM

Kita vertus, „OpenCV“ papildomai suteikia galimybę (1) pakeisti vaizdą (ty pakeisti dydį) ir (2) pasiūlyti savavališką sukimosi centrą, kad būtų galima sukti.

Mūsų modifikuota sukimosi matrica M parodyta žemiau:

Pradėkime atidarydami ir sugeneruodami naują failą, pavadintą pasukti.py :

# importuoti reikiamus paketus

importuoti nelygus kaip pvz.

importuoti argparse

importuoti imutil

importuoti cv2

# sukuriamas argumentų parserio objektas ir analizuojamas argumentas

apobj = argparse. Argumentų analizatorius ( )

apobj. pridėti_argumentą ( '-k' , '--vaizdas' , reikalaujama = Tiesa , padėti = 'vaizdo kelias' )

argumentai = kurių ( apobj. parse_args ( ) )

vaizdas = cv2. perskaitytas ( argumentai [ 'vaizdas' ] )

cv2. imshow ( 'Original_image' , vaizdas )

# Apskaičiuokite vaizdo centrą naudodami vaizdo matmenis.

( aukščio , plotis ) = vaizdas. figūra [ : 2 ]

( centrasX , centrasY ) = ( plotis / 2 , aukštis / 2 )

# Dabar, naudodami cv2, pasuksime vaizdą 55 laipsniais į

# nustatykite sukimosi matricą naudodami getRotationMatrix2D()

rotacijaMatrica = cv2. getRotationMatrix2D ( ( centrasX , centrasY ) , 55 , 1.0 )

pasuktasVaizdas = cv2. warpAffine ( vaizdas , rotacijaMatrica , ( plotis , aukščio ) )

cv2. imshow ( 'Pasuktas vaizdas 55 laipsnių kampu' , pasuktasVaizdas )

cv2. palaukKey ( 0 )

# Dabar vaizdas bus pasuktas -85 laipsnių kampu.

rotacijaMatrica = cv2. getRotationMatrix2D ( ( centrasX , centrasY ) , - 85 , 1.0 )

pasuktasVaizdas = cv2. warpAffine ( vaizdas , rotacijaMatrica , ( plotis , aukščio ) )

cv2. imshow ( 'Pasuktas vaizdas -85 laipsnių' , pasuktasVaizdas )

cv2. palaukKey ( 0 )

1–5 eilutės: Importuojame visus šiai programai reikalingus paketus, tokius kaip OpenCV, argparser ir NumPy. Prašome atkreipti dėmesį, kad yra ir kita biblioteka, kuri yra imutils. Tai nėra OpenCV paketas. Tai tik biblioteka, kuri bus naudojama norint lengvai parodyti tą patį vaizdo apdorojimą.

Bibliotekos imutilai nebus automatiškai įtraukti, kai įdiegsime OpenCV. OpenCV įdiegia imutils. Turime naudoti šį metodą:

pip install imutils

8–14 eilutės: Sukūrėme agrparserį ir įkėlėme vaizdą. Šiame argparseryje naudojame tik vieną vaizdo argumentą, kuris nurodys vaizdo kelią, kurį naudosime šioje programoje, kad parodytume sukimąsi.

Sukant vaizdą, turime apibrėžti sukimosi sukimosi tašką. Dažniausiai norėsite pasukti vaizdą apie jo centrą, tačiau „OpenCV“ leidžia pasirinkti bet kurį atsitiktinį tašką. Tiesiog pasukime vaizdą aplink jo centrą.

17-18 eilutės atitinkamai paimkite vaizdo plotį ir aukštį, tada padalinkite kiekvieną matmenį iš dviejų, kad nustatytumėte vaizdo centrą.

Sukuriame matricą, kad pasuktume vaizdą taip pat, kaip apibrėžėme matricą, kad išverstume vaizdą. Mes tiesiog paskambinsime cv2.getRotationMatrix2D funkcija 22 eilutėje, o ne rankiniu būdu sukurti matricą naudojant NumPy (tai gali būti šiek tiek sudėtinga).

The cv2.getRotationMatrix2D funkcijai reikalingi trys parametrai. Pirmoji įvestis yra norimas sukimosi kampas (šiuo atveju vaizdo centras). Tada teta naudojama norint nurodyti, kiek (prieš laikrodžio rodyklę) laipsnių pasuksime vaizdą. Čia pasuksime vaizdą 45 laipsnių kampu. Galutinė parinktis yra susijusi su vaizdo dydžiu.

Nepaisant to, kad dar neaptarėme vaizdo mastelio keitimo, čia galite pateikti slankiojo kablelio skaičių su 1,0, nurodantį, kad vaizdas turėtų būti naudojamas pradinėmis proporcijomis. Tačiau jei įvedėte reikšmę 2,0, vaizdas padvigubėtų. Skaičius 0,5 taip sumažina vaizdo dydį.

22–23 eilutė: Gavęs mūsų sukimosi matricą M iš cv2.getRotationMatrix2D funkciją, pasukame vaizdą naudodami cv2.warpAffine Technika 23 eilutėje. Pirmoji funkcijos įvestis yra vaizdas, kurį norime pasukti. Tada apibrėžiamas išvesties vaizdo plotis ir aukštis kartu su mūsų sukimo matrica M. 23 eilutėje vaizdas pasukamas 55 laipsniais.

Galite pastebėti, kad mūsų vaizdas buvo pasuktas.

28–30 eilutės sudaro antrąjį sukimąsi. 22–23 kodo eilutės yra identiškos, išskyrus tai, kad šį kartą mes pasukame -85 laipsniais, o ne 55.

Iki šio taško mes tiesiog pasukome vaizdą aplink jo centrą. O kas, jei norėtume pasukti vaizdą aplink atsitiktinį tašką?

Pradėkime atidarydami ir sugeneruodami naują failą, pavadintą rotate.py:

# importuoti reikiamus paketus

importuoti nelygus kaip pvz.

importuoti argparse

importuoti imutil

importuoti cv2

# sukuriamas argumentų parserio objektas ir analizuojamas argumentas

ap_obj = argparse. Argumentų analizatorius ( )

ap_obj. pridėti_argumentą ( '-k' , '--vaizdas' , reikalaujama = Tiesa , padėti = 'vaizdo kelias' )

argumentas = kurių ( ap_obj. parse_args ( ) )

# įkelkite vaizdą ir parodykite jį ekrane

vaizdas = cv2. perskaitytas ( argumentas [ 'vaizdas' ] )

cv2. imshow ( 'Original_image' , vaizdas )

# Apskaičiuokite vaizdo centrą naudodami vaizdo matmenis.

( aukščio , plotis ) = vaizdas. figūra [ : 2 ]

( centrasX , centrasY ) = ( plotis / 2 , aukštis / 2 )

# Dabar, naudodami cv2, pasuksime vaizdą 55 laipsniais į

# nustatykite sukimosi matricą naudodami getRotationMatrix2D()

rotacijaMatrica = cv2. getRotationMatrix2D ( ( centrasX , centrasY ) , 55 , 1.0 )

pasuktasVaizdas = cv2. warpAffine ( vaizdas , rotacijaMatrica , ( plotis , aukščio ) )

cv2. imshow ( 'Pasuktas vaizdas 55 laipsnių kampu' , pasuktasVaizdas )

cv2. palaukKey ( 0 )

# Dabar vaizdas bus pasuktas -85 laipsnių kampu.

rotacijaMatrica = cv2. getRotationMatrix2D ( ( centrasX , centrasY ) , - 85 , 1.0 )

pasuktasVaizdas = cv2. warpAffine ( vaizdas , rotacijaMatrica , ( plotis , aukščio ) )

cv2. imshow ( 'Pasuktas vaizdas -85 laipsnių' , pasuktasVaizdas )

cv2. palaukKey ( 0 )

# vaizdo pasukimas iš kokio nors savavališko taško, o ne iš centro

rotacijaMatrica = cv2. getRotationMatrix2D ( ( centrasX - 40 , centras Y - 40 ) , 55 , 1.0 )

pasuktasVaizdas = cv2. warpAffine ( vaizdas , rotacijaMatrica , ( plotis , aukščio ) )

cv2. imshow ( „Vaizdo pasukimas iš savavališkų taškų“ , pasuktasVaizdas )

cv2. palaukKey ( 0 )

34–35 eilutės: Dabar šis kodas turėtų atrodyti gana įprastas sukant objektą. Norėdami pasukti vaizdą aplink tašką 40 pikselių į kairę ir 40 pikselių virš jo centro, nurodome cv2.getRotationMatrix2D funkcija atkreipti dėmesį į pirmąjį parametrą.

Vaizdas, sukurtas taikant šį pasukimą, parodytas žemiau:

Aiškiai matome, kad sukimosi centras dabar yra (x, y) koordinatė, kuri yra 40 pikselių į kairę ir 40 pikselių virš apskaičiuoto paveikslo centro.

3. Vaizdo aritmetika

Tiesą sakant, vaizdo aritmetika yra tik matricos pridėjimas su keliais papildomais duomenų tipų apribojimais, kuriuos aptarsime vėliau.

Leiskite šiek tiek laiko peržvelgti kai kuriuos gražius linijinės algebros pagrindus.

Apsvarstykite galimybę sujungti kitas dvi matricas:

Kokį rezultatą duotų matricos pridėjimas? Paprastas atsakymas yra matricos įrašų suma, elementas po elemento:

Pakankamai paprasta, tiesa?

Šiuo metu visi suprantame pagrindines sudėjimo ir atimties operacijas. Tačiau dirbdami su vaizdais turime atsižvelgti į apribojimus, kuriuos nustato mūsų spalvų erdvė ir duomenų tipas.

Pavyzdžiui, RGB vaizdų pikseliai yra tarp [0, 255]. Kas atsitiks, jei žiūrėdami į pikselį, kurio intensyvumas yra 250, bandysime pridėti 10?

Jei taikytume standartinius aritmetikos principus, gautume 260 vertę. 260 nėra tinkama reikšmė, nes RGB vaizdai pateikiami kaip 8 bitų beženkliai sveikieji skaičiai.

Taigi, kas turėtų įvykti? Ar turėtume atlikti patikrinimą, kad įsitikintume, jog joks pikselis nėra už [0, 255] diapazono, iškirpdami kiekvieną pikselį, kad jo reikšmė būtų nuo 0 iki 255?

O gal „apvyniojame“ ir atliekame modulio operaciją? Pagal modulio taisykles, pridėjus 10 prie 255, gautųsi tik 9.

Kaip reikėtų tvarkyti vaizdų, viršijančių [0, 255] diapazoną, pridėjimą ir atėmimą?

Tiesa ta, kad nėra teisingos ar neteisingos technikos; viskas priklauso nuo to, kaip dirbate su pikseliais ir ko tikitės pasiekti.

Tačiau atminkite, kad yra skirtumų tarp pridėjimo OpenCV ir pridėjimo NumPy. Modulio aritmetika ir „apvyniojimas“ bus atliktas NumPy. Priešingai, OpenCV vykdys iškirpimą ir užtikrins, kad pikselių reikšmės niekada nepaliktų diapazono [0, 255].

Pradėkime kurdami naują failą pavadinimu aritmetika.py ir atidarius:

# python arithmetic.py --image squirrel.jpg

# importuoti reikiamus paketus

importuoti nelygus kaip pvz.

importuoti argparse

importuoti imutil

importuoti cv2

# sukuriamas argumentų parserio objektas ir analizuojamas argumentas

apObj = argparse. Argumentų analizatorius ( )

apObj. pridėti_argumentą ( '-k' , '--vaizdas' , reikalaujama = Tiesa , padėti = 'vaizdo kelias' )

argumentai = kurių ( apObj. parse_args ( ) )

vaizdas = cv2. perskaitytas ( argumentai [ 'vaizdas' ] )

cv2. imshow ( 'Original_image' , vaizdas )

'''

Mūsų pikselių reikšmės bus diapazone [0, 255]

nes vaizdai yra NumPy masyvai, kurie saugomi kaip nepasirašyti 8 bitų sveikieji skaičiai.

Naudojant tokias funkcijas kaip cv2.add ir cv2.subtract, reikšmės bus nukirptos

į šį diapazoną, net jei jie pridedami arba atimami iš išorės

[0, 255] diapazonas. Štai iliustracija:

'''


spausdinti ( 'daugiausia 255: {}' . formatu ( g ( cv2. papildyti ( pvz. uint8 ( [ 201 ] ) ,

pvz. uint8 ( [ 100 ] ) ) ) ) )

spausdinti ( 'mažiausiai 0: {}' . formatu ( g ( cv2. atimti ( pvz. uint8 ( [ 60 ] ) ,

pvz. uint8 ( [ 100 ] ) ) ) ) )

'''

Atliekant aritmetines operacijas su šiais masyvais naudojant NumPy,

vertė apims aplink, o ne bus apkarpyta

[0, 255]diapazonas. Naudojant vaizdus, ​​būtina tai išlaikyti

omenyje.

'''


spausdinti ( 'apvynioti: {}' . formatu ( g ( pvz. uint8 ( [ 201 ] ) + pvz. uint8 ( [ 100 ] ) ) ) )

spausdinti ( 'apvynioti: {}' . formatu ( g ( pvz. uint8 ( [ 60 ] ) - pvz. uint8 ( [ 100 ] ) ) ) )

'''

Padauginkime kiekvieno vaizdo pikselio šviesumą iš 101.

Norėdami tai padaryti, sugeneruojame tokio pat dydžio NumPy masyvą, kaip ir mūsų matrica,

užpildytas vienetais, ir padauginkite jį iš 101, kad gautumėte užpildytą masyvą

su 101. Galiausiai sujungiame du vaizdus.

Pastebėsite, kad vaizdas dabar yra „ryškesnis“.

'''


Matrica = pvz. vieni ( vaizdas. figūra , dtipas = 'uint8' ) * 101

vaizdas_pridėtas = cv2. papildyti ( vaizdas , Matrica )

cv2. imshow ( 'Pridėtas vaizdo rezultatas' , vaizdas_pridėtas )

#Panašiai fotografuodami galime padaryti savo vaizdą tamsesnį

# 60 atstumu nuo visų pikselių.

Matrica = pvz. vieni ( vaizdas. figūra , dtipas = 'uint8' ) * 60

vaizdas_atimtas = cv2. atimti ( vaizdas , Matrica )

cv2. imshow ( „Atimtas vaizdo rezultatas“ , vaizdas_atimtas )

cv2. palaukKey ( 0 )

1–16 eilutės bus naudojamas mūsų įprastam procesui atlikti, kuris apima mūsų paketų importavimą, argumentų analizatoriaus konfigūravimą ir vaizdo įkėlimą.

Prisiminkite, kaip anksčiau aptariau skirtumą tarp „OpenCV“ ir „NumPy“ pridėjimo? Dabar, kai jį išsamiai išnagrinėjome, pažvelkime į konkretų atvejį, kad įsitikintume, jog jį suvokiame.

Apibrėžiami du 8 bitų nepaženklinti sveikųjų skaičių NumPy masyvai 26 eilutė . 201 reikšmė yra vienintelis elementas pirmajame masyve. Nors antrajame masyve yra tik vienas narys, jo reikšmė yra 100. Tada reikšmės pridedamos naudojant OpenCV funkciją cv2.add.

Kokio tikitės rezultato?

Pagal įprastus aritmetikos principus atsakymas turėtų būti 301. Tačiau atminkite, kad turime reikalą su 8 bitų beženkliais sveikaisiais skaičiais, kurie gali būti tik [0, 255] diapazone. Kadangi naudojame cv2.add metodą, OpenCV tvarko iškirpimą ir užtikrina, kad pridėjus būtų pateiktas tik maksimalus rezultatas – 255.

Pirmoje toliau pateikto sąrašo eilutėje rodomas šio kodo vykdymo rezultatas:

aritmetika. py

daugiausiai 255 : [ [ 255 ] ]

Iš tikrųjų ši suma sudarė 255.

Po to, 26 eilutė atimčiai atlikti naudoja cv2.subtract. Dar kartą apibrėžiame du 8 bitų nepaženklintus sveikųjų skaičių NumPy masyvus su vienu elementu kiekviename. Pirmojo masyvo vertė yra 60, o antrojo masyvo vertė yra 100.

Mūsų aritmetika nurodo, kad atėmus vertė turėtų būti -40, tačiau OpenCV dar kartą apdoroja iškirpimą už mus. Pastebime, kad vertė buvo sumažinta iki 0. Žemiau pateiktas rezultatas parodo tai:

aritmetika. py

mažiausiai 0 : [ [ 0 ] ]

Naudodami cv2 atimkite 100 iš 60 atimkite ir gaukite reikšmę 0.

Bet kas atsitiks, jei skaičiavimams atlikti naudosime NumPy vietoj OpenCV?

38 ir 39 eilutės spręsti šią problemą.

Pirma, apibrėžiami du 8 bitų beženklio sveikojo skaičiaus NumPy masyvai su vienu elementu. Pirmojo masyvo reikšmė yra 201, o antrojo masyvo vertė yra 100. Jei naudotume funkciją cv2.add, mūsų papildymas būtų apkarpytas ir būtų grąžinta 255 reikšmė.

Kita vertus, „NumPy“ „apvynioja“ ir atlieka modulinę aritmetiką, o ne karpymą. NumPy apsisuka iki nulio, kai pasiekiama 255 vertė, o tada tęsia skaičiavimą, kol bus pasiekta 100 žingsnių. Tai patvirtina pirmoji išvesties eilutė, kuri parodyta žemiau:

aritmetika. py
apvynioti: [ Keturi. Penki ]

Tada apibrėžiami dar du NumPy masyvai, kurių vieno vertė yra 50, o kito su 100. Šis atimtis būtų apkarpytas metodu cv2.subtract, kad būtų gautas rezultatas 0. Tačiau mes žinome, kad vietoj iškirpimo NumPy vykdo modulinė aritmetika. Vietoj to, modulo procedūros apsisuka ir pradeda skaičiuoti atgal nuo 255, kai atimties metu pasiekiamas 0. Tai matome iš šios išvesties:

aritmetika. py

apvynioti: [ 207 ]

Dar kartą mūsų terminalo išvestis parodo skirtumą tarp apkarpymo ir apvyniojimo:

Atliekant sveikųjų skaičių aritmetiką, labai svarbu turėti omenyje norimą rezultatą. Ar norite, kad būtų nukirptos vertės už diapazono [0, 255] ribų? Po to naudokite OpenCV integruotus vaizdų aritmetinius metodus.

Ar norite, kad reikšmės būtų apvyniotos, jei jos nepatenka į [0, 255] ir modulio aritmetinių operacijų diapazoną? Tada NumPy masyvai tiesiog pridedami ir atimami kaip įprasta.

48 eilutė apibrėžia vienmatį NumPy masyvą, kurio matmenys tokie pat kaip ir mūsų vaizdas. Dar kartą užtikriname, kad mūsų duomenų tipas būtų 8 bitų be ženklų sveikieji skaičiai. Mes tiesiog padauginame savo vienaženklių reikšmių matricą iš 101, kad užpildytume ją 101, o ne 1. Galiausiai naudojame funkciją cv2.add, kad pridėtume 100 s matricą prie pradinio vaizdo. Tai padidina kiekvieno pikselio intensyvumą 101, o taip pat užtikrina, kad visos vertės, kurios bando viršyti 255, būtų nukirptos į diapazoną [0, 255].

Stebėkite, kaip vaizdas pastebimai ryškesnis ir atrodo labiau „išplauti“ nei originalas. Taip yra todėl, kad padidiname pikselių intensyvumą 101 pikseliais ryškesnių spalvų link.

Norėdami atimti 60 iš kiekvieno vaizdo pikselio intensyvumo, pirmiausia sukuriame antrą NumPy masyvą 54 eilutėje, užpildytą 60-aisiais.

Šios atimties rezultatai pavaizduoti šiame paveikslėlyje:

Mus supantys daiktai atrodo žymiai tamsesni nei anksčiau. Taip yra todėl, kad atėmus 60 iš kiekvieno pikselio, RGB spalvų erdvėje esančius pikselius perkeliame į tamsesnes sritis.

4. Vaizdo apvertimas

Panašiai kaip pasukimas, vaizdo apvertimas per x arba y ašį yra dar viena „OpenCV“ siūloma galimybė. Net jei vartymo operacijos nenaudojamos taip dažnai, jų žinojimas yra neįtikėtinai naudingas dėl įvairių priežasčių, kurių iš karto nepastebėsite.

Kuriame mašininio mokymosi klasifikatorių, skirtą mažai pradedančiajai įmonei, kuri siekia atpažinti veidus vaizduose. Kad mūsų sistema „sužinotų“, kas yra veidas, mums reikės tam tikro duomenų rinkinio su veidų pavyzdžiais. Deja, bendrovė mums pateikė tik nedidelį 40 veidų duomenų rinkinį, todėl negalime surinkti daugiau informacijos.

Tai ką tada daryti?

Kadangi veidas išlieka veidu, nesvarbu, ar jis yra veidrodinis, ar ne, kiekvieną veido vaizdą galime apversti horizontaliai ir naudoti veidrodines versijas kaip papildomus treniruočių duomenis.

Šis pavyzdys gali atrodyti kvailas ir dirbtinis, bet taip nėra. Apvertimas yra apgalvota strategija, kurią naudoja stiprūs giluminio mokymosi algoritmai, kad mokymo etape būtų gauta daugiau duomenų.

Iš ankstesnio aišku, kad šiame modulyje išmokti vaizdo apdorojimo metodai yra didesnių kompiuterinio matymo sistemų pagrindas.

Tikslai:

Naudojant cv2.flip funkcija, šios sesijos metu išmoksite apversti vaizdą tiek horizontaliai, tiek vertikaliai.

Vartymas yra kita vaizdo manipuliacija, kurią išnagrinėsime. Vaizdo x ir y ašys gali būti apverstos arba net abi. Prieš pasineriant į kodavimą, geriausia pirmiausia pažvelgti į vaizdo apvertimo rezultatus. Šiame paveikslėlyje žiūrėkite horizontaliai apverstą vaizdą:


Atkreipkite dėmesį, kaip mūsų pradinis vaizdas yra kairėje ir kaip vaizdas buvo horizontaliai atspindėtas dešinėje.

Pradėkime kurdami naują failą pavadinimu vartymas.py .

Matėte vaizdo apvertimo pavyzdį, todėl panagrinėkime kodą:

# python flipping.py --image quirrel.jpg

# importuoti reikiamus paketus

importuoti argparse

importuoti cv2

# sukurti argumento objektą analizuoti ir išanalizuoti argumentą

apObj = argparse. Argumentų analizatorius ( )

apObj. pridėti_argumentą ( '-i' , '--vaizdas' , reikalaujama = Tiesa , padėti = 'vaizdo kelias' )

argumentas = kurių ( apObj. parse_args ( ) )

vaizdas = cv2. perskaitytas ( argumentas [ 'vaizdas' ] )

cv2. imshow ( 'Original' , vaizdas )

# apverskite vaizdą horizontaliai

apverstas vaizdas = cv2. apversti ( vaizdas , 1 )

cv2. imshow ( „Horizontaliai apverstas vaizdas“ , apverstas vaizdas )

# vertikaliai apversti vaizdą

apverstas vaizdas = cv2. apversti ( vaizdas , 0 )

cv2. imshow ( „Vertikaliai apverstas vaizdas“ , apverstas vaizdas )

# vaizdas apverstas išilgai abiejų ašių

apverstas vaizdas = cv2. apversti ( vaizdas , - 1 )

cv2. imshow ( 'Apversta horizontaliai ir vertikaliai' , apverstas vaizdas )

cv2. palaukKey ( 0 )

Veiksmai, kurių atliekame norėdami importuoti savo paketus, analizuoti įvestis ir įkelti vaizdą iš disko, atliekami l. nuo 1 iki 12 .

Įjungus funkciją cv2.flip 15 eilutė , paprasta apversti vaizdą horizontaliai. Vaizdas, kurį siekiame apversti, ir konkretus kodas arba vėliavėlė, nurodantis, kaip apversti vaizdą, yra du argumentai, reikalingi cv2.flip metodui.

Apvertimo kodo reikšmė 1 reiškia, kad pasuksime vaizdą aplink y ašį, kad apverstume jį horizontaliai ( 15 eilutė ). Jei nurodome apvertimo kodą 0, norime pasukti vaizdą apie x ašį ( 19 eilutė ). Neigiamas apvertimo kodas ( 23 eilutė ) pasuka vaizdą abiem ašimis.

Vienas iš paprasčiausių pavyzdžių šioje temoje yra vaizdo apvertimas, kuris yra pagrindinis.

Toliau aptarsime vaizdų apkarpymą ir naudosime „NumPy“ masyvo skilteles, kad ištrauktume konkrečias vaizdo dalis.

5. Vaizdo apkarpymas

Apkarpymas, kaip rodo pavadinimas, yra dominančio regiono (arba tiesiog ROI), kuris yra mus dominanti vaizdo sritis, pasirinkimo ir pašalinimo procesas.

Veidas turi būti apkarpytas iš vaizdo, kad būtų galima naudoti veido aptikimo programą. Be to, jei kurtume Python scenarijų, kad surastume šunis vaizduose, galbūt norėtume apkarpyti šunį vaizde, kai jį surastume.

Tikslai: Mūsų pagrindinis tikslas yra susipažinti su NumPy masyvo pjaustymu ir lengvai jį naudoti norint apkarpyti vaizdo sritis.

Apkarpymas : Kai apkarpome vaizdą, mūsų tikslas yra pašalinti išorinius elementus, kurie mūsų nedomina. IG pasirinkimo procesas dažnai vadinamas dominančio regiono pasirinkimu.

Sukurkite naują failą pavadinimu crop.py , atidarykite jį ir pridėkite šį kodą:

# python crop.py

# importuoti reikiamus paketus

importuoti cv2

# vaizdas įkeliamas ir rodomas ekrane

vaizdas = cv2. perskaitytas ( 'vovere.jpg' )

spausdinti ( vaizdas. figūra )

cv2. imshow ( 'Original' , vaizdas )

# NumPy masyvo pjūviai naudojami norint greitai apkarpyti vaizdą

# ketiname apkarpyti voverės veidą iš vaizdo

voverės veidas = vaizdas [ 35 : 90 , 35 : 100 ]

cv2. imshow ( 'Voverės veidas' , voverės veidas )

cv2. palaukKey ( 0 )

# O dabar mes apkarpysime visą kūną

# voverės

voveraitė = vaizdas [ 35 : 148 , 23 : 143 ]

cv2. imshow ( 'Voverės kūnas' , voveraitė )

cv2. palaukKey ( 0 )

Apkarpymą rodysime Python ir OpenCV naudodami vaizdą, kurį įkeliame iš disko 5 ir 6 eilutės .

Originalus vaizdas, kurį ketiname apkarpyti

Naudodami tik pagrindinius apkarpymo būdus, siekiame atskirti voverės veidą ir voverės kūną nuo aplinkinės zonos.

Naudosime savo ankstesnes žinias apie vaizdą ir rankiniu būdu pateiksime „NumPy“ masyvo dalis, kuriose yra kūno ir veido. Įprastomis sąlygomis mes paprastai naudotume mašininio mokymosi ir kompiuterinio matymo algoritmus, kad atpažintume veidą ir kūną vaizde. Tačiau kol kas būkime aiškūs ir nenaudokime jokių aptikimo modelių.

Vaizdo veidą galime atpažinti naudodami tik vieną kodo eilutę. 13 eilutė , Norėdami išgauti stačiakampę vaizdo dalį, pradedant nuo (35, 35), pateikiame NumPy masyvo pjūvius (90, 100). Gali atrodyti painu, kad apkarpymą pateikiame rodyklėmis aukštis-pirma ir plotis-antra tvarka, bet atminkite, kad OpenCV vaizdus saugo kaip NumPy masyvus. Dėl to turime pateikti y ašies reikšmes prieš x ašį.

„NumPy“ reikalauja šių keturių indeksų, kad galėtume apkarpyti:

Pradėti y: Y koordinatė pradžioje. Šiuo atveju mes pradedame nuo y = 35.

Pabaiga y: Y koordinatė pabaigoje. Mūsų apkarpymas sustos, kai y = 90.

Pradėti x: Pjūvio pradžia x koordinatė. Apkarpymas pradedamas nuo x=35.

Pabaiga x: Pjūvio pabaigos x ašies koordinatė. Kai x = 100, mūsų pjūvis baigtas.

Panašiai apkarpome sritis (23, 35) ir (143, 148) iš pradinio vaizdo, kad iš vaizdo ištrauktume visą kūną 19 eilutė .

Galite pastebėti, kad vaizdas buvo apkarpytas, kad būtų rodomas tik kūnas ir veidas.

6. Vaizdo dydžio keitimas

Vaizdo pločio ir aukščio didinimo arba mažinimo procesas vadinamas mastelio keitimu arba tiesiog dydžio keitimu. Keičiant vaizdo dydį reikia atsižvelgti į kraštinių santykį, kuris yra vaizdo pločio ir aukščio santykis. Jei nepaisysite formato santykio, vaizdai, kurių mastelis buvo pakeistas, gali atrodyti suspausti ir iškraipyti:

Mūsų pradinis vaizdas yra kairėje. Dešinėje matysite du vaizdus, ​​kurių mastelis buvo pakeistas neišlaikant formato santykio, iškraipant vaizdo pločio ir aukščio proporciją. Keisdami vaizdų dydį, paprastai turėtumėte atsižvelgti į kraštinių santykį.

Mūsų dydžio keitimo algoritmo naudojama interpoliavimo technika taip pat turi atsižvelgti į interpoliavimo funkcijos tikslą naudoti šias pikselių apylinkes vaizdo dydžiui padidinti arba sumažinti.

Apskritai vaizdo dydžio sumažinimas yra daug efektyvesnis. Taip yra todėl, kad vaizdo elementų pašalinimas yra viskas, ko reikia interpoliacijos funkcijai. Kita vertus, norint padidinti vaizdo dydį, interpoliacijos metodas turėtų „užpildyti tarpus“ tarp pikselių, kurių anksčiau nebuvo.

Kairėje pusėje yra originalus vaizdas. Vaizdas buvo sumažintas iki pusės pradinio dydžio centre, bet be to, vaizdo „kokybė“ neprarado. Nepaisant to, vaizdo dydis dešinėje buvo gerokai padidintas. Dabar jis atrodo „susprogdintas“ ir „pikseliuotas“.

Kaip jau minėjau, paprastai norėsite sumažinti vaizdo dydį, o ne jį padidinti. Sumažinus vaizdo dydį, analizuojame mažiau pikselių ir turime susidoroti su mažiau „triukšmo“, todėl vaizdo apdorojimo algoritmai tampa greitesni ir tikslesni.

Vertimas ir pasukimas yra dvi vaizdo transformacijos, kurios iki šiol buvo aptartos. Dabar panagrinėsime, kaip pakeisti vaizdo dydį.

Nenuostabu, kad vaizdų dydį keisime naudodami cv2.resize metodą. Kaip minėjau anksčiau, naudodami šį metodą turime atsižvelgti į vaizdo kraštinių santykį. Tačiau prieš pernelyg gilindamiesi į specifiką, leiskite man pateikti jums iliustraciją:

# python resize.py --image squirrel.jpg

# importuoti reikiamus paketus

importuoti argparse

importuoti cv2

# sukurti argumento objektą analizuoti ir išanalizuoti argumentą

apObj = argparse. Argumentų analizatorius ( )

apObj. pridėti_argumentą ( '-k' , '--vaizdas' , reikalaujama = Tiesa , padėti = 'vaizdo kelias' )

argumentai = kurių ( apObj. parse_args ( ) )

# įkelkite vaizdą ir parodykite jį ekrane

vaizdas = cv2. perskaitytas ( argumentai [ 'vaizdas' ] )

cv2. imshow ( 'Original' , vaizdas )

# Kad vaizdas nepasirodytų iškreiptas, kraštinių santykis

# turi būti laikomas arba deformuotas; todėl išsiaiškiname ką

# naujo vaizdo santykis su esamu vaizdu.

# Padarykime naujo vaizdo plotį 160 pikselių.

aspektas = 160,0 / vaizdas. figūra [ 1 ]

matmuo = ( 160 , tarpt ( vaizdas. figūra [ 0 ] * aspektas ) )

# šioje eilutėje bus rodomos tikrosios dydžio keitimo operacijos

pakeisto dydžio vaizdas = cv2. pakeisti dydį ( vaizdas , matmuo , interpoliacija = cv2. INTER_AREA )

cv2. imshow ( 'Pakeistas vaizdo plotis' , pakeisto dydžio vaizdas )

# Ką daryti, jei norėtume pakeisti vaizdo aukštį? - naudojant

# tuo pačiu principu, mes galime apskaičiuoti formato santykį

# apie aukštį, o ne plotį. Padarykime mastelį

# vaizdo aukštis 70 pikselių.

aspektas = 70,0 / vaizdas. figūra [ 0 ]

matmuo = ( tarpt ( vaizdas. figūra [ 1 ] * aspektas ) , 70 )

# pakeiskite dydį

pakeisto dydžio vaizdas = cv2. pakeisti dydį ( vaizdas , matmuo , interpoliacija = cv2. INTER_AREA )

cv2. imshow ( 'Pakeistas vaizdo aukštis' , pakeisto dydžio vaizdas )

cv2. palaukKey ( 0 )

1-14 eilutės , Importavę savo paketus ir sukonfigūravę argumentų analizatorių, įkelsime ir parodysime savo vaizdą.

20 ir 21 eilutės: šiose eilutėse prasideda atitinkamas kodavimas . Keičiant jo dydį, reikia atsižvelgti į vaizdo kraštinių santykį. Vaizdo pločio ir aukščio santykis yra žinomas kaip kraštinių santykis.

Aukštis Plotis yra kraštinių santykis.

Jei neatsižvelgsime į formato santykį, dydžio keitimo rezultatai bus iškraipyti.

Įjungta 20 eilutė , atliktas pakeisto dydžio santykio skaičiavimas. Šioje kodo eilutėje naujojo vaizdo plotis yra 160 pikselių. Mes tiesiog apibrėžiame savo santykį (aspectratio) kaip naują plotį (160 pikselių), padalytą iš senojo pločio, kurį pasiekiame naudodami vaizdą, kad apskaičiuotume naujo aukščio ir senojo aukščio santykį. forma[1].

Įjungti nauji vaizdo matmenys 21 eilutė galime apskaičiuoti dabar, kai žinome savo santykį. Dar kartą naujojo vaizdo plotis bus 160 pikselių. Padauginus senąjį aukštį iš mūsų santykio ir pavertus rezultatą į sveikąjį skaičių, apskaičiuojamas aukštis. Atlikdami šią operaciją galime išlaikyti pradinį vaizdo kraštinių santykį.

24 eilutė yra vieta, kur iš tikrųjų keičiamas vaizdo dydis. Vaizdas, kurio dydį norime pakeisti, yra pirmasis argumentas, o antrasis – matmenys, kuriuos apskaičiavome naujam vaizdui. Mūsų interpoliacijos metodas, kuris yra tikrojo vaizdo dydžio keitimo algoritmas, yra paskutinis parametras.

Galiausiai, toliau 25 eilutė , rodome pakeistą vaizdą.

Mes iš naujo apibrėžiame savo santykį (aspectratio). 31 eilutė . Mūsų naujo vaizdo aukštis bus 70 pikselių. Mes padalijame 70 iš pradinio aukščio, kad gautume naują aukščio ir pradinio aukščio santykį.

Tada nustatome naujo vaizdo matmenis. Naujasis vaizdas bus 70 pikselių aukščio, kuris jau žinomas. Galime dar kartą išlaikyti pradinį vaizdo kraštinių santykį, padaugindami senąjį plotį iš santykio, kad gautume naują plotį.

Tada vaizdo dydis iš tikrųjų pakeičiamas 35 eilutė , ir jis rodomas 36 eilutė.

Čia matome, kad sumažinome pradinio vaizdo plotį ir aukštį, išlaikydami formato santykį. Mūsų vaizdas atrodytų iškraipytas, jei nebūtų išlaikytas kraštinių santykis.

Išvada

Šiame tinklaraštyje mes išstudijavome pagrindines skirtingas vaizdo apdorojimo koncepcijas. Mes matėme vaizdų vertimą su OpenCV paketo pagalba. Mes matėme būdus, kaip perkelti vaizdą aukštyn, žemyn, dešinėn ir kairėn. Šie metodai yra labai naudingi, kai sukuriame panašių vaizdų duomenų rinkinį, skirtą pateikti kaip mokymo duomenų rinkinį, todėl įrenginys matys skirtingus vaizdus, ​​net jei jie yra vienodi. Šiame straipsnyje taip pat buvo išmokyta, kaip pasukti vaizdą aplink bet kurį Dekarto erdvės tašką naudojant sukimo matricą. Tada sužinojote, kaip OpenCV suka vaizdus naudodamas šią matricą, ir pamatėte keletą besisukančių vaizdų iliustracijų.

Šiame skyriuje buvo nagrinėjamos dvi pagrindinės (bet reikšmingos) vaizdo aritmetinės operacijos – sudėjimo ir atimties. Kaip matote, pagrindinių matricų pridėjimas ir atėmimas yra visos vaizdo aritmetinės operacijos.

Be to, norėdami ištirti vaizdo aritmetikos ypatumus, panaudojome OpenCV ir NumPy. Šiuos apribojimus reikia turėti omenyje, nes kitaip rizikuojate gauti netikėtų rezultatų, kai atliekate aritmetines savo vaizdų operacijas.

Svarbu atsiminti, kad nors „NumPy“ atlieka modulio operaciją ir „apvynioja“, „OpenCV“ sudėjimo ir atimties sumažinimo vertes už [0, 255] ribų, kad tilptų diapazone. Kurdami savo kompiuterinės vizijos programas, atsimindami tai padės išvengti sudėtingų klaidų.

Vaizdo apvertimas neabejotinai yra viena iš paprastesnių idėjų, kurias nagrinėsime šiame kurse. Apvertimas dažnai naudojamas mašininiame mokyme, siekiant sukurti daugiau mokymo duomenų pavyzdžių, todėl gaunami veiksmingesni ir patikimesni vaizdų klasifikatoriai.

Taip pat sužinojome, kaip naudoti OpenCV vaizdo dydžiui keisti. Keičiant jo dydį, labai svarbu atsižvelgti ir į naudojamą interpoliacijos metodą, ir į pradinio vaizdo formato santykį, kad rezultatas nebūtų iškraipytas.

Galiausiai, labai svarbu atsiminti, kad jei vaizdo kokybė yra problema, visada geriausia pakeisti didesnį vaizdą į mažesnį. Daugeliu atvejų padidinus vaizdą atsiranda artefaktų ir pablogėja jo kokybė.