1. No category

JOONAS KIISKINEN
VIRHETILANTEIDEN
KONENÄÖLLÄ
HAVAITSEMINEN
PAKKAUSKONEESTA
Diplomityö
Tarkastaja: professori Seppo Kuikka
Tarkastaja ja aihe hyväksytty
Teknisten tieteiden tiedekuntaneuvoston kokouksessa
6.5.2015
ii
TIIVISTELMÄ
TAMPEREEN TEKNILLINEN YLIOPISTO
Automaatiotekniikan koulutusohjelma
KIISKINEN, JOONAS: Virhetilanteiden havaitseminen pakkauskoneesta
konenäöllä
Diplomityö, 49 sivua, 3 liitesivua
Huhtikuu 2015
Pääaine: Automaatiotekniikka
Tarkastaja: professori Seppo Kuikka
Avainsanat: OpenCV, konenäkö
Laadunvalvonnassa on perinteisesti käytetty ihmisiä, eivätkä koneet ole heitä täysin
syrjäyttäneetkään. Kuitenkin teollisuudessa tuotantolinjat tukeutuvat konenäköön yhä
useammin, kun tekniikat ja algoritmit konenäössä kehittyvät. Konenäön etuna voidaan
pitää sen nopeaa ja täsmällistä tiedonkäsittelyä.
Tässä diplomityössä tutkittiin menetelmiä, joilla pystytään tekemään järjestelmästä
interaktiivinen ympäristönsä kanssa. Tähän sisältyy liikkeen tunnistaminen videosta,
missä tausta erotetaan alkuperäisestä kuvasta. Tavoitteena oli toteuttaa
konenäkösovellus, joka hyödyntää tätä ja monia muita toimintoja. Näiden avulla
sovellus pystyy informoimaan PLC-järjestelmää sen ympäristön muutoksista.
Sovellus käyttää avoimen lähdekoodin kirjastoja. Oleellisin näistä on OpenCV-kirjasto,
joka tarjoaa tarvittavat funktiot sovelluksen tekemiseen. Tämän lisäksi sovellus käyttää
vielä ZXing-kirjastoa, jonka avulla voidaan lukea viiva- sekä 2D-koodeja
digitaalikuvasta. Sovellus kehitettiin Qt-kehitysympäristössä, joka tarjosi myös
mahdollisuuden kehittää sovellukselle tarvittavan käyttöliittymän. Diplomityön
tarkoituksena oli jatkokehittää alkuperäistä järjestelmää, mutta myös tutkia järjestelmän
suoritusta kevyemmällä alustalla. Tässä onnistuttiinkin, mutta tiettyjä osia alkuperäisen
järjestelmän toiminnasta jouduttiin kuitenkin karsimaan kohdealustan heikon
suorituskyvyn takia.
Toteutettu konenäkösovellus pystyy tutkimaan jatkuvaa videovirtaa ja tutkimaan siitä
sovellukselle opetetut toiminnot. Toimintoihin sisältyy liikkeen tunnistaminen ja
viivakoodin lukeminen. Jokainen virheellinen liikehavainto tai onnistunut viivakoodin
tulkitseminen välitetään järjestelmään yhdistetyille laitteille. Sovelluksessa voidaan
määrittää käsin tai automaattisesti sallittu liikealue. Virheellinen liikehavainto tarkoittaa
sitä, että liikettä havainnoidaan tämän alueen ulkopuolella.
iii
ABSTRACT
TAMPERE UNIVERSITY OF TECHNOLOGY
Master’s Degree Programme in Automation Technology
KIISKINEN, JOONAS: Error detection from packing machine with computer
vision
Master of Science Thesis, 49 pages, 3 Appendix pages
April 2015
Major: Automation Technology
Examiner: Professor Seppo Kuikka
Keywords: OpenCV, computer vision
Traditionally, people have been used in quality control, and machines haven’t yet
completely displaced them. However, industrial production lines rely more and more in
computer vision when techniques and machine vision algorithms evolve. The main
advantage of machine vision can be considered to be rapid and punctual information
processing.
This thesis studies ways on which we are able to make the existing system to be
interactive with its surroundings. This includes movement detection from video stream
where background is subtracted from the initial frame. The goal was to create a
computer vision application which will utilize this and its many other functions. With
these the application is able to communicate with the PLC-system about the changes of
its surroundings.
The application uses open source code libraries. The most significant library is
OpenCV. It provides the necessary functions to complete the application. The
application also uses ZXing-library by which the application is able to read barcodes
and 2D-codes from a digital image. The application was developed in a Qt-environment
which offered the possibility to develop a required user interface for the application.
The most important purpose of this thesis was to develop further the original monitoring
system but to also investigate the performance of an embedded device when it is
running the original system. The investigation was successful but some features of the
original system had to be eliminated due to the poor performance of the target device.
The computer vision application is able to process continuous video stream and process
all the functions that have been taught for the application. These functions include
motion detection and barcode/2D-code reading. Every faulty motion detection or
successful barcode detection will trigger an event which will be sent to every device
which is connected to the monitoring system. In the application it is possible to define
an area manually or automatically where movement is allowed. Faulty motion detection
is triggered if movement is detected outside of this defined area.
iv
ALKUSANAT
Suuret kiitokset Jomet Oy:lle, joka tarjosi mielenkiintoisen diplomityöaiheen. Ennen
työn aloittamista, kävimme palavereita Jomet sisäisen kehitysryhmän kanssa, joissa
alettiin ideoimaan järjestelmä, joka pystyisi itse havaitsemaan jos pakkauskoneessa
ilmenee virhetilanne. Mielessäni kävi tuolloin, että kyseisen toiminnon suorittava
sovellus pystyttäisiin toteuttamaan vasta kaukana tulevaisuudessa. Ei kuitenkaan
kestänyt kauaa kunnes aloin hieman tutkia asiaa ja törmäsin OpenCV-kirjastoon ja
havahduimme sen tarjoamista mahdollisuuksista.
Erityismainintana haluan kuitenkin vielä kiittää ohjaajaani diplomi-insinööri Juha
Kiiskistä sekä työn tarkastajaa professori Seppo Kuikkaa. Molemmat ovat antaneet työn
rakenteeseen sekä sisältöön liittyvää rakentavaa palautetta.
Holzösterissä 12.4.2015
Joonas Kiiskinen
v
SISÄLLYS
Abstract ....................................................................................................................... iii
Termit ja niiden määritelmät ......................................................................................... 1
1
Johdanto................................................................................................................ 2
2
Konenäköjärjestelmä ............................................................................................. 4
2.1 Valaistus ....................................................................................................... 6
2.2 Linssi ............................................................................................................ 7
2.3 Anturointi ...................................................................................................... 8
2.4 Kuvan prosessointi ........................................................................................ 8
2.5 Kommunikointi ............................................................................................. 9
3
Konenäön soveltaminen ...................................................................................... 10
3.1 Digitaalikuva ............................................................................................... 10
3.1.1 Digitaalikuvaa mallintava funktio ................................................... 11
3.2 Digitaalisen kuvan käsittely ......................................................................... 11
3.2.1 Geometriset operaatiot .................................................................... 11
3.2.2 Kuvan gradientti ............................................................................. 15
3.2.3 Kuvassa esiintyvät reunat ............................................................... 16
4
Vanha järjestelmä................................................................................................ 20
4.1 Virheiden havaitseminen ............................................................................. 20
4.2 Kommunikaatio ........................................................................................... 20
4.3 Reagointi virheeseen ................................................................................... 20
4.3.1 Tiedon siirtäminen pilvipalveluun................................................... 21
5
Toteutus .............................................................................................................. 22
5.1 Kevyet kehitysalustat................................................................................... 22
5.2 Vanhan järjestelmän kehittäminen ............................................................... 24
5.2.1 Vaatimukset.................................................................................... 24
5.2.2 Käyttötapaukset .............................................................................. 25
5.2.3 Käytetyt kirjastot ............................................................................ 28
5.2.4 Sovellus .......................................................................................... 34
6
Tulokset ja arviointi ............................................................................................ 38
6.1 Testialusta ................................................................................................... 38
6.2 Loppusovelluksen yleiskuvaus .................................................................... 39
6.3 Käyttö ......................................................................................................... 40
6.4 Sovelluksen rakenne .................................................................................... 41
6.5 Jatkokehitys................................................................................................. 42
7
Yhteenveto .......................................................................................................... 44
Lähteet........................................................................................................................ 46
Liitteet ........................................................................................................................ 48
1
TERMIT JA NIIDEN MÄÄRITELMÄT
API
Ohjelmointirajapinta. (Application Programming Interface).
ASIC
Mikropiiri, joka on suunniteltu ainoastaan yhtä toimintoa
varten. (Application Specific Integrated Circuit).
FPGA
Ohjelmoitava mikropiiri, joka toimii kellotaajuuden
tarkkuudella. (Field Programmable Gate Array).
GCC
Kääntäjä, joka tukee lukuisia ohjelmointikieliä. (GNU
Compiler Collection).
inline-avainsana
C-ohjelmointikielissä käytetty avainsana, jolla vältytään
ohjelmassa muistihypyiltä.
IPC
Prosessien
välinen
Communication).
PLC
Ohjelmoitava logiikka, teollisuuskomponentti, joka tukee
IEC-61131-3-standardin
ohjelmointikieliä.
Käytetään
teollisuudessa
mm.
ohjaamaan
toimilaitteita.
(Programmable Logic Controller).
SIMD-käsky
Laskentayksikkö suorittaa samaa ohjelmaa useille eri
tietoalkioille. (Single Instruction stream, Multiple Data
streams).
STL-säilö
Säilö on olio, joka sisältää toisia olioita. (Standard Template Library container).
x86-prosessori
Intelin kehittämä prosessoriarkkitehtuuri.
kommunikaatio.
(Inter-Process
2
1
JOHDANTO
Konenäön kehitys sai alkunsa 1960-luvulla, kun Larry Roberts teki tohtorin tutkintonsa
3D-mallin
geometrisen
informaation
erottamisen
2D-näkymästä
MIT:lle
(Massachuttsetts Institute of Technology). Monet tutkijat käyttivät tätä työtä pohjanaan
omaan työhönsä sekä jatkoivat Robertsin aloittamaa työtä eteenpäin. 1970-luvun lopulla
David Marr kehitti uuden lähestymistavan (bottom up), jolla pystytään ymmärtämään
digitaalista näkymää paremmin konenäön kannalta. 1980-luvulla konenäkö alkoi
saavuttaa maailman laajuista tutkijakuntaa, mikä toi mukanaan uusia teorioita ja
käsitteitä. Vasta 1990-luvulla konenäköjärjestelmiä alkoi näkyä tuotantojärjestelmissä,
mikä johti konenäköteollisuuden varsinaiseen syntymiseen. Tällä hetkellä konenäkö
kehittyy edelleen huimaa vauhtia samalla kun prosessointiyksiköt kehittyvät,
mahdollistaen entistä monimutkaisempia ja näyttävämpiä konenäkösovelluksia.
Nousevana trendinä on 3D- sekä elepohjaisten järjestelmien kehittäminen.
Elepohjaisessa järjestelmässä perinteiset syötelaitteet, kuten hiiri ja näppäimistö
korvataan eleohjauksilla. [2]
Konenäöllä jäljitellään ihmisen näköaistia, eli konenäkö pyrkii tulkitsemaan 3D-mallia
2D-kuvista tai -videovirroista. Konenäön määritelmä koostuu tiedon automaattisesta
erottamisesta digitaalisista kuvista ja videoista. Tieto on esimerkiksi objektin
tunnistamista tai liikkeen seuraamista. Kuvien käsittely voidaan jakaa kolmeen eri
tasoon. Alimmalla tasolla tapahtuu kuvan prosessointi, mikä käsittää kuvan matalan
tason parannukset: kohinan suodattaminen, ominaisuuden tunnistaminen ja kuvan
kompressointi. Toisella tasolla on kuvan analysoiminen, jossa käytetään hyväksi
alemmalla tasolla saatuja tuloksia. Ylin taso koostuu konenäöstä, joka käyttää taas
analysointitason tuloksia muodostaen näistä uudet johtopäätökset: objektin
tunnistamisen, muodon analysoinnin ja yleisen tunnistamisen. Nykyään konenäköä
käytetään moneen erilaiseen tärkeään toimintoon teollisuudessa ja lääketieteessä.
Teollisuudessa monet tarkastelutehtävät pystytään suorittamaan koneellisesti konenäön
avulla sekä lääketieteessä konenäköä voidaan hyödyntää röntgen- ja magneettikuviin.
Kehityksen myötä näitä sovelluksia pystytään entistä helpommin siirtämään kevyille
alustoille. Nämä sovellukset voidaan kategorisoida neljään eri funktioon: mittaukseen,
laskemiseen, paikantamiseen ja dekoodaukseen. Mittausta ja laskemista voidaan käyttää
tuotteiden ominaisuuksiin, esimerkiksi piirilevyn komponenttien sijainti piirilevyllä..
Paikantamisessa vaadittu ominaisuus paikallistetaan, jolloin siihen voidaan suorittaa
muita tarvittavia operaatioita. Dekoodauksella viitataan erilaisten viivakoodien sekä 2Dkoodien tulkitsemiseen. [2]
3
Konenäköjärjestelmä tarkoittaa kokonaisuutta, jossa kuvan hankinta, käsittely ja
analysointi on yhdistetty yhdeksi kokonaisuudeksi. [2] Digitaalikuvan käsittely ja
analysointi tehdään tietokoneella tai jollakin muulla laitteella. Järjestelmä koostuu
yhdestä tai useasta kamerasta, valaistuksesta, laskentayksiköstä sekä kuvankäsittely- ja
analysointiohjelmasta. Tässä tutkimustyössä käytetään Logitechin C920-webkameroita,
joissa on sisäänrakennettu H.264-enkoodaus. Sisäänrakennetulla enkoodauksella on
vasta merkitystä kun siirrytään kevyempään alustaan, mutta tähän perehdytään
tarkemmin luvussa 5. Tyypillisesti konenäköjärjestelmä on osana tuotantolinjaa, jossa
voidaan
tarkastella
tuotteiden
ominaisuuksia.
Tuotantotehtaat
käyttävät
konenäköjärjestelmää ihmisten sijasta, koska ne pystyvät toimimaan nopeammin, ovat
luotettavampia ja pystyvät työskentelemään jatkuvasti. Tässä työssä pöytätietokone
toimii tutkimustyön konenäköjärjestelmän ytimenä, mutta tämän lisäksi tutkitaan
kevyempää alustavaihtoehtoa yksinkertaisempiin monitorointitoimintoihin.
Nykyajan pakkauskoneet räätälöidään entistä enemmän vastaamaan asiakkaan tarpeita,
jolloin jokainen valmistettava kone poikkeaa hieman toisista. Koneiden
perustoiminnallisuus toki pysyy samanlaisena, mutta pienet muutokset toimilaitteiden
ohjauksessa vaativat ohjelmakoodin muokkauksen, joka mahdollistaa inhimilliset
ohjelmavirheet. Tämän takia pakkauskoneen toimintaa halutaan monitoroida. Jos ja kun
ohjelmavirhe ilmenee ja keskeyttää koneen toiminnan, tilanteesta halutaan löytyvän
videomateriaalia, johon voidaan tukeutua ja tämän avulla pystytään korjaamaan
mahdollinen ohjelmavirhe. Koneen pysäyttävään virheeseen voidaan joutua ilman
ohjelmavirhettäkin. Mekaaninen ongelma onkin tyypillisempi kuin ohjelmallinen, koska
mekaaniset osat kuluvat ja alentavat täten osien toimintavarmuutta. Joka tapauksessa
videon avulla pystytään toteamaan ongelmatilanteen aiheuttaja.
Tässä työssä tutkitaan pystytäänkö OpenCV-kirjastolla luomaan webkamerapohjainen
konenäköjärjestelmä, joka pystyy toimimaan ”reaaliaikaisesti” yhdessä PLCjärjestelmän kanssa. Aiheeseen tutustuminen aloitetaan tutustumalla konenäön
perusteisiin, jonka jälkeen tarkastellaan konenäön mahdollistavaa OpenCV-kirjastoa.
Kirjastoon tutustumisen ohessa käydään läpi hieman myös sovellusohjelmointia ja
selvennetään tutkimuksessa tehtyä sovellusta. Tästä seuraavassa luvussa tarkastellaan
lopullisen sovelluksen tuloksia ja arvioidaan, kuinka hyvin OpenCV-kirjasto soveltuu
teollisiin automaatiosovelluksiin. Viimeinen luku tiivistää vielä yhteen koko
tutkimuksen.
4
2
KONENÄKÖJÄRJESTELMÄ
Konenäkö perustuu digitaalisten kuvien perusteelliseen tutkimiseen. Kuvan avulla
tietokone pystyy tekemään hyödyllisiä päätelmiä siinä esiintyvistä fyysisistä objekteista.
Videotiedostoa voidaankin käytännössä kuvitella digitaalikuvataulukkona, joka on
synkronoitu äänitiedoston kanssa. Videon oleellinen ominaisuus on kuvien
virkistystahti. Tämä määrittää kuinka monta kuvaa esitetään sekunnissa. Ihminen pystyy
erottamaan noin 55 kuvaa sekunnissa, mutta jo 20 kuvan virkistystahti näyttää ihmiselle
jatkuvalta liikkeeltä. Tämä tarkoittaa, että virkistystaajuuden ollessa 20, eli kuva
päivittyy 50 tahdilla, käytännössä konenäköjärjestelmällä on myös sama aika
prosessoida kuva ja tehdä tarvittavat päätelmät.
Konenäköjärjestelmässä on kuitenkin kaksi erilaista mahdollisuutta prosessoida
jatkuvaa videovirtaa. Toisessa näistä jokainen videovirtaa generoivan laitteen kuva
siirretään puskuriin, eli ”digitaalikuvataulukkoon” ja toisessa luetaan ainoastaan tuorein
kuva väylästä. Ensimmäiseksi esitetyn mallin sovelluksen tulee olla vähintäänkin yhtä
nopea kuin videovirran virkistystaajuus. Jos sovellus ei pysty tähän, niin puskuri tulee
täyttymään ajan myötä ja jos tämä halutaan välttää, niin sovelluksen täytyy hylätä
satunnaisia kuvia prosessoinnista. Tällöin on mahdollista, että hylätään jotain oleellista
tietoa sisältäviä kuvia. Sovelluksen prosessointinopeuden ollessa hitaampi kuin
videovirran virkistystaajuus, tarkoittaa tämä sitä, että järjestelmän ”reaaliaikaisuus” on
menetetty. Toinen sovellusmalli prosessoi ainoastaan uusinta kuvaa, jonka kamera on
lähettänyt. Tämän etuna on, että sovelluksen reaktioaika on deterministinen. Huono
puoli on, että kaikkia kuvia ei prosessoida, jos sovelluksen reaktioaika on suurempi kuin
videovirran virkistystaajuus.
Konenäön avulla toteutettuja sovelluksia:
•
•
•
•
•
•
•
•
•
Autonomisen auton visuaalinen ohjaus
Rekisterikilpien automaattinen tunnistus (ANPR)
Tekstin tunnistaminen (OCR)
Kasvon tunnistaminen
Hymyn tunnistaminen (kamera laukeaa vasta kun hymy on tunnistettu)
Objektitunnistus
Kirjautuminen järjestelmään kasvojen avulla (http://www.sensiblevision.com)
Urheilulähetysten grafiikka
Peliteollisuus: Nintendo Wii, Xbox Kinect
5
Konenäköjärjestelmän toiminnot voidaan jakaa neljään sovelluskohteeseen:
mittaamiseen, laskemiseen, paikantamiseen sekä dekoodaukseen. Näiden toimintojen
avulla pystytään alentamaan tuotantojärjestelmän kustannuksia sekä kasvattamaan
tuotantolinjan tuottavuutta. Konenäkö pystyy erittelemään virheelliset tuotteet
tuotantolinjalta ilman taukoja, väsymättä ja pyyteettömästi. Näin varmistetaan, että
tuotteen loppukäyttäjä ei saa käyttöönsä viallista tuotetta. Tuotantolinjan tuottavuuden
kasvattamisen perusteena on, että pienemmällä määrällä lähtömateriaalia saadaan
enemmän lopullisia tuotteita.
Konenäkö mahdollistaa virheiden havaitsemisen jo tuotantolinjan alkuvaiheesta
tehokkaasti. Tällöin vioittunut tuote tai komponentti voidaan käyttää uudelleen
esimerkiksi raaka-aineina uuden tuotteen tuottamiseen, jos lopullinen tuote koostuu
esimerkiksi erilaisista komponenteista. On siis tärkeää, että ennen kuin lopullinen tuote
valmistetaan, jokainen sen komponentti toimii. Tuotantolinjan loppupäässä havaittu
viallinen tuote voi joutua jätteeksi, jos siitä ei pystytä enää hyödyntämään mitään raakaaineita tuotantoprosessia varten.
Konenäöllä pystytään myös kasvattamaan tuotantolinjan päälläoloaikaa. Pakkauskoneen
toiminta on taattu, kun kaikki sisään tulevat tuotteet tai tavarat tulevat samalla lailla
sekä ennalta sovitulla tavalla.
Kuva 1 virheellinen tuote tuotantolinjassa
Kuvassa 1 on havainnollistettu tilanne, joka voisi mahdollisesti aiheuttaa koneen
seisahduksen. Jotta tuotantolinjan tuottavuus pysyy korkealla, on oleellista, että
vältetään pakkauskoneen virhetilanteita. Seisahduksesta tulee huomattavasti lyhyempi,
kun pysäytetään hihnakuljetin virheen korjaamiseksi.
Tuotteiden seuranta on myös tärkeää tuotantojärjestelmässä. Näin tuotteita pystytään
paikantamaan tuotantolinjalla ja mahdollisesti havaitaan ne kohdat, joiden toimintaa
pitää kehittää, jotta saavutetaan vieläkin parempi tuottavuus. Tuotteita seuratessa
konenäkösovellus tarkastelee viivakoodeja, 2D-koodeja sekä OCR-tekstejä (Optical
Character Recognition) eli koneen ja ihmisen ymmärtämiä tekstejä.
6
Näiden ohella konenäköjärjestelmän etuna voidaan myös pitää sitä, että se pystyy
työskentelemään jatkuvasti ilman mitään pysähdyksiä. Kun järjestelmä on kerran
ohjelmoitu jotakin tehtävää varten, se tekee aina samaa tehtävää. Ihmisillä alkaa
tapahtua virheitä enenevissä määrin noin 20 minuutin tarkastelutyön jälkeen, koska
mielenkiinto tehtävää työtä kohtaan laskee tutkitusti. Tämän lisäksi koneet pystyvät
työskentelemään nopeammin ja aina samanlaisesti.
Fyysisesti konenäköjärjestelmä koostuu viidestä eri osa-alueesta: valaistuksesta,
linssistä, anturoinnista, kuvaprosessoinnista ja kommunikoinnista. Itse järjestelmä voi
koostua joko erikseen edellä mainituista komponenteista tai kaikki nämä komponentit
voidaan yhdistää yksittäiseen sulautettuun järjestelmään. Erillisistä komponenteista
koottu järjestelmä voisi koostua esimerkiksi tietokoneesta, kamerasta ja ulkoisesta
valolähteestä. Ennen kuin tarkastellaan näitä komponentteja tarkemmin, on oleellista
tiedostaa, että ei ole yhdentekevää mitenkä kappaleet esitellään konenäköjärjestelmälle.
Kappaleen sijainnin ja suunnan tulisi olla vakio tai toistettava, jotta konenäön
tuottamasta lopputuloksesta tulisi hyödyllinen seuraavalle järjestelmälle.
2.1
Valaistus
Valaistus on tärkeä osa toimivaa konenäköjärjestelmää. Ilman sitä mitään kameran
ottamia kuvia ei luultavasti pystytä hyödyntämään, koska kuvista ei voida erottaa
mitään hyödyllistä. Oikealla valaistuksella, eli valon suuntauksella, tehokkuudella ja
valon värin valinnalla pystytään tuomaan kappaleen tarkkailtavat ominaisuudet näkyviin
ja mahdollisesti vielä korostamaan näitä ominaisuuksia. Tarkoituksena on siis saada
ainoastaan tarkkailtavista ominaisuuksista tarkkoja ja muista ominaisuuksista
mahdollisimman epäselviä, jotta erottuvuus olisi mahdollisimman suuri.
Kuva 2 valaistuksen suunnan merkitys
Kuvassa
2
on
esitelty
esimerkkinä
valaistuksen
suunnan
merkitys.
Vasemmanpuoleisessa kuvassa valaistus on sijoitettu kappaleen ja kameran väliin,
jolloin hehkulampun lanka näkyy epäselvästi. Oikeanpuoleisessa kuvassa valaistus on
sijoitettu kappaleen taakse kohti kameraa, jolloin saadaan selvästi tarkempi kuva
langasta.
7
Kuva 3 väriympyrä
Materiaalit myös heijastavat ja absorboivat eripituisia valon aallonpituuksia. Kun
materiaalin pinta näyttää erityisen kirkkaalta, se heijastaa suurinta osaa tulevasta
valosta. Pinnan ollessa tumma, pinta kostuu vastustavasta väristä, ja se absorboi
suurimman osan tulevasta valosta.
Kuva 4 Valolähteen värin merkitys
Voidaan käyttää yksinkertaista väriympyrää, joka jakautuu kahteen eri osaan;
lämpimään ja kylmään. Tämän avulla pystytään luomaan kontrasti kohteen ja taustan
välillä. Mustavalkokameralla on myös mahdollista erottaa tietyn värisiä ominaisuuksia,
kun käytetään oikean väristä valonlähdettä kuvauksessa. Jokainen väri heijastaa hyvin
samanväristä valoa, esimerkiksi punainen kappale näyttää kirkkaalta (valkoiselta)
punaisessa valaistuksessa ja samaisesta kappaleesta saadaan tumma (musta) vihreällä
valaistuksella. [9,15]
2.2
Linssi
Linssin avulla kaapataan kuva ja välitetään se anturoinnille valona. Linssi määrittää
myös tarkasteltavan alueen koon ja tarkkuuden syvyyden. Oikealla linssin valinnalla
pystytään edesauttamaan konenäköjärjestelmä kohti parempaa lopputulosta. Linssin
valinnalla voidaan rajata tarkasteltava alue ainoastaan haluttuihin ominaisuuksiin.
8
Kuva 5 väärä linssivalinta voi tehdä kuvasta lukukelvottoman konenäkösovellukselle
Väärällä linssin valinnalla otetaan epätarkempi kuva laajemmalta alueelta, joka sisältää
turhaa tietoa. Tällöin kuvalle joudutaan suorittamaan huomattavasti enemmän
algoritmeja, että saadaan eroteltua halutut ominaisuudet. Useampien algoritmien
suorittaminenkaan ei takaa, että huonosta kuvasta voitaisiin erottaa samat ominaisuudet
kuin hyvästä kuvasta.
2.3
Anturointi
Digitaaliset kamerat ovat tulleet entistä suosituimmiksi samalla kun niiden hinnatkin
ovat laskeneet. Yksi syy tähän on digitaalikameran anturointiteknologian kehitys.
CMOS-tekniikka on hiljalleen syrjäyttämässä kalliimpaa CCD-tekniikkaa. Anturointi
vastaanottaa linssin välittämän valon ja muuntaa sen elektroneiksi. Lopullinen
digitaalikuva muodostuu kun elektronit sijoitetaan pieniin kennoihin, jotka vastaavat
pikselialueita digitaalikuvassa.
Anturointi käyttää tyypillisesti CCD- tai CMOS-tekniikkaa muokatessaan linssin
välittämän valon digitaaliseksi kuvaksi. Tämä digitaalinen kuva koostuu pikseleistä,
missä vähäinen valo muodostaa tummia pikseleitä ja kirkas valo kirkkaampia pikseleitä.
On tärkeää, että kameran anturoinnin resoluutio on tarpeeksi suuri konenäkösovellusta
varten. Mitä alhaisempi resoluutio, eli MP-taso (Mega Pixels), sitä selkeämmin pikselit
erottuvat toisistaan kuvassa. Kun digitaalinen kuva on muodostettu, se lähetetään
eteenpäin prosessorille, joka suorittaa tarvittavia analyysejä kyseiselle kuvalle. [9]
2.4
Kuvan prosessointi
Kuvan prosessoiva yksikkö koostuu algoritmeista, jotka tarkastelevat kuvaa ja erottavat
kuvasta haluttuja ominaisuuksia. Prosessointivaihe voidaan jakaa seuraaviin vaiheisiin:
•
•
•
•
Kuva vastaanotetaan kameralta
Käsitellään kuvaa, jotta ominaisuudet erottuvat
Ohjelmat etsivät halutut ominaisuudet
Lasketaan mittaukset ja verrataan referenssiarvoihin
9
•
Lopuksi välitetään tulos eteenpäin, tyypillisesti tieto hyväksytystä tai hylätystä
tuotteesta.
Tähän kiteytyy koko konenäköjärjestelmän ydin. Kuvan prosessointiin liittyy usein
erilaisia konenäköohjelmistoja, joilla pystytään konfiguroimaan järjestelmä tutkimaan
tiettyjä asioita. Useimmissa ohjelmistoissa on toiminnot paikantamiselle, laskemiselle,
mittaamiselle ja dekoodaamiselle. Näitä toimintoja käytetään usein yhdessä laadittaessa
lopputulosta.
2.5
Kommunikointi
Kuvan prosessoimisen jälkeen lopputulokset välitetään eteenpäin seuraavalle
järjestelmälle. Lopputuloksen on tarkoitus olla hyödyllistä tietoa, joka on eritelty
digitaalikuvasta. Kommunikoinnin voi jakaa yksittäiseen signaaliin, joka yhdistetään
esimerkiksi PLC-järjestelmään tai solenoidiin, joilla ohjataan hylkäysmekanismia.
Toinen vaihtoehto kommunikoinnissa on, että välitetään dataa esimerkiksi RS-232:lla,
Ethernetillä tai Ethernet/IP:llä. RS-232-sarjaväylää ja Ethernetiä voidaan käyttää, jos
järjestelmän data halutaan siirtää esimerkiksi tietokoneelle. Ethernet/IP:llä data voidaan
siirtää HMI-paneeliin (Human Machine Interface), josta koneen operaattori voi
tarkastella mittaustuloksia.
10
3
KONENÄÖN SOVELTAMINEN
Digitaalisille kuville voidaan tehdä monenlaisia operaatioita. Useat konenäköön liittyvät
operaatiot muokkaavat kuvaa parantamalla kuvanlaatua tai prosessoimalla kuvaa
muodostaen uuden kuvan. Konenäössä käytetään kuitenkin myös operaatioita, jotka
muuttavat alkuperäisen kuvan esitystavan täysin. Alkuperäisessä kuvassa voidaan
esittää pikselin väriarvot, mutta prosessoidussa kuvassa voidaan esittää pikseleiden
väriarvojen diskreettejä derivaattoja, jolloin lopputuloksena näkyy alkuperäisen kuvan
reunoja. Tässä luvussa on tarkoituksena käydä läpi hieman molempia operaatioita
geometrisista operaatioista aina reunan tunnistamiseen. Aluksi on kuitenkin hyvä
tutustua siihen, mitä digitaalinen kuva sisältää.
3.1
Digitaalikuva
Digitaalinen kaksiulotteinen kuva koostuu pikseleistä ja pikseli voi sisältää useita eri
väriarvoja riippuen kuvan värimaailmasta. Digitaalikuvat esitetään usein RGBmuodossa, jolloin pikseliarvo sisältää punaisen, vihreän ja sinisen värikomponentin
arvot. Jokaisen värikomponentin arvo skaalautuu arvovälille [0,255], joka on
esitettävissä kahdeksalla bitillä. Näin ollen, RGB-muodossa olevan kuvan yksi pikseli
tarvitsee 24 bittiä muistia. Harmaasävyisessä kuvassa ainoana värikomponenttina on
harmaa, jonka arvoalue on myös [0,255]. Tällöin harmaasävyisen kuvan yhden pikselin
vaatima muistin määrä on kahdeksan bittiä. Konenäössä onkin tärkeää huomioida
prosessoitavan tiedon kokoa. Koska harmaasävyinen kuva on ainoastaan kolmasosan
kokoinen RGB-kuvaan verrattuna, on tärkeää, että vain riittävää dataa tutkitaan ja
manipuloidaan.
Kuva 6 tietokoneen näkemys digitaalikuvista
11
Kuvassa 6 esitetään digitaalikuvan sisältämän datan näkymää ihmisen ja tietokoneen
näkökulmasta. Ihminen havaitsee väriarvot värinä ja tietokone tulkitsee samaiset arvot
diskreetteinä lukuarvoina. Vasemmalla olevassa kuvassa esitetään kohta, johon
zoomataan. Keskellä oleva kuva näyttää mustavalkoisen datan zoomatusta alueesta ja
oikealla nähdään kohteen sisältämät RGB-komponenttien arvot. [2,15]
3.1.1
Digitaalikuvaa mallintava funktio
Kuvaa voidaan mallintaa myös funktiolla f(x,y), jossa x ja y ovat xy-koordinaatiston
koordinaatteja. Funktion ulostuloa, millä tahansa xy-koordinaattiparilla, kutsutaan kuvan
intensiteetiksi kyseisestä pisteestä. Kun x-, y- ja intensiteettiarvot ovat kaikki äärellisiä
ja diskreettejä, niin kutsumme tätä kuvaa digitaaliseksi kuvaksi. [15]
Kuvaa mallintava funktio koostuu kahdesta komponentista.
1. Valaisusta (illuminance) i(x,y) = kuvassa ilmenevän valaistuksen määrä.
2. Heijastuksesta (reflection) r(x,y) = kuvassa ilmenevän valaistuksen
heijastuminen kuvan objekteista.
, = , , ,
(1)
jossa
0 < , < ∞ ja 0 < , < 1
Objektin ominaisuudet määrittelevät r(x,y)-arvon. Kun r(x,y) = 0, niin objekti ei heijasta
yhtään valoa ja r(x,y) = 1 tarkoittaa valon täydellistä heijastumista. Esimerkkinä
mainittakoon, että aurinko valaisee kirkkaana päivänä 90 000 lm / m2, pilvisenä päivänä
10 000 lm / m2 ja valaistuksen voimakkuus toimistossa on noin 1000 lm / m2.
Vastaavasti lumen heijastuskerroin on 0.93, ruostumattoman teräksen on 0.63 ja mustan
sametin on 0.01. Funktion f(x,y) palauttamat arvot rajoittuvat tyypillisesti sisätiloissa 10
ja 1000 välille. Kuvattaessa mustavalkomaailmaa, funktion ulostuloarvot rajoitetaan 0 ja
255 väliin. Musta on 0 ja valkoinen on vastaavasti 255, kaikki muu tämän väliltä esittää
harmaan eri sävyjä.
3.2
Digitaalisen kuvan käsittely
3.2.1
Geometriset operaatiot
Geometrinen matriisioperaatio laskee uudet koordinaatit pikseliarvoille. Geometristen
operaatioiden avulla voidaan esimerkiksi zoomata, pyörittää ja muuttaa kuvan
näkökulmaa. Nämä operaatiot suoritetaan 2-ulotteisille kuville. Operaatioiden
12
lopputuloksena on uusi kuva, jossa alkuperäisen kuvan jokaiselle pikseliarvon
koordinaateille lasketaan uudet koordinaatit ja näihin koordinaatteihin sijoitetaan
alkuperäinen pikseliarvo. Pikseliarvojen sijoitus voidaan tehdä kahdella eri tavalla.
Eteenpäin sijoituksessa (forward mapping) käydään alkuperäisen kuvan pikselit yksi
kerrallaan läpi ja kopioidaan pikseliarvo geometrisen operaation osoittamaan
koordinaattipisteeseen. Asian voi myös mieltää siten, että lopullisen kuvan
koordinaattien pikseliarvoja muutetaan ”satunnaisessa” järjestyksessä. Käänteisessä
sijoituksessa (reverse mapping) käydään loppukuvan koordinaatit yksi kerrallaan läpi ja
ne paikannetaan alkuperäisestä kuvasta geometrisella operaatiolla. Lasketun paikan
pikseliarvo kopioidaan loppukuvan koordinaattiin. Tämän jälkeen loppukuvassa
siirrytään seuraavaan koordinaattiin ja lasketaan sen alkuperäinen sijainti ja niin
edelleen. Eli toisin kuin eteenpäin sijoituksessa, käänteisessä sijoituksessa loppukuvan
koordinaattien pikseliarvot muutetaan järjestyksessä. [4,18,19]
Kuva 7 vasemmalla esitetään forward mapping ja oikealla reverse mapping [18,19]
On olemassa kuitenkin kaksi tilannetta, jotka vaikeuttavat edellä kuvattuja
sijoitusprosesseja. Ensimmäinen on se, että lopullinen kuva on suurempi kuin
alkuperäinen. Tällöin koordinaatit eivät välttämättä kuulu alkuperäisen kuvan
pikselikoordinaatistoon. Tämä edellyttää jonkinlaista interpolaatiota, jossa lasketaan
kyseiseen koordinaattiin pikseliarvo. Toinen tilanne on se, missä lopullinen kuva on
pienempi kuin alkuperäinen. Tämä tarkoittaa sitä, että alkuperäisessä kuvassa on liiaksi
dataa, eli kaikkia pikseliarvoja ei voida sijoittaa loppukuvaan. Tätä varten tarvitaan
ekstrapolaatiomenetelmiä, joilla pystytään säilyttämään alkuperäisen kuvan sisältö.
Tämä kuitenkin johtaa siihen, että loppukuvassa on vähemmän tietoa, jolloin
kasvatettaessa loppukuvaa suuremmaksi, ei päästä alkuperäisen kuvan laatutasoon. [20]
Jotta voimme paremmin ymmärtää digitaalikuvan muokkaamisen, digitaalikuva täytyy
pystyä esittämään matemaattisessa muodossa. Alla on digitaalikuvan matemaattinen
esitys, jolla voidaan muokata alkuperäistä kuvaa.
1 = 1 ∗ = 1 ∗ ,
= + = + !
13
Tässä [ v w 1 ] viittaa alkuperäiseen kuvaan ja T on transformaatiomatriisi, joka on
alkuperäisen ja lopullisen kuvan geometrinen muutos. Transformaatiomatriisi voidaan
käsittää koostuvan neljästä eri osasta. 2x2-kokoinen matriisi
"
#,
vastaa lineaarisesta muutoksesta rotaatiolle, skaalaukselle sekä horisontaaliselle että
vertikaaliselle kiertämiselle. Matriisilla [ ] voidaan siirtää kuvaa origon suhteen,
matriisi $ tuottaa perspektiivisen muutoksen ja vaikuttaa kuvan
skaalaukseen. [4,18,19]
Liitteissä 1 ja 2 on esitetty eri ohjelmointiympäristöihin soveltuvat ohjelmat, joilla
voidaan demonstroida seuraavia geometrisia operaatioita.
3.2.1.1
Siirto
Siirrossa jokainen kuvan pikseli siirretään uuteen positioon lopulliseen kuvaan.
Transformaatiomatriisi on muuten yksikkömatriisi, mutta alimatriisilla [ ]
pystytään parametrisoimaan kuvan siirto origon suhteen.
Kuva 8 siirto-operaation lopputulos
1
0
0
1
!
0
0 ,
1
= + = + !
Yllä olevan kuvan koko on 461x461, eli kuvassa on 461 pikseliä sekä leveys- että
korkeussuuntaan. Siirtomatriisissa käytetyt ja ! ovat 100.
3.2.1.2
Rotaatio
Rotaatiossa kaikki kuvan xy-pikselit siirretään origon suhteen kulman % verran. Monet
rotaatiofunktiot poikkeavat toisistaan siinä mitä pistettä kuvasta käytetään origona.
14
cos %
− sin %
0
sin %
cos %
0
0
= v ∗ cos % − ∗ sin %
0 , = ∗ sin % + ∗ sin %
1
Kuva 9 rotaatio-operaation lopputulos
3.2.1.3
Skaalaus
Tämä tarkoittaa, että jokainen pikseli skaalataan matriisista löytyvillä kertoimilla ja
! . Näinollen, kuvan kokoa muokataan kertoimien mukaan. Negatiivisilla kertoimilla
kuva voidaan peilata sekä samalla skaalataan kuvan kokoa pienemmäksi.
Kuva 10 skaalauksen jälkeinen lopputulos: ! = -1
0
0
0
!
0
0
0
1
,
= ∗ -
= ∗ !
Jos kertoimet ja ! eivät ole samansuuruisia, niin kuvan mittasuhteet muuttuvat
samassa suhteessa
3.2.1.4
Horisontaalinen/vertikaalinen kiertäminen
Koordinaatiston skaalaaminen rajoittui edellä ainoastaan diagonaalisiin termeihin ja
.
Sekä
horisontaalisesessa
että
vertikaalisessa
kiertämisessä
samat
diagonaalimuuttujat pysyvät vakiona = = 1. Sallimalla :n ja :n olla nollaarvosta poikkeavia, pystytään kuvaa kiertämään siten, että esimerkiksi x-arvot voidaan
asettaa olemaan lineaarisesti riippuvaisia v- sekä w-arvoista, kun y-arvo pysyy
identtisenä w-arvoon.
15
Kuva 11 kierto-operaation lopputulos
1
/
0
.
1
0
0
0 ,
1
= + ∗ - = ∗ / + .
Yllä oleva kuva on saatu käyttämällä siirtomatriisissa arvoja 0 ja 1.
[4]
3.2.2
Kuvan gradientti
Kuvan gradientti ilmaisee valon intensiteetin tai värin muutosta kuvassa. Gradienttien
avulla saadaan tietoa kuvassa esiintyvistä objekteista. Etenkin gradienttien avulla
pystytään määrittelemään kuvassa esiintyvien reunojen sijainti ja suunta.
Matemaattisesti gradientti esitetään seuraavan laisesti:
2 2
, 2 2
2
013 = , 0
2
2
014 = 0, 2
01 = ja edelleen gradientin suunta saadaan
2
2
5 = arctan 92 2
Digitaalikuva F[x,y] derivoidaan diskreetisti, ottaen äärellinen erotus
2
2
, ≈ ; + 1, − ;, Gradienteilla voidaan erottaa kuvasta erilaista tietoa. Gradienttikuvat muodostetaan
ottamalla jokaisesta alkuperäisen kuvan pikselin ympäristöstä gradientin
approksimaatio, tyypillisesti jollakin matriisifiltterillä. Yksinkertaisin näistä
suodattimista on Sobelin operaattori. Tyypillisemmin gradientteja käytetään reunojen
16
etsimiseen kuvasta. Kun jokaiselle kuvan pikselille on laskettu gradienttiarvot, näistä
suurimmat arvot omaavat gradientit edustavat mahdollisia reunoja kuvasta.
[5]
3.2.3
Kuvassa esiintyvät reunat
Reunat ovat suuria lokaaleja muutoksia kuvassa, mitkä esiintyvät kahden eri alueen
yhdistymäkohdassa. Tärkeät ominaisuudet pystytään erottamaan kuvasta reunojen
perusteella, esimerkiksi kulmat, suorat ja käyrät viivat. Näitä tietoja voidaan käyttää
korkean tason konenäköalgoritmeissa, esimerkiksi objektin tunnistamisessa. [6,8]
Reunan tunnistaminen tarkoittaa suuren epäjatkuvuuskohdan tunnistamista ja
paikantamista
kuvasta.
Epäjatkuvuuskohdat
ovat
äkillisiä
pikselin
intensiteettimuutoksia, jotka voidaan karakterisoida objektin reunaksi. Klassisimmat
reunantunnistusmetodit käsittelevät kuvaa 2D-suodattimella, joka on rakennettu
olemaan herkkä suurille gradienteille ja suodattamaan tasaiset alueet kuvasta. Tämän
tyylisiä algoritmeja on olemassa lukuisia ja jokainen näistä on viritetty olemaan herkkä
tietyn tyyppisille reunoille, esimerkiksi kulmille tai suorille reunoille.
Reunantunnistusoperaattorin geometrian perusteella karakterisoidaan suunta, jolle
operaattori on herkin. Operaattorit voidaan optimoida tarkastelemaan horisontaalisia,
vertikaalisia tai diagonaalisia reunoja. Reunan tunnistaminen on haastavaa kohinaisista
kuvista, koska sekä kohina että reunat sisältävät suuria pikseli-intensiteettimuutoksia.
Kohinaa voidaan tietysti suodattaa pois kuvasta, mutta tämä johtaa silloin siihen, että
kuvassa ilmenevät reunatkin sumentuvat ja vääristyvät. Suodattimet, joita käytetään
kohinaisissa kuvissa, ovat tyypillisesti suurempia, jotta ne pystyvät keräämään tarpeeksi
dataa erottaakseen kohinan aiheuttamat pikseliarvot. Tämä johtaa vähemmän tarkkaan
reunan paikallistamiseen. Kaikki reunat eivät välttämättä edes koostu askelmaisista
arvoaluemuutoksista intensiteettitasossa. Valon taittuminen tai kameran huono
tarkennus voi aiheuttaa sen, että objektien reunat voivat muuttua astemaisesti
intensiteettitasossa eivätkä äkillisesti suurina askelmina. Eli ongelmia reunojen
tunnistamisessa on: kohinan aiheuttamat häiriöt, todellisten reunojen havaitsematta
jättäminen, reunan paikallistaminen ja korkeat prosessointiajat tunnistamisessa. [1,7,8]
On olemassa monta eri tapaa kuinka reunat tunnistetaan. Suosituimmat
reunantunnistusmenetelmät ovat gradientti ja Laplacian. Gradienttimenetelmässä reunat
tunnistetaan etsimällä maksimi- ja minimiarvot kuvan ensimmäisen derivaatan avulla.
Laplacian-menetelmässä etsitään kuvasta otetun toisen derivaatan nollakohtaylitykset,
jonka perusteella voidaan todeta reunan olemassaolo. Digitaalisista kuvista reunan
tunnistaminen pystytään tekemään soveltamalla erilaisia suodatinmatriiseja kuvan
jokaisen pikselin ympäristölle. Suodatinmatriisit approksimoivat kuvalle derivaatan
arvoja, jolloin näiden perusteella voidaan todeta reunoihin liittyviä tietoja.
Approksimaatio saadaan seuraavanlaisesti:
17
1.
2.
3.
4.
Käydään kuvan jokaisen pikselin ympäristö läpi
Ympäristön laajuuden määrittää suodatinmatriisin dimensio
Suoritetaan pistetulo jokaiselle ympäristön pikselille suodatinmatriisin kanssa
Summataan pistetulon lopputulokset, jolloin saadaan approksimaatio pisteen
derivaatasta
5. Sijoitetaan saatu approksimaatio ulostulokuvaan alkuperäisen pikselin kohdalle
Kuva 12 Suodatinmatriisien derivaattaiaproksimaatiot
Yllä oleva algoritmi on toteutettu liitteessä 3 olevassa ohjelmassa. Ohjelman ulostulo on
nähtävissä kuvassa, johon on piirretty eri suodatinmatriisien palauttamat derivaatan
approksimaatiot. [1,6]
3.2.3.1
Gradienttimenetelmät
Robertin ristioperaatio on yksinkertaisin reunantunnistusoperaattori, jossa on kaksi 2x2
matriisifiltteriä x- ja y-suunnalle.
"
+1
0
0
#
−1
"
0
−1
+1
#
0
Yksinkertaisuutensa takia Robertin ristioperaatio on myös nopea laskettava. Robertin
ristioperaation ulostulo kuvastaa gradientin suuruuden arviota kuvan jokaisessa
pisteessä.
Sobel- sekä Prewitt-operaattorit koostuvat molemmat kahdesta 3x3 matriisifiltteristä.
Toinen filtteri on yksinkertaisesti käännetty 90 asteella. Se on muuten samanlainen kuin
Robertin ristioperaatio, mutta suodatinmatriisit ovat hieman suurempia ja arvot ovat
erisuuret.
18
−1
−2
−1
0
0
0
+1
+2
+1
+1
0
−1
+2 +1
0
0
−2 −1
−1
−1
−1
0
0
0
+1
+1
+1
+1
0
−1
+1 +1
0
0
−1 −1
Nämä matriisit on suunniteltu löytämään horisontaalisia ja vertikaalisia reunoja.
Matriiseja voidaan soveltaa kuvaan erikseen, jotta saadaan erilliset reunahavainnot
gradienttikomponenteista. Nämä reunahavainnot voidaan sitten yhdistää ja laskea
yhdistettyjen gradienttien suuruus kaavalla 2.
|> | = ?>
+ >! (2)
[1,5,7]
3.2.3.2
Laplacian-menetelmät
Gaussin Laplacian-menetelmä (Laplacian of Gaussian, LOG) laskee toisen asteen
derivaatan kuvalle. Menetelmä korostaa alueita, joissa intensiteettimuutos on suuri ja
tämän takia sitä käytetään reunantunnistuksessa. Laplacian-menetelmä on hyvin herkkä
kohinalle. Tämän takia menetelmää käytetään yleensä kohinasuodatettuun kuvaan.
Kohinasuodatuksessa käytetään tyypillisesti Gaussianin kohinasuodatinta.
Kuvan pikseli-intensiteettejä kuvataan funktiolla I(x,y), jolloin Laplacian L(x,y)
funktiolle on seuraava:
ABC
@, = A
B
ABC
+ A! B
(3)
Koska sisääntulokuva koostuu yksittäisistä pikseleistä, operaattorille täytyy löytää
matriisifiltteri, joka pystyy approksimoimaan toisen asteen derivaattaa, joka on
Laplacian-menetelmän määrittelyssä. Alla esitellään yksi yleisimmin käytetyistä
matriisifilttereistä.
−1
2
−1
2
8
2
−1
2
−1
Koska kyseinen konvoluutio-operaatio on assosiatiivinen, matriisifiltterin sekä Gaussin
kohinasuodattimen tulo voidaan laskea ensiksi ja tämän jälkeen tätä tulomatriisia
voidaan soveltaa alkuperäiselle kuvalle. Kyseinen optimointi vähentää huomattavasti
aritmeettisten operaatioiden suoritusten lukumäärää verrattuna filttereiden erilliseen
suorittamiseen kuvalle. [6]
19
@E> , = −
0
1
0
1
−4
1
"1 −
FG H
B I! B
G B
#J
K
LB MNB
BOB
(4)
0
1
0
Canny-algoritmi tunnetaan parhaiten optimaalisimpana reunantunnistusalgoritmina. Sen
kehitti John F. Canny vuonna 1986. Algoritmi pystyy tunnistamaan monenlaisia reunoja
kuvista. Cannyn ajatuksena oli kehittää olemassa olevia reunantunnistusmetodeja ja
aiheesta voi lukea lisää hänen tutkielmastaan: ”A Computational Approach to Edge
Detection” [3]. Tutkielmassaan hän listasi aiheita, joita tuli kehittää olemassa olevissa
algoritmeissa. Ensisijaisesti hän pyrki saavuttamaan alhaista virhesuhdetta
tunnistamisessa. Tämän hän aloitti minimoimalla olemattomien reunojen tunnistamisen
sekä maksimoimalla todellisten reunojen tunnistamisen. Toinen asia, jota hän pyrki
kehittämään oli reunan pikselipisteiden lokalisointi. Tunnistettujen pisteiden ja kuvassa
esiintyvän reunan etäisyys tuli olla minimissään. Kolmas asia oli saavuttaa yksi
tunnistettu reuna vastaamaan yhtä kuvassa esiintyvää reunaa. Tämä oli oleellista, koska
kaksi ensimmäistä aihetta, joita hän pyrki saavuttamaan, eivät ottaneet kantaa tähän
kolmanteen ongelmaan. [3,5,7]
20
4
VANHA JÄRJESTELMÄ
Muutama vuosi sitten Jomet Oy:ssä päätettiin panostaa pakkauskoneen
videovalvontajärjestelmään. Tämän ideana oli parantaa koneen virhediagnostiikkaa ja
helpottaa virheiden alkuperän löytämistä. Järjestelmän toimintaperiaate on hyvin
yksinkertainen: tietokone pitää tallessa 30 minuutin videohistoriaa pakkauskoneen
toiminnasta. Virhetilanteen sattuessa, kymmenen viimeisintä minuuttia kopioidaan
puskurista pysyvään muistiin.
4.1
Virheiden havaitseminen
Tällä hetkellä virheiden havaitseminen on toteutettu logiikkayksikön toimesta.
Pakkauskoneessa on tyypillisesti venttiili- ja moottoriliikkeitä. Virhetilanteet havaitaan
molemmista liikkeistä eri tavalla. Venttiililiikkeeltä löytyy tyypillisesti liikkeen etusekä takaraja. Kun PLC ohjaa venttiiliä eteen, niin eturajan on tultava päälle tietyn ajan
kuluessa, muuten PLC tulkitsee venttiililiikkeen suorituksen epäonnistuneeksi eli
virheeksi. Moottoriliikkeiden virheiden havaitseminen tapahtuu moottorin
taajuusmuuttajassa, jos kyseessä on servomoottori, niin servo-ohjaimessa. Logiikka,
taajuusmuuntaja ja servo-ohjain on kytketty toisiinsa Ethercat-kaapelilla, jolla välitetään
moottoreiden virhetiedot logiikkayksikölle.
4.2
Kommunikaatio
Fyysinen yhteys PLC:n ja kamerajärjestelmän välillä on toteutettu Ethernet-kaapelilla.
Kamerajärjestelmä luo sisäisen palvelimen, johon PLC voi luoda asiakaspohjaisen
yhteyden. Yhteyden avulla välitetään tietoa pakkauskoneessa tapahtuvista virheistä
kamerajärjestelmälle.
4.3
Reagointi virheeseen
Virhetilanteen tapahtuessa, kamerajärjestelmä vastaanottaa sitä vastaavan viestin
palvelinohjelmassaan. Viestin vastaanottaminen signaloi videoita nauhoittavalle
ohjelmalle, että videoiden tallentaminen tiedostoihin voidaan lopettaa 10 s kuluttua.
Tällä toiminnolla pyritään varmistamaan, että virhetilanteen mahdolliset seuraukset
tulisivat myös videolle, jos jotakin vakavaa tapahtuisi. Ohjelma, joka luo videotiedoston
kameralta tulevasta virrasta, tallentaa 30 minuutin jatkuvaa videotiedostoa eräänlaiseen
rengaspuskuriin. Tämän ideana on, että 30 minuutin jälkeen tallennuksen aloituksesta
vanhin videomateriaali korvataan uudemmalla. Tällöin videotiedosto
21
sisältää ainoastaan 30 viimeisintä minuuttia.
4.3.1
Tiedon siirtäminen pilvipalveluun
Pilvipalveluna kamerajärjestelmässä käytetään Google Drive-palvelua. Google Datakirjasto sisältää Googlen kehittämän protokollan, jolla pystytään lukemaan ja
kirjoittamaan dataa Googlen palvelimille. Kirjastoa pystyy käyttämään seuraavilla
kielillä:
•
•
•
•
•
•
Java
Javascript
.NET:n tukemat kielet
PHP
Python
Objective-C
Järjestelmässä käytetään Google Data Python Client-kirjastoa. Jokainen kirjasto tarjoaa
kuitenkin samanlaiset mahdollisuudet käyttää Googlen palveluita. Kirjastot ovat myös
avointa lähdekoodia.
[16]
22
5
TOTEUTUS
Alkuperäinen järjestelmä on vastaanotettu varsin hyvin eri asiakkailla ja he ovat olleet
tyytyväisiä ripeään virheiden diagnosointiin ja niiden poistamiseen. Näiden
innoittamana järjestelmää halutaan kehittää eteenpäin. Ensimmäinen kehityskohde on
järjestelmän suorittaminen kevyemmällä alustalla kuin tehokkaalla pöytäkoneella.
Toinen fokus on kehittää järjestelmää olemaan interaktiivinen PLC:n kanssa.
Työn teknisenä kontribuutiona tutkittiin kuinka pienellä alustalla vanhaa järjestelmää
voidaan suorittaa sekä toteutettiin yksinkertainen konenäön opetussovellus.
Opetussovelluksen toteutuksen tarkoituksena oli myös tutkia, minkälaisia
mahdollisuuksia konenäkösovellukset voivat antaa ja kuinka paljon työtä ja vaivaa ne
mahdollisesti vaativat.
5.1
Kevyet kehitysalustat
Tämän päivän markkinoilla jatkuvan kasvun prosessoreiden suorituskyvyissä sekä
näiden laskevan hintatason johdosta sovelluskehittäjät voivat suunnitella erittäin
kehittyneitä ratkaisuja erilaisiin sovelluksiin. Samalla kun sovellukset kehittyvät,
suunnitelmat monimutkaistuvat ja nämä ongelmat voivat aiheuttaa pullonkauloja
kehittäjille. Pullonkaulat ilmenevät tyypillisesti pidempinä kehitysaikoina, yhä
monimutkaisempina kehitysympäristöinä ja sovellusten laadun ja vakauden ongelmina.
Kehittäjät voivat käsitellä näitä ongelmia käyttämällä kehittyneitä kirjastoja, kuten
OpenCV. Siirrettäessä sovellusta sulautettuun alustaan, mukana tulee ryhmä uusia
haasteita, muun muassa: C++-koodin toteuttaminen, muistin asettamat rajoitteet,
liukulukulaskenta sekä alustan laitteiston 100 % hyödyntäminen.
Konenäkösovellusten jatkuva lisääntyminen asettaa ristiriitaisia vaatimuksia
sulautetuiden alustojen kehittäjille. Kehittyneet konenäköalgoritmit vaativat yhä
enemmän muistia ja prosessointitehoa, mutta järjestelmien hintojen ja tehonkulutuksen
pitää olla mahdollisimman alhaiset.
Yksi tyypillisimpiä teollisuuden konenäkötehtäviä on tuotantolinjan tarkastelu, joka
havaitsee, luokittelee ja suodattaa objekteja maksimoidakseen tuotannon nopeutta ja
laatua. Tyypillisesti konenäköalgoritmit suoritetaan kalliilla ja tehokkailla tietokoneilla.
Videovalvontasovellukset tarjoavat toisen näkökulman konenäön kehitykseen.
Tavanomaisimmat valvontajärjestelmät eivät ole kiinnostuneita kuvan analyysistä, vaan
23
ne on suunniteltu enimmäkseen koodaamaan ja tallentamaan videovirtaa. Joka
tapauksessa, konenäköalgoritmit kehittyvät ja videovalvontaan yhdistetään yhä
enemmän automatisoitua monitorointia ja analysointia tallennettuun videoon.
Algoritmien kehittyessä luotettavammiksi ja nopeammiksi, valvontajärjestelmät tulevat
automaattisemmiksi ja kehittyneemmiksi. Tämä asettaa tietynlaisen haasteen
sulautetulle videovalvontajärjestelmälle. Koska tuoreimmat algoritmit on kehitetty
tehokkaille tietokoneille, huomattavaa lisätyötä ja optimointia voidaan vaatia, jotta
sovellus toimii tehokkaasti sulautetulla laitteella. Näinollen, monet sulautetut
kamerajärjestelmät pysyttäytyvät yksinkertaisemmassa ’koodaa ja tallenna’-mallissa.
Prosessorin arkkitehtuurin lisäksi muistin asettamat rajoitteet ja erityiset vaatimukset
deterministiselle ja reaaliaikaiselle toiminnalle aiheuttavat haasteita sulautetun
järjestelmän suunnittelulle. Moniytimiset laitteet alkavat olla aiempaa yleisempiä
sulautetuissa laitteissa. Sulautetut moniydinlaitteet saattavat koostua homogeenisistä
ytimistä, esimerkiksi dual-ARM-laitteet. Ne voivat myös yhdistää ARM-prosessorin
heterogeenisen ytimen kanssa, esimerkiksi DSP:n tai GPU:n. Monet OpenCV-kirjaston
funktioista hyötyvät paljon, kun käytetään erikoisprosessointiytimiä, vektori- tai
liukulukukiihdyttimiä.
Algoritmi, jota voidaan helposti ajaa rinnakkaisesti, voi olla hyvä ajettavaksi GPU:lla.
Konenäkö- ja kuvankäsittelyalgoritmit, joita ei pysty suorittamaan rinnakkaisesti, mutta
jotka silti vaativat intensiivistä liukulukulaskentaa, saattavat sopeutua paremmin DSPyksikölle. Matalan tason kuvankäsittelyfunktiot, esimerkiksi väriavaruuden vaihtaminen
ja kohinan suodattaminen soveltuvat tyypillisesti suoritettavaksi komponentilla, joka on
suunniteltu vain yhtä toimintoa varten, esimerkiksi FPGA:lla (Field Programmable
Gate Array) tai ASIC-piirillä (Application Specific Integrated Circuit). Sulautetut
laitteet, jotka sallivat sovelluskehittäjän jakaa tehokkaasti sovelluksen (esimerkiksi
OpenCV-sovellus) suorituksen
heterogeenisten
komponenteille,
saavuttavat
ylivoimaisen suorituskyvyn. [13]
Jaetun muistin tehokas käyttäminen ja jakaminen ovat yksi sulautetun järjestelmän
kehityksen haasteista. Monet nykypäivän sovelluksista vaativat kokonaisen
käyttöjärjestelmän, jolla on oma jalanjälki muistissa. Tämän takia muistinhallinnasta
tulee vieläkin tärkeämpää. Sulautettu konenäkösovellus, joka käyttää OpenCV-kirjastoa,
vaatii kohtuullisen suuren muistin riittävän suurella kaistanleveydellä ja hakuajalla.
Tämä siksi, jotta voidaan tarjota puskurit ja ohjelman data useille toisiinsa liittyville
tehtäville: datan hankkiminen, prosessointi ja tallentaminen tai ulostulon esittäminen.
Sulautetut moniydinprosessorit tarjoavat paremman suorituskyvyn kasvattamalla
prosessointitehoa, joka on sovellusten käytettävissä. Suurimmat haasteet tulevat
vastaan, kun kehittäjät haluavat hyväksikäyttää tuota prosessointitehoa kiihdyttääkseen
OpenCV:n suoritusta. Suurin haaste, kun siirrytään moniydinmalliin, on ohjelman
24
kokonaisuuden jakaminen osiin ja suorituksen jakaminen eri ytimille.
Yksinkertaisimmassa tapauksessa järjestelmä koostuu kahdesta ARM-ytimestä. Tällöin
ongelman lähestymistapana on kirjoittaa sovellus aivan kuin yksiytimiselle alustalle ja
sitten jakaa sovelluksen osia suoritettavaksi toiselle ytimelle. Oleellinen kriteeri
tehtävän suorittamisen siirtämisessä ytimeltä toiselle on prosessoreiden välisen
kommunikaation (Inter-Processor Communication, IPC) ajan kulutus. Suorituksen
jakaminen toiselle ytimelle on ainoastaan mielekästä, jos IPC-viestien lähettämiseen ja
vastaanottamiseen kuluva aika ei ylitä aikaa, joka on säästetty, kun prosessointikuorma
on jaettu kyseiselle ytimelle.
Monisäikeiset sovellukset vaativat erityistä käsittelyä, jotta tehtäviä jaetaan ytimille
oikein ja tehokkaasti. Rinnakkaisuuden tuoma suorituskyvyn parannus useissa
konenäköalgoritmeissa on rajoitettu, koska tyypillisesti algoritmeja suoritetaan
sarjallisesti, eli seuraavaa operaatiota ei voida aloittaa ennen kuin edellinen operaatio on
valmistunut. [13]
5.2
Vanhan järjestelmän kehittäminen
Ohjelmiston vaatimusmäärittelyssä kuvataan ohjelmiston tavoitteet ja vaatimukset.
Tässä kuvataan kuinka ohjelmiston tulisi toimia ja kuinka nämä toiminnallisuudet
yleisellä tasolla saavutetaan.
5.2.1
Vaatimukset
1. Yleiset vaatimukset
1.1 Sovelluksen pitää olla helppokäyttöinen
1.2 Sovelluksen täytyy olla yhteensopiva edeltävän järjestelmän kanssa
1.3 Käyttöönotto ei vaadi erillistä koulutusta
1.4 Sovelluksessa pitää olla eri käyttäjätasoja
2. Kamerajärjestelmän vaatimukset
2.1 Sovellukseen pitää pystyä luomaan tarkistustoimintoja
2.2 Tarkistustoimintoja pitää pystyä tallentamaan
2.3 Sovelluksen pitää pystyä hallitsemaan useita tarkistustoimintoja
2.4 Järjestelmästä pitää löytyä eri toimintatilat
2.5 Järjestelmän pitää pystyä välittämään binääritiedolla tarkistustomintojen
suorituksen totuusarvon
3. Työkalun vaatimukset
3.1 Seuraavien ominaisuuksien pitää olla tuettuja
3.1.1 Värin erottaminen kuvasta
3.1.2 Käyttäjän määrittämä alueopetus
3.1.3 Automaattinen alueopetus
3.1.4 Viivakoodi
4. Kommunikaation vaatimukset
25
4.1 Kommunikointi voidaan toteuttaa asiakas- tai palvelinsovelluksena
4.1.1 Portti pitää pystyä määrittämään erikseen
4.1.2 Asiakas-vaihtoehdossa, IP-osoite pitää pystyä määrittämään
5.2.2
Käyttötapaukset
Sovelluksen käyttäminen on jaettu ainoastaan yhdelle käyttäjäryhmälle. Käyttäjä pystyy
tekemään järjestelmän konfiguroinnin, kun hän on kirjautunut onnistuneesti
järjestelmään. Kuvassa 13 on esitelty vaatimusten perusteella tehty käyttötapauskaavio.
Kaaviossa on esitelty neljä erillistä päätapausta, jotka kaikki vaativat
käyttäjähallintatapahtuman onnistuneen suorituksen.
Kuva 13 kamerajärjestelmän käyttötapauskaavio
Järjestelmän tilan vaihtaminen
Sovellus sisältää kolme erilaista tilaa: Overview, Teach ja Run. Overview-tilalla
mallinnetaan sovelluksen joutokäyntiä, eli sovellusta suoritetaan kevyellä kuormalla.
Teach-tilassa käyttäjällä on mahdollisuus opettaa uusia työkaluja järjestelmään. Runtilassa sovelluksen suorituskuorma on suurin, sovellus käyttää aktivoituja työkaluja
kuvankäsittelyprosesseissaan ja generoi näiden avulla lopputuloksen.
26
Oletuksena järjestelmä on Overview-tilassa. Jos käyttäjä on onnistuneesti kirjautunut
järjestelmään, hän voi asettaa haluamansa tilan ”Operation mode”-pudotusvalikosta,
kun hän haluaa aktivoida kyseisen tilan käyttöönsä, hän painaa ”Change mode”näppäintä.
Onnistuminen:
Käyttäjä pystyy vaihtamaan onnistuneesti järjestelmän tilan.
Virhetilanteet:
Mikäli käyttäjä ei ole kirjautuneena sisään, niin ”Change mode”-näppäin ei ole
aktivoituna, eikä käyttäjän painalluksiin reagoida.
Jos käyttäjä yrittää vaihtaa tilan samaksi, jossa järjestelmä jo on, niin ”Change mode”näppäimen painalluksiin ei reagoida.
Menu-toimnnot
Sovelluksessa on menu-navigointi-ikkuna, joka sisältää Open-, Save- ja Exit-toiminnot.
Navigointi-ikkuna sijaitsee sovelluksen vasemmassa yläosassa. Painamalla ”File”välilehteä avautuu valikko, jossa on kyseiset vaihtoehdot. Open-toiminto avaa
tiedostodialogin, johon käyttäjä voi syöttää olemassa olevaa työkalua vastaavan
tiedoston. Save-toiminnolla pystytään tallentamaan opetuksessa oleva työkalu
tiedostomuotoon. Exit-toiminto lopettaa sovelluksen toiminnan.
Painamalla vaihtoehtoa ”File Save” avautuu tiedostodialogi tallennusta varten.
Käyttäjä pystyy navigoimaan itsensä haluamaansa polkuun sekä antamaan työkalulle
haluamansa nimen. Vaihtoehdossa ”File Exit”, graafinen käyttöliittymä suljetaan ja
sovellus suorittaa tarvittavat puhdistustoimenpiteet taustalla.
Onnistuminen:
Käyttäjä avaa onnistuneesti olemassa olevan työkalun muokattavaksi.
Käyttäjä tallentaa onnistuneesti opetuksessa olevan työkalun tiedostomuotoon.
Käyttäjä lopettaa sovelluksen toiminnan onnistuneesti.
Virhetilanteet:
Mikäli käyttäjä ei ole kirjautuneena sisään, niin vaihtoehdot Open ja Save eivät ole
aktivoituna, eikä käyttäjän painalluksiin reagoida.
Käyttäjän syöttäessä virheellisiä nimiä tiedostodialogiin, niin niihin reagoidaan
virheilmoituksella, joka ilmestyy näytölle: ”Name error!”.
27
Jos käyttäjällä on keskeneräinen työkalu suljettaessa käyttöliittymää, näytölle avautuu
kyselyikkuna: ”Do you want to save changes you made to unnamed.tool?”.
Työkalun opettaminen
Ohjelmasta löytyy kaksi erilaista tilaa opetusta varten. On mahdollisuus opettaa offlinetilassa tai reaaliaikaisesta videovirrasta. Offline-tila tarkoittaa, että koneen toimintaa on
tallennettu videotiedostoon ja opetusprosessi tehdään tälle videotiedostolle.
Tällä hetkellä opetettaviksi ominaisuuksiksi on määritelty väri, alue, automaatti ja
viivakoodi. Väriominaisuudella pystytään erottamaan tietty RGB-arvoväli kuvasta
minimi- ja maksimiarvojen avulla, jolloin lopputuloksena on binäärikuva, jossa on
valkoisella kaikki pikselit, jotka sopivat määriteltyyn arvoväliin. Alueominaisuudella,
käyttäjä voi määrittää itse alueen, jossa liikettä saa tapahtua. Pikselien suuret
arvomuutokset
saavat
tapahtua
ainoastaan
edellämainitulla
alueella.
Automaattiominaisuus
rajaa
alueen,
joka
muuttuu
opetuksen
aikana.
Viivakoodiominaisuus vaatii käyttäjää rajaamaan alueen, josta yritetään selvittää
viivakoodin sisältö.
Työkalua ei ole pakko tallentaa, mutta jos halutaan käyttää lukuisia työkaluja, niin ne
pitää tallentaa erillisiksi tiedostoiksi. Jos käytössä on ainoastaan yksi työkalu, niin
tallennusta ei vaadita. Siirryttäessä Run-tilaan ja jos työkalu on opetettu, niin se otetaan
automaattisesti käyttöön, ellei järjestelmälle ole opetettu jo jotakin muuta työkalua.
Onnistuminen:
Käyttäjä onnistuu opettamaan uuden työkalun.
Virhetilanteet:
Mikäli käyttäjä ei ole kirjautuneena sisään, opetustyökalut eivät ole aktivoituna, eikä
käyttäjän painalluksiin reagoida.
Kommunikointiasetusten vaihtaminen
Kommunikointia varten sovellukseen on lisätty vaihtoehdot asiakkaan ja palvelimen
välille. Asiakas-mallissa asiakas luonnollisesti ottaa yhteyden palvelimeen, jolloin
tarvitsee tietää IP-osoite, porttinumero ja verkkomaski. Palvelimella määritetään
ainoastaan porttinumero, jonka läpi asiakkaat voivat muodostaa yhteyden.
Onnistuminen:
Käyttäjä pystyy asettamaan onnistuneesti järjestelmän kommunikointiasetukset.
28
Virhetilanteet:
Mikäli käyttäjä ei ole kirjautuneena sisään, niin kommunikointiasetukset eivät ole
aktivoituna, eikä käyttäjän painalluksiin reagoida.
Jos käyttäjä syöttää viallisia arvoja asetuksiin, niistä ilmaistaan virheilmoituksella:
”Error: Invalid parameters!”.
Käyttäjähallinta login/logout
Sovellus vaatii, että suoritetaan kirjautuminen. Kirjautumisen avulla voidaan varmentaa,
että sovelluksen avulla tehtävät muutokset ovat oikean henkilön tekemiä. Kuvassa x
esitetään näkymä, johon syötetään käyttäjänimi sekä salasana.
Kuva 14 JometCV-sovelluksen kirjautumisdialogi
Jos kirjautuminen keskeytetään Abort-näppäimellä tai kirjautuminen epäonnistuu jonkin
muun syyn takia, suurin osa sovelluksen käyttöliittymäkomponenteista ei aktivoidu.
Kirjautumisen dialogi on mahdollista saada jälleen esiin Help-valikosta. Painamalla
sovellusikkunan yläreunasta olevaa Help-valikkoa avautuu valikko, jossa on Contents,
About ja Login. Painamalla ”Help Login”, avautuu sama näkymä kuin kuvassa 14.
Onnistuminen:
Käyttäjä kirjautuu onnistuneesti järjestelmään sisään.
Virhetilanteet:
Mikäli käyttäjätunnus tai salasana on virheellinen, niin näytölle ilmestyy virheilmoitus:
”Username doesn’t exist!” tai ”Username or password was incorrect!”.
5.2.3
5.2.3.1
Käytetyt kirjastot
Qt
Qt on poikkialustainen kehityskehys, joka on kirjoitettu C++-kielellä. Alun perin se
suunniteltiin käyttöliittymäohjelmointia varten, mutta nyt sen avulla pystytään tekemään
paljon muutakin:
29
•
•
•
•
•
•
•
Tietokannat
XML
WebKit
Multimedia
Verkottuminen
OpenGL
Konsolisovellukset
Qt koostuu moduuleista, joilla jokaisella on samanlainen API (Application
Programming Interface). Qt laajentaa C++-kieltä makroilla ja introspektiolla.
Lopullinen Qt-sovellus on kuitenkin aina muutettu C++-kielelle. Tarkoituksena on
kääntää yhdestä lähdekoodista alustariippumaton loppusovellus. Tämän avulla
pystytään rakentamaan natiiveja sovelluksia, joilla on natiivi ulkonäkö sekä tuntuma.
Kohdealustat:
•
•
•
•
•
•
•
Windows
Mac OS X
Linux/UNIX X11
Windows CE
Symbian
Maemo
Sulautettu Linux
QtObject-luokka on käytännössä jokaisen Qt-luokan ja –widgetin kantaluokka.
QtObject-luokka sisältää suurimman osan mekanismeista, jotka tekevät Qt:n
(tapahtumat, signaalit ja slotit, ominaisuudet sekä muistinhallinnan). Lisäksi QtObjectluokasta periytyneiden luokkien instanssit sisältävät metaolion. Kyseinen metaolio
tietää luokkansa nimen, periytymissuhteensa, ominaisuutensa, signaalit ja slottinsa sekä
yleisen informaation luokastaan. Metaolio luodaan käännösvaiheessa, jonka suorittaa
Qt:n MOC (Meta Object Compiler). MOC hakee tietoja *.h-tiedostoista ja luo niiden
avulla moc_*.cpp-tiedostoja, jotka käännetään lopuksi *.cpp- ja *.h-tiedostojen lisäksi
objektikoodiksi.
Signaalit ja slotit ovat Qt:n oma dynaaminen ja kevyehkö tapa sitoa tapahtumia ja tilan
muutoksia reaktioilla. Muut ympäristöt tarjoavat normaalisti callback-toiminnon, jolla
reagoidaan samalla tapaa tapahtumiin ja tilan muutoksiin. Callback on funktio-osoitin,
jota kutsutaan kun tapahtuma tapahtuu. Mikä tahansa funktio voidaan asettaa callbackfunktioksi. Callback-funktiot eivät kuitenkaan tarjoa minkäänlaista tyyppiturvallisuutta
ja toimivat aina suorana funktiokutsuna. Signaalit ja slotit tarjoavat kuitenkin
huomattavasti dynaamisemman ja geneerisemmän ratkaisun callback-funktioihin
30
verrattuna. Näiden avulla kahden eri luokan toimintojen yhdistäminen on huomattavasti
helpompaa kuin callback-funktioilla.
Signaalit määritellään C++-koodissa Qt:n oman varatun sanan alaisuuteen.
Esittelytiedostoista löytyy signals: -lohko, johon voidaan määritellä luokan lähettämiä
signaaleita. Signaaleita ei ole kuitenkaan pakko toteuttaa, koska MOC pystyy luomaan
myös näiden toteutuksen. Signaaleilla ei ole koskaan mitään paluuarvoa, eli
signaalifunktioiden tyyppi on void. Qt ei ole rajoittanut mitenkään slottien määrää,
joihin signaali voidaan yhdistää. Signaalit lähetetään varatulla sanalla emit. Yleisesti
signaalin lähettäminen aiheuttaa suoran funktiokutsun, mutta signaali voidaan myös
välittää tapahtumana säikeiden välillä.
Slotit ovat funktioita, jotka vastaanottavat signaaleita. Nämä määritellään *.htiedostossa slots:-sanan alle. Sloteilla on myös kolme eri näkyvyysaluetta: public,
protected ja private. Eli *.h-tiedostossa slotteja määritellessä pitää esitellä myös slotin
näkyvyysalue, joten slots: ei yksinään riitä. Slotit voivat palauttaa paluuarvoja, mutta
eivät signaali-slot-yhdistyksessä. Slot voi vastaanottaa määrittämättömän määrän
signaaleita ja toteutus vastaa luokan jäsenfunktiota sekä niitä voidaan kutsua samalla
lailla kuin muita luokan jäsenfunktioita. Jos useita slotteja on kytketty signaaliin, niin
slottien suoritusjärjestys on satunnainen.
Yhdiste signaalien ja slottien välillä on toteutettu QObject-luokassa. Jotta luokkien
instanssit pystyvät kommunikoimaan toistensa kanssa, ne pitää yhdistää tällä funktiolla.
Alla on funktion esittely, jota kutsumalla luodaan yhdiste, jos yhdiste luodaan
onnistuneesti, funktio palauttaa arvon tosi, muussa tapauksessa arvon epätosi. Qt pystyy
luomaan yhdisteitä signaalien ja slottien välillä, vaikka näiden parametrivälitys ei
täsmää. Ainoana rajoitteena on, että slot-funktiossa ei saa olla enempää parametreja
kuin signaalissa, koska Qt ei pysty luomaan arvoja tyhjästä.
bool QObject::connect( const QObject * sender, const char * signal, const QObject *
recv, const char * method, Qt::ConnectionType type = Qt::AutoConnection ) [static]
5.2.3.2
OpenCV
OpenCV (Open Computer Vision) on ilmainen ja avoimen lähdekoodin
konenäkökirjasto, jolla on BSD-lisenssi (Berkley Software Distribution). Kirjaston
kehittämisen aloitti Intel vuonna 1999. Kirjasto on kirjoitettu C++:lla, mutta sitä
voidaan käyttää lukuisilla eri ohjelmointikielillä. Kirjasto mahdollistaa reaaliaikaisen
konenäön toteuttamisen käytännössä alustalla kuin alustalla, eli kirjasto on yhteensopiva
useimmilla PC- ja mobiilikäyttöjärjestelmillä. Tuhannet kehittäjät käyttävät OpenCV:tä
konenäkösovellustensa ytimenä, mikä tekee OpenCV-kirjastosta suosituimman
konenäkökirjaston. OpenCV-kirjastoprojekti on käynnissä oleva kehitysprojekti, jossa
31
säännölliset päivitykset pyrkivät kehittämään ja korjaamaan olemassa olevia ongelmia.
Pääasiallinen kehitys on kohdistettu x86-arkkitehtuurille. Kirjasto tukee myös ohjelman
kiihdytystä Intelin omalla IPP-kirjastolla (Integrated Performance Primitives).
Viimeisimmät päivitykset ovat lisänneet myös OpenCV-kirjastoon GPU-suorittimen
(Graphics Processing Unit) hyväksikäytön. Kiihdytyksessä käytetään NVidian
kehittämää CUDA-standardia (Compute Unified Device Architecture). [2]
OpenCV:n suurin vahvuus on sen laaja algoritmikanta, joka sisältyy sen normaaliin
jakelupakkaukseen. OpenCV:n toiminnollisuudet, kuva 15, jakautuvat kuvan
pikselitason suodattamisesta ja muuttamisesta aina monimutkaisiin ominaisuuksien
analyyseihin ja koneoppimisen toiminnollisuuksiin.
Kuva 15 OpenCV:n ominaisuuksia [21]
Huolimatta siitä, että OpenCV oli alun perin suunniteltu työpöytäkäyttöiseen
tietokoneeseen, OpenCV on hyödyllinen työkalu myös sulautetussa alustassa. Osa
laitevalmistajista tarjoaa kirjastoja sulautetuille järjestelmille. Nämä kirjastot pystyvät
suorittamaan osan OpenCV:n tarjoamista algoritmeista, mutta vain harvat pystyvät
tarjoamaan yhtä kattavan algoritmikannan kuin OpenCV. OpenCV on siirretty jo ARMarkkitehtuuriin, joka on suosittu CPU-valinta sulautettujen alustojen keskuudessa.
Työpöytäympäristöön suunniteltu OpenCV-ohjelma voidaan siis kääntää sulautettuun
ARM-ympäristöön. Sovellus ei välttämättä toimi samalla lailla sulautetussa
32
järjestelmässä kuin työpöytäympäristössä, koska sulautettu järjestelmä käyttää
normaalisti vähemmän muistia sekä järjestelmän suorituskyky saattaa olla muutenkin
alhaisempi. Jotta OpenCV:tä voidaan käyttää sulautetussa järjestelmässä sulavasti,
muutamat esteet pitää selvittää, jotta saavutetaan hyväksyttävä suorituskyky sulautetulla
järjestelmällä. [2]
Koska OpenCV on avointa lähdekoodia ja kirjoitettu kokonaan C/C++:lla, kirjasto on
käännetty ja siirretty monelle erilaiselle alustalle. Käännösprosessi ei kuitenkaan yksin
välttämättä riitä siihen, että saavutetaan reaaliaikaisuus kyseisellä alustalla. Kirjaston
koodin uudelleenkirjoittaminen ja optimointi uudelle alustalle vaatisi valtavan
työmäärän. Alustakohtaiset optimoivat kääntäjät ovat oleellisia tämäntyylisten
ongelmien ratkaisuissa. GCC-kääntäjä (GNU Compiler Collection) on yksi esimerkki,
joka on onnistunut kääntämään OpenCV-kirjaston ARM-alustalle. GCC-kääntäjä on
vahvasti keskittynyt C-kieleen ja osaa optimoida C++-kieltä. OpenCV:n tämänhetkinen
versio rakentuu vahvasti C++-kielen STL-säilöihin (Standard Template Library), niin
kuin GCC ja C99-laajennokset, mitä monet sulautettujen alustojen kääntäjät eivät tue.
Jos sulautetun alustan kääntäjä pystyy kääntämään ainoastaan C-koodia, niin OpenCV
täytyy palauttaa aina 1.1 versioon tai aikaisempaan, koska nämä versiot on kirjoitettu
melkein täysin C-kielellä. Versio 1.1 ei tietenkään sisällä uusien versioiden kehittyneitä
algoritmejä, joten versiopalautus aiheuttaa varmasti ongelmia. OpenCV:n lähdekoodi
sisältää monia alatason optimointeja x86-prosessoreille. Nämä optimoinnit eivät
kuitenkaan ole käytettävissä ARM-prosessoreissa tai DSP-alustoissa. Optimoinnit on
kuitenkin mahdollista korvata laitekohtaisilla kirjastoilla tai olennaisilla funktioilla,
jotka hyödyntävät arkkitehtuurikohtaisia atomisia käskyjä, SIMD-käskyjä
nopeuttaakseen koodin suoritusta. OpenCV:n ohjelmointirajapinta mahdollistaa usein,
että data voidaan välittää monessa eri muodossa funktioille. Tämä voi monimutkistaa
näiden funktioiden optimointia uusille alustoille. Rajoittamalla nämä funktiot
toimimaan ainoastaan yhdellä tietotyypillä, mahdollistaa sen, että kääntäjä generoi
yksinkertaisempaa ja tehokkaampaa koodia. Lisäksi, käyttämällä inline-avainsanaa
pienissä, usein toistuvissa funktioissa voi myös kasvattaa suorituskykyä korkean tason
konenäköfunktioilla. [2]
Optimointi sulautettuihin alustoihin tarkoittaa usein laitekohtaisen assembly-koodin
hyväksikäyttöä alkuperäisessä koodissa. Onneksi sulautetut prosessorit ovat kehittyneet
monimutkaisemmiksi, samalla kehitystyökalut ovat tulleet tehokkaammiksi ja
käyttäjäystävällisemmäksi. Useimmat valmistajat sulautetuissa järjestelmissä tarjoavat
optimoituja kirjastoja, jotka ovat käsinkirjoitettu tarjoamaan parhaan suorituskyvyn
matalan tason matematiikalle, kuvan ja konenäön funktioille. OpenCV-kirjaston
yhdistäminen näihin valmistajan tarjoamiin kirjastoihin voi kiihdyttää huomattavasti
korkean tason OpenCV:n ohjelmointirajapintaa.
33
Muutamat yritykset tarjoavat konenäkö- ja kuvankäsittelykirjastoja, joilla voidaan
korvata osa OpenCV:n funktioiden koodin osista tai joissakin tapauksissa koko funktio.
Lisäksi optimoitua matematiikkakirjastoa voi käyttää kasvattaakseen OpenCV:n
funktioiden suorituskykyä. Käyttämällä näitä optimoituja kirjastoja OpenCV:n
ohjelmointirajapinnassa,
voidaan
maksimoida
suorituskyky
hyödyntämällä
arkkitehtuurikohtaisia ominaisuuksia, kuitenkin säilyttämällä standardin rajapinta
korkean tason ohjelmistoon. Toisin sanoen, nämä matalan tason kirjastot voivat
kiihdyttää OpenCV-kirjaston funktioita rikkomatta olemassa olevan sovelluksen koodia,
joka on kirjoitettu OpenCV:n ohjelmointirajapinnalla.
Toinen usein kohdattu ongelma käyttäessä OpenCV-kirjaston funktioita, on se, miten
sulautetun prosessorin ympäristö suhtautuu liukulukujen käsittelyyn. Tämä tuo
huomattavan ongelman käytettäessä OpenCV-kirjastoa, koska se sisällyttää lukuisia
kuvankäsittelyfunktiota, jotka tukeutuvat vahvasti liukulukuaritmetiikkaan. OpenCV
tukee monenlaisia kuvatyyppejä, jotka sisältävät myös liukulukuesitykset. Monet
OpenCV:n
kuvankäsittelyfunktiot
eivät
kuitenkaan
koskaan
käytä
liukulukuaritmetiikkaa tai käyttävät sitä ainoastaan, kun kuva koostuu
liukulukuarvoista. Kuitenkin muutamat erikoisemmat funktiot, jotka käsittelevät
ominaisarvoja, kuvan transformaatioita tai kuvan statistiikkaa käyttävät aina
liukulukulaskentaa, huolimatta siitä, mikä on alkuperäisen kuvan tyyppi. Tämän
tyyppiset algoritmit tarvitsevat alustalta natiivia liukulukutukea, jotta voidaan saavuttaa
reaaliaikainen kuvankäsittely. [2]
5.2.3.3
ZXing
ZXing-kirjasto on niin ikään avoimen lähdekoodin kirjasto, joka on toteutettu Javakielellä, mutta kirjasto voidaan siirtää useille eri ohjelmointikielille. Kirjasto tukee
useiden 1D- ja 2D-viivakoodien dekoodausta digitaalikuvasta.
Taulukko 1 ZXing-kirjaston tukemat viivakoodityypit
Tyyppi
Code 39
Code 93
Code 128
Codabar
EAN-8
EAN-13
ITF
RSS-14
RSS-Expanded
UPC-A
UPC-E
Aztec
Dimensio
1
1
1
1
1
1
1
1
1
1
1
2
34
Data Matrix
PDF 417
QR Code
2
2
2
Loppusovellus tehtiin Qt-kehysalustalla ja ZXing-kirjastosta löytyy QZXing-moduuli,
jonka avulla pystytään hyödyntämään kirjaston toimintoja Qt-ympäristössä.
Moduulinen käyttäminen oli varsin yksinkertaista, joka voidaan nähdään myös liitteessä
4.
Kuva 16 ZXing-kirjaston viivakoodiolion käyttäminen Qt-ympäristössä
Instantioinnissa luodaan muuttuja pääikkunaan: QZXing *barcodeDecoder_ = new
QZXing(this); Tämän jälkeen yhdistetään pääikkunan signaali moduulin slotin kanssa,
mikä
suorittaa
viivakoodien
dekoodaamisen.
Moduulin
vastaanotettua
dekoodaussignaalin, se alkaa prosessoimaan kuvaa. Prosessoinnin onnistumisesta
ilmoitetaan tagFound-signaalilla. Tällöin voidaan suorittaa pääikkunan getTag()funktio, jolla reagoidaan onnistuneeseen dekoodaukseen ylimmällä tasolla.
5.2.4
Sovellus
Ensimmäinen haaste konenäkösovelluksen kehittämisessä oli taustan erottaminen
kuvista. Kamera asennetaan staattiseksi pakkauskoneen yhteyteen, jolloin suurin osa
kuvasta pysyy vakiona. Koska pakkauskoneen liikkeet ovat toistuvia ja pakattavat
tuotteet pysyvät vakiona, voidaan näitä varten kehittää alueita kuviin, joiden sisällä
liikkeiden ja tuotteiden on pysyttävä normaaliajossa. Jos liikkeet tai tuotteet eivät pysy
määriteltyjen alueiden sisällä, todetaan, että virhe on ilmennyt.
35
5.2.4.1
Taustan erottaminen
Taustan erottaminen tai etualan tunnistaminen tarkoittaa kuvankäsittelytekniikkaa, jossa
etuala poistetaan kuvasta jatkokäsittelyä varten, esimerkiksi objektin tunnistusta varten.
Tyypillisesti suurin osa kuvasta on taustaa ja kuvassa esiintyvät objektit (autot, ihmiset,
tekstit jne.) muodostavat kuvan etualan. Kun kuva on esiprosessoitu, kuvasta
paikannetaan objektit, mikä tarkoittaa useiden algoritmien suorittamista kuvalle.
Taustan erottamista käytetään usein liikkuvien objektien seuraamiseen vertailemalla
juuri otettua kuvaa referenssikuvaan. Referenssikuvaan viitataan usein taustakuvana tai
–mallina. Taustan erottamista kuvasta käytetään pääosin ainoastaan videokuvalle.
Taustan erottamisessa on kuitenkin omat haasteensa. Ideaalitapauksessa taustan
pikseliarvot pysyisivät videokuvassa aina samoina, jolloin vertaamalla tarkasteltavan
kuvan pikseliarvoja taustakuvan pikseleihin, arvojen poiketessa voidaan todeta, että
kyseisessä pikselikohdassa on tapahtunut liikettä. Robustin taustan erottamisen täytyy
kuitenkin pystyä reagoimaan valaistuksen muutoksiin sekä toistuviin ja pitkäaikaisiin
muutoksiin.
Luvussa 3.2 esiteltiin kuvan digitaalinen esittäminen. Digitaalinen video voidaan esittää
samanlaisella funktiolla V(x,y,t), johon liitetään lisäparametri t, joka kuvastaa videon
aikamuuttujaa.
Q + 1 = |R, , + 1 − R, , |
Yllä on esitetty absoluuttinen erotus ajanhetkellä t + 1, jossa taustakuvan oletetaan
olevan ajanhetkellä t oleva kuva. Mutta kyseinen lauseke toimii ainoastaan tapauksissa,
joissa objektit liikkuvat ja tausta pysyy täsmälleen samana. Kuvankäsittelyssä törmätään
usein raja-arvo käsitteeseen ja samoin tässäkin tapauksessa tarvitaan raja-arvoa, joka
absoluuttisen erotuksen tulee ylittää.
|R, , + 1 − R , , | > ℎ
Raja-arvolla Th pystytään nyt hieman varioimaan pikseliarvojen sallittua muutosta.
Tämän lähestymistavan tarkkuus on riippuvainen liikkeiden nopeuksista, mikä johtaa
siihen, että nopeilla ja hitailla liikkeillä tarvitaan mahdollisesti erilaisia raja-arvoja.
Jotta tausta saadaan erotettua entistä tarkemmin, erotuksessa käytettävän taustakuvan
pitää olla luotettava. Videosta otettu yksi kuvakaappaus V(x,y,t) voi olla hyvinkin
epäluotettava. Luotettavuutta voidaan kasvattaa ottamalla lukuisia kuvia taustasta ja
palauttamalla näiden kuvien pikseliarvojen keskiarvo lopulliseen taustakuvaan.
36
U, = ∑V
XY R , , − ,
V
jossa N on taustasta otettujen kuvien lukumäärä. Edellä olevalla lausekkeella saadaan
B(x,y), joka kuvastaa uutta keskiarvoitettua taustakuvaa. Tämän jälkeen alkuperäinen
taustakuva V(x,y,t) voidaan korvata absoluuttisessa erotuksessa B(x,y)-funktiolla ja näin
päästään tarkempiin tuloksiin. OpenCV tarjoaa tähän toimintoon oman olioluokan.
5.2.4.2
Reunojen tunnistaminen
Luvussa 3.3.3 esitettiin hieman teoriaa kuinka digitaalisesta kuvasta voidaan löytää
reunoja. OpenCV tarjoaa monia eri tapoja tämän toteuttamiseen. Yksinkertaisimmissa
algoritmeissa paikannetaan pikseleiden positiot, joissa pikselin gradientti on suurempi
kuin pikselin ympäristön muut gradientit.
Yleisin derivoinnissa käytettävä operaattori on Sobelin derivaatta-operaattori, joka ei
varsinaisesti derivoi mitään, ainoastaan generoi derivaatan approksimaation kyseiselle
pisteelle. Tätä voidaan hyödyntää ja laajentaa x. asteen derivaatoille. Tämä operaattori
on ainoastaan matriisifiltteri, joka approksimoi derivaatan arvon diskreetissä
avaruudessa. Vastaavanlaisia matriisifilttereitä löytyy lukuisia ja etenkin Sobeloperaattorin heikkoutena on pienien matriisifiltterien heikko tarkkuus.
Matriisisuodattimen dimension kasvaessa käytetään laajempaa aluetta kuvasta
derivaatan arvon approksimaatioon, mikä johtaa pienempään virhearvioon, mutta on
huomattavasti hitaampi suorittaa. Heikko tarkkuus antaa vastaavasti virheellisiä
derivaatan suuntia, joita käytetään esimerkiksi objektien tunnistamiseen.
OpenCV:ssä käytetään kolmea eri approksimaattoria: Sobel, Scharr ja Laplacian. Sobel
ja Scharr ovat käytännössä aivan samanlaisia, mutta Scharr-filtterillä päästään
tarkempaan lopputulokseen samalla suoritusajalla. Laplacian määriteltiin luvussa 3.3.3,
josta ilmenee, että siinä käytetään toisen asteen derivaattoja. OpenCV:n toteutus
Laplacian-operaatiosta on toteutettu Sobel-filttereitä käyttämällä. Koska Laplacianoperaattori käsittelee digitaalikuvan toisen asteen derivaatta-approksimaatioita,
lähtökuvan reunat ilmenevät nollina Laplacianin muodostamassa datajoukossa.
Toisaalta merkitsevät ja vähemmän merkitsevät reunat esiintyvät Laplacianin
datajoukossa nollina, mutta tämä ongelma voidaan poistaa suodattamalla pikselipositiot,
joissa ensimmäinen derivaatta on myös suuri.
Paras reunantunnistus-funktio/algoritmi OpenCV:ssä on cvCanny()-funktio, joka vaatii,
että operoitava kuva on mustavalkoinen, josta lopuksi muodostetaan binäärikuva.
cvCanny()-funktion toteutuksessa kuitenkin tukeudutaan Sobel-operaattoriin, jolla
suoritetaan tarvittavat derivoinnit kuvalle.
37
5.2.4.3
Alueen opettaminen
Yksinkertaisimmaksi menetelmäksi todettiin, että käyttäjä itse saa määrittää tutkittavan
alueen, jonka sisäpuolella liikehdintää saa tapahtua. Loppusovellukseen määriteltiin
kaksi aluetta, jotka on mahdollista opettaa. Toinen tarkastelee liikettä; ettei sitä tapahdu
alueen ulkopuolella ja toiseen alueeseen voidaan määrittää viivakoodin sijainti.
Liikkeen määrittäminen perustuu kuitenkin edelleen taustan erottamiseen kuvasta,
jolloin etualan äärirajat otetaan talteen ja tarkastetaan, että ne ovat sallitun alueen
sisällä. Toinen tapa, jota testattiin, oli värialueiden seuranta. Kuvasta luodaan
binäärikuva sallimalla ainoastaan rajattu värialue. Eli jos alkuperäisen kuvan pikselin
väriarvo sisältyy rajattuun väriarvoalueeseen, se merkataan valkoisella binäärikuvaan.
Binäärikuvan valmistuttua haetaan valkoisten alueiden määrittämät äärirajat, joista
jälleen tarkastetaan, että ne ovat sallittujen rajojen sisällä.
38
6
TULOKSET JA ARVIOINTI
6.1
Testialusta
Tutkimuksen ensimmäisenä tutkimuskohteena oli alkuperäisen järjestelmän
suorittaminen kevyemmällä alustalla. Koska alkuperäisen järjestelmän toiminnallisuus
ei vaadi laitteistolla kovin paljon, toiminnallisuuden toteuttamista aloitettiin tutkimaan
BeagleBone Black-alustalla, joka ei ole erityisen tehokas mutta edullinen tutkimusta
varten. Taulukossa on esitelty alustan oleellisimpia ominaisuuksia.
Taulukko 2 BeagleBone Black-kehitysalustan tietoja
CPU
GPU
Muisti
Flash
OS
Cortex-A8, 1GHz
SGX530, 20MHz
DDR3, 512 MB
8bit eMMC, 2 GB
Ångström
Järjestelmälle valittiin kameraksi Logitechin C920, jossa on sisäänrakennettu H.264videopakkauskoodaus. Tämä siksi, koska alkuperäinen järjestelmä pystyi pakkaamaan
vastaanottamat videovirtansa entistä pienempään kokoon, mutta tämä ei ole mahdollista
enää BBB-alustalla sen heikon suoritustehon takia. Alustaa varten luotiin uusi
tallennusohjelma, joka pystyy hyödyntämään edistyneemmän USB-kameran
ominaisuuksia käynnistämällä sisäisen videopakkauskoodauksen ja pienempikokoisen
videovirran lähettämisen. Matalaresoluutioisesta videovirrasta muodostuu myös
pienempiä videotiedostoja, mikä nopeuttaa tiedostojen siirtelyä pilvipalveluun.
Koska molemmilla alustoilla toimii Linux-käyttöjärjestelmä, ohjelmien siirtäminen
onnistui ongelmitta alustalta toiselle. Ainoana muutoksena jouduttiin toteuttamaan uusi
videoiden tallennusohjelma, josta mainittiin jo edellä. Kevyen alustan videoiden koko
kasvoi, vaikka videoiden resoluutio onkin pienempi. Syynä tähän on, että PC-ympäristö
pystyy pakkaamaan vastaanotettua videota vieläkin pienemmäksi ilman että
tallennetusta videosta menetetään kuvia. Kevyt alusta on näinkin yksinkertaisessa
prosessissa aivan suorituskykyjensä äärirajoilla. Tästä johtuen järjestelmä jumittui niin
pahasti, että tallennettavasta videosta uupui paljon kuvia ja huonoimmassa tapauksessa
koko minuutin tallennus epäonnistui kokonaan. Toinen ongelmakohta ilmeni
samanaikaisessa videon tallennuksessa sekä toisen videon siirtämisessä pilvipalveluun.
Tilannetta helpottaisi huomattavasti, jos alustan suoritusympäristö olisi
kaksiydinprosessori, jolloin käyttöjärjestelmä pystyisi skeduloimaan tehtävien suoritusta
39
samanaikaisesti molemmille ytimille. Yksiytimisessä alustassa molemmat: sekä
tallennus- että siirtoprosessi kamppailevat suoritusajasta ytimellä.
Tämä kevyt alusta antoi kuitenkin positiivisen vaikutelman siitä, mihin näinkin halvalla
laitteella pystytään. Etenkin kun teknologia kehittyy ja kun markkinoille ilmestyy
entistä halvempia ja tehokkaampia kevyitä alustoja, alkuperäinen järjestelmä pystytään
varmasti siirtämään tällaiseen alustaan. Tässä vaiheessa järjestelmän toimiminen BBBalustassa on kuitenkin siinä määrin epävarmaa, että se ei pysty vielä korvaamaan
olemassa olevaa alustaa.
[17]
6.2
Loppusovelluksen yleiskuvaus
Tämän tutkimustyön teknisenä kontribuutiona toteutettiin konenäkösovellus, jonka
käyttöliittymän pääsivu on esitelty kuvassa 17. Sovellusta voidaan käyttää
pakkauskoneen erilaisiin monitorointitoimintoihin. Sovellus voidaan konfiguroida
lukuisiin eri toimintoihin, esimerkiksi tallentamaan koneen toimintaa levylle, sovellusta
voidaan hyödyntää anturityyppisesti palauttamaan konfiguroituja tilatietoja sekä
sovellus pystyy dekoodaamaan 1- ja 2-uloitteisia viivakoodeja. Sovelluksen
käyttöliittymä ja logiikka on toteutettu Qt:lla. Konenäköön liittyvä toiminnollisuus
käyttää OpenCV-kirjastoa ja viivakoodien dekoodauksessa käytetään ZXing-kirjastoa.
Sovellus on melko yksinkertainen ja tämän tarkoituksena on ainoastaan esitellä
konenäköä OpenCV-kirjaston avulla alkuperäisessä valvontajärjestelmässä. Sovelluksen
toteutus jakautuu kahteen osaan: kehys- ja toteutusluokkiin. Kehysluokkien
tarkoituksena on luoda ympäristö toteutusluokille. Toteutusluokat toteuttavat taas
sovelluksessa vaadittavan toiminnon tietämättä muista sovelluksessa esiintyvistä
toiminnoista.
40
Kuva 17 JometCV-sovelluksen käyttöliittymä
Sovelluksesta oli tarkoitus tehdä myös mahdollisimman itsenäinen, jotta se ei olisi
mitenkään riippuvainen pakkauskoneesta, johon tätä järjestelmää tultaisiin käyttämään.
Sovelluksen itsenäinen toiminnollisuus perustuu tarkastustoimintoihin, joita käyttäjä
pystyy luomaan sovelluksessa.
6.3
Käyttö
Sovellusta käytetään kamerajärjestelmän konfigurointiin. Tämän avulla voidaan luoda
automaattinen tallennustoiminto, joka tallentaa järjestelmän kameran videovirtaa levylle
puskurimaisesti. Myös puskurin koko konfiguroidaan sovelluksessa. Kun puskuri tulee
täyteen, vanhin videomateriaali poistetaan. Näin saadaan tilaa uudelle videolle.
Automaattinen tallennus voidaan linkittää myös tarkastustoimintoihin. Jos
tarkastustoiminto lähettää tapahtuman tallennukselle, tapahtumaan liittyvä video
tallennetaan erilliseen paikkaan, josta tiedoston voi poistaa ainoastaan käyttäjä. Näin
vältytään poistamasta video, joka sisältää tapahtumatietoja.
Sovellukseen kuuluu myös tarkastustoimintoja. Näillä toiminnoilla on tarkoitus luoda
järjestelmästä riippumaton sen fyysisestä ympäristöstä eli käytännössä pakkauskoneesta,
johon se asennetaan. Tarkastustoimintoja voidaan luoda automaattisesti tai
manuaalisesti käyttäjän toimesta. Automaattinen tarkastuksen luominen perustuu
järjestelmän kykyyn oppia itse pakkauskoneen toiminta-alue. Järjestelmä tarkastelee
kameran kautta pakkauskoneen normaalia toimintaa. Tästä se pystyy tulkitsemaan
alueen, jossa liikkeet tapahtuvat. Kun ajon aikana tapahtuu jotakin liikettä tämän alueen
ulkopuolella, automaattinen tarkistus lähettää tästä tapahtuman. Tapahtuma voidaan
ottaa joko vastaan tai ei.
41
Käyttäjä itse voi myös määrittää tarkastustoimintoja. Käyttäjä pystyy rajaamaan
kameran näkymästä alueen, johon voidaan soveltaa muutamaa eri toimintoa. Yksi näistä
on esimerkiksi viivakoodin lukeminen, jolloin toimintoa opetettaessa on annettu
intervalli, joka määrittää aikavälin kuinka usein viivakoodia yritetään lukea alueesta.
Onnistuneen lukemisen jälkeen lähetetään tapahtuma, joka sisältää viivakoodiluvun
tuloksen.
Toinen toiminto on värin tunnistaminen alueesta. Otetaan esimerkiksi tilanne, jossa
ryhmittelijä haluaa siirtää tuotteet paikasta A paikkaan B. Alla olevasta kuvasta 18 käy
ilmi, että käyttäjän rajaamalla alueella vain toisessa tilanteessa rajatulta alueelta
pystytään tunnistamaan tarpeeksi suuri ruskea alue. Ennen siirtoa pakkauskone voi
tehdä kyselyn käyttäjän määrittämälle tarkistustoiminnolle, löytyykö alueesta riittävän
suuri ruskea alue.
Kuva 18 JometCV-sovelluksella opetettu tarkistustoiminto
6.4
Sovelluksen rakenne
Kuvassa 19 on nähtävissä toteutetun sovelluksen rakenne. Sovelluksen käyttöliittymä,
on rakennettu SovellusGUI-luokkaan, joka myös muodostaa tarvittavat oliot muille
toiminnoille. Sovelluksen kommunikointi PLC-järjestelmän kanssa on toteutettu
TCP/IP-yhteydellä. MyServer-luokka sisältää tähän tarvittavat palvelut. Jokaisesta
yhteydenottavasta laiteesta muodostetaan MyClient-luokan olio.
42
Kuva 17 JometCV-sovelluksen luokkakaavio
Sovelluksen kannalta konenäköosuuden tärkein osuus sisältyy TeachToolkantaluokkaan, joka toimii perustana jokaiselle opetettavalle toiminnolle. TeachToolluokasta on periytetty myös OnlineTeach-luokka, joka tarjoaa tarvittavat palvelut
reaaliaikaisen tarkastustyökalun tekemiseen. Periytymisketjua jatketaan vielä
FileTeach-luokalla, jonka avulla voidaan opettaa työkaluja videotiedostoista. Barcodeluokka sisältää toiminnot viivakoodien tulkitsemiseen.
6.5
Jatkokehitys
Tutkimuksen tarkoituksena oli kehittää itsenäistä järjestelmää, jonka pystyisi liittämään
koneeseen kuin koneeseen. Tämän lisäksi selvitettiin, kuinka hyvin kevyt alusta pystyy
suoriutumaan alkuperäisen järjestelmän suorituksessa. Itsenäisen järjestelmän
kehittämisessä onnistuttiin riittävän hyvin, mutta parannettavaa vielä löytyy paljon.
Ensimmäinen asia, joka kävi ilmi jo sovellusta tehtäessä oli, että kyseessä on sen
kokoinen projekti, joka ei sovellu yhden ihmisen toteutettavaksi tiukalla aikataululla.
OpenCV-kirjasto on jatkuvan kehityksen alla. Siihen tulee paranneltuja
toiminnollisuuksia versio versiolta. Näin ollen tämänkin työn sovellus on suoraan
riippuvainen OpenCV-kirjaston suorituskyvystä. Sovellusta tulisikin päivittää
vastaamaan uusimman OpenCV-kirjaston moduulien käyttöä, joka voisi jo itsessään
parantaa eri tarkistustoimintojen toimintavarmuutta.
Tällä hetkellä sovelluksen käyttämä automaattinen oppiminen perustuu taustan
erottamiseen ja siitä saadun etualan rajaamiseen. Rajattu alue tarkoittaa aluetta, jossa
liike saa tapahtua. Nyt etuala rajataan suorakulmiolla, joka sallii liian suuren alueen
sallituksi alueeksi.
43
Kuva 18 automaattisesti tunnistetun alueen minimoiminen
Kuvassa 20 on pyritty havainnollistamaan tilannetta. Mustalla rajattu alue edustaa
etualaa, eli liikettä. Punainen väri näyttää tämänhetkisen sovelluksen rajaaman sallitun
alueen. Keltaisella värillä muodostettu monikulmio rajaa optimaalisesti sallitun liikkeen
alueen.
Näiden lisäksi yhtenä tärkeimpänä jatkokehitysideana voitaisiin pitää järjestelmän
toiminnan siirtämistä kevyemmälle alustalle. Tällä hetkellä se ei välttämättä ole
mahdollista, mutta teknologian kehittyessä tehokkaampia ja pienempiä alustoja ilmestyy
aivan varmasti.
44
7
YHTEENVETO
PLC-järjestelmän ollessa tietoinen ympäristöstään pystytään parantamaan järjestelmän
virhediagnostiikkaa. Tämä tarkoittaa tämän työn yhteydessä sitä, että kun virhe tapahtuu
PLC-järjestelmässä, kamerajärjestelmä tarjoaa tästä videon, jonka avulla on helppoa
tehdä tarvittavia johtopäätöksiä virheestä. Kamerajärjestelmää voidaan myös käyttää
hyväksi ennaltaehkäisemään virhetilanteita. Asioita, joita perinteisillä antureilla ei
pystytä havaitsemaan, voidaan tunnistaa kamerajärjestelmän avulla.
Tässä diplomityössä tutkittiin, miten OpenCV-kirjastoa pystytään hyödyntämään Qtkehitysympäristössä luomalla itsenäinen konenäköjärjestelmä. Työn teknisenä
kontribuutiona toteutettiin JometCV-sovellus, joka on jatkokehitystä yrityksen
alkuperäiselle pakkauskoneen monitorointijärjestelmälle. JometCV-sovellus on
kehitetty Qt-kehitysympäristössä ja käyttää OpenCV- ja ZXing-kirjastoja toteuttaakseen
sovellukseen tarvittavat toiminnot. Yksi oleellisimmista toiminnoista on erilaisten
liikkeiden tunnistaminen ja näiden analysointi, joiden perusteella voidaan antaa tietoa
PLC-järjestelmälle. Tämän lisäksi sovelluksen avulla kamerajärjestelmä voidaan
konfiguroida älykkääksi anturiksi, jolta PLC pystyy kysymään ympäristönsä tietoja.
JometCV-sovellukseen kehitettiin myös useita uusia toimintoja, joilla parannettiin
yksinkertaisen monitorointijärjestelmän toimintoja. Uuteen sovellukseen kehitettiin uusi
käyttöliittymä, jonka avulla pystytään konfiguroimaan koko järjestelmä halutunlaiseksi.
Uusina toimintoina esiteltiin konenäköön perustuva automaattinen virheen
tunnistaminen, uusien tarkkailutoimintojen luominen ja viivakoodien dekoodaus. Näin
JometCV-sovelluksesta haluttiin tehdä soveltuva moneen eri toimintaan. Sovellus
saatiin työn aikana riittävälle tasolle vaatimusten osalta, mutta työn teon aikana
havaittiin, että kyseinen projekti on liian suuri yhden henkilön vietäväksi loppuun.
Sovellus osaa havaita liikkeen hyvin, mutta se sallii vielä liian suuren alueen
virhetarkastelussa. Jotta näitä virheellisiä liikkeitä havaitaan entistä tarkemmin,
kyseinen alue pitää optimoida mahdollisimman pieneksi opetustilanteen jälkeen.
Lisäksi, sovelluksen toiminta perustuu vahvasti OpenCV-kirjastoon, joka kehittyy koko
ajan. Sovelluksen toimintaa pystytään mahdollisesti parantamaan päivittämällä
OpenCV-kirjasto ja tarkkailemalla, ilmestyykö siihen parempia funktioita.
Työn toisena osana tutkittiin kevyitä kehitysalustoja ja näiden kykyjä suorittaa
videoprosessoimista. Ensimmäisenä haasteena oli tutkia pystytäänkö Jometin
alkuperäinen monitorointijärjestelmä siirtämään suoritettavaksi kevyellä alustalla.
45
Tutkimuskohteeksi valikoitui BeagleBone Black. Kyseinen kehitysalusta yllätti
positiivisesti,
koska
se
kykeni
suorittamaan
alkuperäisen
järjestelmän
monitorointitoimintoa. Tähän ei kuitenkaan pystytty ilman pieniä muutoksia, sillä
kehitysalustan vaatimattomasta suoritustehosta johtuen, alusta ei pysty dekoodaamaan
yhtään jatkuva-aikaista videovirtaa eri muotoon. Niinpä päätettiin käyttää kameraa, joka
suorittaa valmiiksi jo kamerassa tarvittavan dekoodauksen. Tämäkin muutti järjestelmän
toimintaa siinä mielessä, että systeemin tallentamien videoiden koko kasvoi. Tästä
johtuen videoiden siirtäminen pilvipalveluun hidastuu eikä tallennettavia videoita voida
säilöä enää niin montaa levylle kuin alkuperäisessä ratkaisussa. Näiden lisäksi järjestelmän toimiessa koko ajan suorituskykynsä huipulla - videon tallennuksessa
voitiin havaita, että muutamia kuvia hukataan tallennettaessa videota, kun järjestelmä
prosessoi muita järjestelmän toimintoja, esimerkiksi lataa viimeisintä videota
pilvipalveluun.
JometCV-sovellus toteutettiin PC-ympäristöön, mutta nykyajan teknologia kehittyy
huimaa vauhtia, mahdollistaen kyseisen sovelluksen siirtämisen kevyelle järjestelmälle
hyvinkin pian. Kirjoittaessa tätä diplomityötä, vastaan on tullut jo useita potentiaalisia
kehitysalustoja, joiden pitäisi ainakin teknisten ominaisuuksiensa puolesta kyetä
suorittamaan tätä sovellusta.
46
LÄHTEET
[1] Argyle, E. 1971. Techniques for edge detection Proc. IEEE, vol. 59, pp. 285-286
[2] Bradski, G., Kaehler, A., 2008. Learning OpenCV. O'Reilly Media.
[3] Canny, John. 1986. A Computational Approach to Edge Detection, IEEE Transactions on Pattern Analysis and Machine Intelligence, Vol. PAMI-8, No. 6, pp. 679-698.
[4] Wolberg, G. 1996. Digital Image Warping. IEEE Computer Society Press. pp. 3-12.
[5] Gonzalez, R. C. & Woods, R. E., 2001. Digital Image Processing. Upper Saddle
River, NJ: Prentice-Hall. p. 117, 134 pp.165-168, pp. 572-582.
[6] Harris and M. Stephens., 1988. A Combined Corner and Edge Detector, Proceedings
of the Fourth Alvey Vision Conference, Manchester, pp. 147-151.
[7] Lim, Jae S. 1990. Two-Dimensional Signal and Image Processing, Englewood
Cliffs, NJ, Prentice Hall, pp. 478-488.
[8] Parker, James R. 1997. Algorithms for Image Processing and Computer Vision, New
York, John Wiley & Sons, Inc., pp. 23-29.
[9] Shapiro, L. & Stockman, G. 2001. Computer vision. Prentice Hall., pp. 33-53.
[10] Szeliski, R. 2010. Computer Vision. Algorithms and Applications.
[11] Ziou, D. & Tabbone, S. 1998. Edge Detection Techniques an Overview, International Journal of Pattern Recognition and Image Analysis, 8(4): pp. 537-559
[12] Lindeberg, T. 1998. Edge detection and ridge detection with automatic scale selection, International Journal of Computer Vision, 30, 2, pp 117-154
[13] Vahid, F. & Lysecky, R. & Zhang, C. & Sitt, G. 2003. Highly configurable
forms for embedded computing systems.
plat-
[14] Rafael, G. & Woods, R. Digital Image Processing. Upper Saddle River, New Jersey, Pearson Education, pp. 165-168.
[15] Sachs, J. 1999. Digital Image Basics.
[16] Online: https://developers.google.com/gdata/. Viitattu 13.2.2014
[17] Online: http://www.elinux.org/Beagleboard:BeagleBoneBlack. Viitattu 1.2.2014
47
[18] Online: http://blogs.mathworks.com/steve/2006/05/05/spatial-transformationsinverse-mapping/. Viitattu 15.2.2014
[19] Online: http://blogs.mathworks.com/steve/2006/04/28/spatial-transforms-forwardmapping/. Viitattu 15.2.2014
[20] Online: http://www.cambridgeincolour.com/tutorials/image-interpolation.htm.
Viitattu 5.3.2014
[21] Online: http://qinxuye.me/article/install-opencv-in-windows/. Viitattu 11.2.2014
48
LIITTEET
Liite 1
#include ”opencv2/highgui/highgui.hpp”
#include “opencv2/imgproc/imgproc.hpp”
#define NEW_SIZE 2
using namespace cv;
int main( int argc, char** argv)
{
//Ladataan kuva
Mat srcImg = imread(“lena.jpg”, 1);
//Luodaan ikkuna kuvaa varten
const char* winName = ”Geometrinen operaatio”;
namedWindow( winName, CV_WINDOW_AUTOSIZE );
/* Luodaan matriisi geometrista operaatiota varten
*
* geoMat = [ NEW_SIZE, 0, 0;
*
0, NEW_SIZE, 0;
*
0, 0, 1];
*/
Mat geoMat = (Mat_<double>(3,3) << NEW_SIZE, 0, 0, 0, NEW_SIZE, 0, 0, 0, 1);
//Varataan muistia lopullista kuvaa varten
Mat destImg;
Size imgSize(srcImg.size().width*NEW_SIZE, srcImg.size().height*NEW_SIZE);
//Kutsutaan funktioita, joka tekee muutoksen 3x3-matriisin perusteella
warpPerspective( srcImg, destImg, geoMat, imgSize );
//Näytetään muokattu kuva
imshow( winName, destImg );
waitKey( 0 );
return 0;
}
Liite 2
%Ladataan kuva
srcImg = imread(’lena3.jpg’);
%Vakio
PI = 3.14;
%R-Matriisissa käytettävä käännöskulma
angle = PI/4;
R = [ cos(angle), sing(angle),0;
-1*sin(angle), cos(angle),0;
0,0,1];
%Muodostetaan transformaatiomatriisi
tform = affine2d(R);
%Tehdään geometrinen muutos ja näytetään se
Imshow(imwarp(srcImg,tform));
49
Liite 3
Img2 = imread('lena.jpg');
Img = double(rgb2gray(Img2));
SImg = zeros(size(Img));
RImg = zeros(size(Img));
PImg = zeros(size(Img));
SI = size(Img);
width = SI(2);
height = SI(1);
Sx = [-1,0,1;-2,0,2;-1,0,1];
Sy = [1,2,1;0,0,0;-1,-2,-1];
Rx = [1,0;0,-1];
Ry = [0,1;-1,0];
Px = [-1,0,1;-1,0,1;-1,0,1];
Py = [1,1,1;0,0,0;-1,-1,-1];
M_W = 3; % do not need the + 1, I assume the for loop means while <less than or equal to>
% x and y are reversed...
for y=1 : height
for x=1 : width
S = 0;
P = 0;
R = 0;
for M_Y = 1 : M_W
for M_X = 1 : M_W
if (x + M_X - 1 < 1) || (x + M_X - 1 > width)
S = 0;
P = 0;
R = 0;
%disp('out of range, x');
continue
end
if (y + M_Y - 1 < 1) || (y + M_Y - 1 > height)
S = 0;
P = 0;
R = 0;
%disp('out of range, y');
continue
end
if (M_X <= 2) && (M_Y <= 2)
S = S + Img(y + M_Y - 1, x + M_X - 1) * Sx(M_Y,M_X);
S = S + Img(y + M_Y - 1, x + M_X - 1) * Sy(M_Y,M_X);
P = P + Img(y + M_Y - 1, x + M_X - 1) * Px(M_Y,M_X);
P = P + Img(y + M_Y - 1, x + M_X - 1) * Py(M_Y,M_X);
R = R + Img(y + M_Y - 1, x + M_X - 1) * Rx(M_Y,M_X);
R = R + Img(y + M_Y - 1, x + M_X - 1) * Ry(M_Y,M_X);
else
S = S + Img(y + M_Y - 1, x + M_X - 1) * Sx(M_Y,M_X);
S = S + Img(y + M_Y - 1, x + M_X - 1) * Sy(M_Y,M_X);
P = P + Img(y + M_Y - 1, x + M_X - 1) * Px(M_Y,M_X);
P = P + Img(y + M_Y - 1, x + M_X - 1) * Py(M_Y,M_X);
end
% It is y + M_Y - 1 because you multiply Robertsx(1,1) *
% Img(y,x).
end
end
SImg(y,x) = S;
RImg(y,x) = R;
PImg(y,x) = P;
end
end
subplot(2,2,1);
50
imshow(Img2,[]);
title('Orig');
subplot(2,2,2);
imshow(SImg,[]);
title('Sobel');
subplot(2,2,3);
imshow(RImg,[]);
title('Roberts');
subplot(2,2,4);
imshow(PImg,[]);
title('Prewitt');
Liite 4
//yhdistetään imageReady-signaali decodeImage-slotin kanssa
connect(this,SIGNAL(imageReady(QImage,int,int,bool)),barcodeDecoder_,SLOT(decodeImage(QImage,int,int,bool)));
//yhdistetään viivakoodilukijan tagFound-signaali pääikkunan getTag-slotin kanssa
connect(barcodeDecoder_,&QZXing::tagFound,this,&MainWindow::getTag);