JUHO BLANKENSTEIN MITTAUSSIGNAALIN PAKKAAMINEN, SELVITYS PAKKAUSALGORITMEISTA

I JUHO BLANKENSTEIN MITTAUSSIGNAALIN PAKKAAMINEN, SELVITYS PAKKAUSALGORITMEISTA Kandidaatintyö Tarkastaja: lehtori Konsta Koppinen Työ jätetty tarkastettavaksi 10. toukokuuta 2009

II TIIVISTELMÄ TAMPEREEN TEKNILLINEN YLIOPISTO Tietoliikenne-elektroniikan koulutusohjelma BLANKENSTEIN, JUHO: Mittaussignaalin pakkaaminen, selvitys pakkausalgoritmeista Kandidaatintyö, 14 sivua, 7 liitesivua Toukokuu 2009 Pääaine: Signaalinkäsittely Tarkastaja: lehtori Konsta Koppinen Avainsanat: Häviötön pakkaaminen, Huffman, Deltasignaali, LPC, LZW, Jakson pituus. Työn tarkoituksena on tarkastella kolmen eri pakkausalgoritmin soveltumista kolmeen eri teollisuusprosessista saatuun signaaliin. Pakkausalgoritmeiksi on valittu laajimmin eri sovelluksissa käytössä olevia ja tunnettuja algoritmeja. Jokainen algoritmi hyödyntää signaalin eri ominaisuutta. Näiden algoritmien lisäksi kokeillaan kahta esikäsittelyprosessia ja näiden vaikutusta algoritmeihin. Työn pääpaino on pakkaustehokkuuden tutkimisessa ja esikäsittelyn soveltumisesta eri tyyppisiin algoritmeihin. Työssä tehokkaimmaksi menetelmäksi osoittautui erotussignaalin pakkaaminen Huffman:lla, kunhan kohinaa ei signaalissa esiinny. Yleiskäyttöinen LZW pärjäsi hyvin kohinankin kanssa.

III ALKUSANAT Haluaisin kiittää Konsta Koppista työn ohjaamisesta ja kommentoinnista. Työssä on ollut suurena apuna Giuseppe Ridinon koodaamat Matlab- funktiot Huffman:iin ja LZW:n, joita olen käyttänyt funktioiden pohjana. Tämä kandidaatintyö toteutettiin osana Tampereen teknillisen yliopiston signaalinkäsittelyn laitoksen kandidaatintyöseminaaria. 10. toukokuuta 2009 Juho Blankenstein

IV SISÄLLYS 1. Johdanto...1 2. Esikäsittely...2 2.1. Deltasignaali eli erotussignaali...2 2.2. Lineaarinen ennustava koodaus...3 3. Pakkausalgoritmit...4 3.1. Entropiaan perustuvat menetelmät - Huffman...4 3.1.1. Toteutus...5 3.1.2. Erilaiset variaatiot...6 3.2. Sanakirjakoodaus LZW...6 3.3. Jakson pituuden koodaus...8 4. Algoritmien testaus...9 4.1. Pakkaustehokkuus...10 4.1.1. Esikäsittely erotussignaalilla...12 4.1.2. Esikäsittely lineaarisen ennustuksen kertoimilla...12 5. Johtopäätökset...14 Liitteet...15 Lähteet...22

TERMIT JA NIIDEN MÄÄRITELMÄT ASCII- merkistö Deltasignaali Huffman- puu Häviötön pakkaaminen LZW American Standard Code ofr Information Interchangemerkistö, joka sisältää englannin kirjaimet, numerot, joukon välimerkkejä ja ohjauskoodeja. Erotussignaali. Kooditaulukko, josta löytyy Huffman- algoritmin pakkaustiedot. Data, joka on pakattu niin, että se voidaan palauttaa alkuperäiseen muotoon. Tekijöidensä, Lempel, Ziv, Welch, mukaan nimetty pakkausalgoritmi.

6 1. JOHDANTO Teollisuusprosessista kerätään viidelta anturilta mittausdataa erilaisista fysikaalisista suureista. Tätä dataa voidaan käyttää myöhemmin arvioimaan prosessin toimintaa eri tavoin. Hyvään analyysiin voidaan tarvita dataa pitkältä aikaväliltä, jotta tilastollisia ominaisuuksia päästäisiin seuraamaan. Tiedon varastointi vie paljon resursseja ja niiden tehostamiseksi tieto pakataan. Muistinkäytön vähetessä tallennus- ja tietonsiirtokapasiteettien tarve vähenee. Dataa on kerätty kymmenen hertzin näytteenottotaajuudella 16:n bitin tarkkuudella ja yksittäisestä mittausjaksosta on kertynyt karkeasti 150 megatavua mittausdataa. Luvussa kaksi perehdytään esikäsittelymenetelmiin, jotka joissain tapauksissa tehostavat algoritmien toiminnallisuutta. Esikäsittelymenetelmistä työssä esitellään deltasignaali ja lineaarinen ennustava koodaus. Tässä kandidaatintyössä perehdytään häviöttömiin pakkaustekniikoihin seuraavasti: entropiaan perustuvista menetelmistä on yleisesti käytetty Huffman- algoritmi, sanakirjakoodauksesta LZW- algoritmi ja kolmantena toistoa eliminoiva jakson pituuden koodaus. Luvussa neljä vertaillaan pakkaustuloksia kolmella erilaisella signaalilla, kun niitä on testattu luvussa kolme esitellyillä algoritmeilla ja luvussa kaksi olevilla esikäsittelyillä. Pakkausalgoritmit toteutettiin Matlab:lla.

7 2. ESIKÄSITTELY Alkuperäisen signaalin pakkaaminen on useimmiten tehotonta verrattuna esikäsiteltyyn signaaliin. Esikäsittelyllä pyritään saamaan signaali sellaiseen muotoon, jossa se on tehokasta pakata, kuitenkaan hukkaamatta sen sisältämästä informaatiosta mitään. Tässä käytetään tietoa signaalin luonteesta ja tallennetaan signaalille tyypilliset piirteet. 2.1. Deltasignaali eli erotussignaali Erotussignaali muodostetaan tallentamalla alkuperäisestä signaalista ensimmäinen näyte ja laskemalla seuraavien näytteiden muutos edelliseen näytteeseen nähden. y[0] = x[0], y[n] = x[n] - x[n -1], (2.1) missä x[0] on ensimmäinen näyte ja y[n] on uusimman ja toiseksi uusimman näytteen erotus. Tällä toimenpiteellä saadaan signaalin y[n] arvot muutoksen suuruisiksi. Menetelmä erottaa tasaisesti muuttuvasta signaalista jaksoja, joissa toistuu sama arvo. Tämä on edullista pakkausta silmällä pitäen. Menetelmän tehokkuus riippuu signaalin luonteesta. Mitä lähempänä viereisten näytteiden arvot ovat toisiaan sitä paremmin deltasignaali toimii. Tyypillisesti tämä on totta tarkasteltaessa audio- ja mittaussignaaleja, kun taas esimerkiksi tietokonekoodissa tai kirjoitetussa tekstissä viereiset arvot eivät yleisesti ole lähellä toisiaan. Kuva 2.1: Signaali ja sen deltakoodattu versio

8 2.2. Lineaarinen ennustava koodaus LPC Linear predictive coding( lineaarinen ennustava koodaus) lähtee tarkastelemaan asiaa vanhojen näytteiden avulla, kun erotussignaalissa käytetään vain edellistä näytettä. LPC onkin yleistys deltasignaalista. Vanhojen näytteiden pohjalta pyritään ennustamaan tuleva näyte x p (n) = - i a(i) x(n-i), i = 1 p, (2.2) missä x on sisääntulo, a(1),a(2),a(3)... a(p) ennustamiseen käytetyt kertoimet ja x p ennustettu sisääntulo. Tässä esikäsittelyssä tallennetaan ennustusvirhe: e(n) = x(n)- x p (n) = i a(i) y(n i), i = 0 p (2.3) todellisen sisääntulon ja ennustetun väliltä. LPC pyrkii löytämään sellaiset kertoimet a(1), a(2), a(3)... a(p), joilla neliövirheiden summa saadaan mahdollisimman pieneksi[1]. Signaalin ennustusvirheen energia kirjoitetaan muotoon: E p = n ( e(n) ) 2, n = - (2.4) = n ( x(n) x p (n) ) 2, n = - Kun on sovittu a(0) = 1 merkintöjen helpottamiseksi, saadaan yhtälö muotoon E p = n ( k a(k)x(n-k) ) 2, n = -, k = 0 p Kertoimien a(p) optimaalisuuden ehtona on että funktion E p osittaisderivaattojen täytyy olla nolla a(p):n suhteen. Kun derivoinnin ja ryhmittelyn jälkeen asetetaan derivaattojen arvot nolliksi saadaan yhtälöryhmä, mistä tulee symmetrinen Toeplitz matriisi, joka on muotoa, Rx=y (2.5) missä R on autokorrelaatiomatriisi ja y ristikorrelaationvektori. Optimaaliset kertoimet ratkaistaan yhtälöstä (2.5) Levinson- Durbin rekursiolla. Levinson- Durbin ratkaisee yhtälöryhmän lohkoittain kasvattamalla yhtälön (2.5) vektorin x pituutta ja hyödyntäen edellisen iteraation tulosta.

9 3. PAKKAUSALGORITMIT Kaikki kolme algoritmia, Huffman, LZW ja jakson pituuden koodaus (engl. Run-Lenght coding), ovat häviöttömiä. Huffman perustuu entropiaan, LZW sanakirjakoodaukseen ja jakson pituus signaalissa olevan toiston hyväksikäyttämiseen. Häviöttömän pakkauksen tehokkuus on kuitenkin aina riippuvainen sille syötettävästä signaalista Tuottakoon mittaus arvoja s 1, s 2, s 3 s L, jotka jakautuvat todennäköisyyksin p 1, p 2, p 3 p L. Tämän mittauksen informaatio on I k = - log 2 p k bittiä. (3.1) Informaation avulla ilmoitettuna mittauksen entropia on H = - p k log 2 p k bittiä. (3.2) Häviöttömän pakkausalgoritmin maksimipakkaus on sidottu entropiaan. Pakattu signaali ei voi päästä entropiaa pienempään bittimäärään. Ilman tätä ehtoa signaalia voitaisiin pakata samalla algoritmilla useaan kertaan ja joka kierroksella päädyttäisiin edellistä pienempään lopputulokseen. Jokaista algoritmia voidaan käyttää joko laskemalla joka kerta pakkauksessa käytettävä tieto kyseisestä signaalista tai käyttää ennaltamäärättyä pakkaustaulukkoa. Näissä testeissä taulukot on laskettu jokaista signaalia varten uusiksi pakkauksen tehokkuuden maksimoitamiseksi. Kuitenkin jos pakataan samankaltaista tietoa voitaisiin käyttää vanhaa pakkaustaulukkoa tai niiden keskiarvoja pakkauslaskennan yksinkertaistamiseksi hävittämättä kuitenkaan paljoa pakkaustehokkuudesta. 3.1. Entropiaan perustuvat menetelmät - Huffman Huffman- algoritmissa näytteille allokoidaan bittejä näytteen esiintymistiheyden mukaan, siten että useimmiten esiintyvät näytteet saavat pienimmät bittimäärät. Allokoiduista biteistä muodostetaan huffman- puu, jonka mukaan signaali pakataan ja puretaan. Bitit on jaettu niin että luettaessa pakattua signaalia aina on selvää mihin arvoon viitataan. Huffman käsittelee dataa aina merkki kerrallaan. Optimaalisen pakkaustehokkuuden saavuttamiseksi merkkien todennäköisyyksien tulisi olla kahden negatiivisia potensseja.

10 3.1.1. Toteutus Algoritmin alussa merkit laitetaan laskevaan järjestykseen niiden esiintymistodennäköisyyksien mukaan. Jokaiseen merkkiin menee oma haara. Tämän jälkeen kaksi pienimpien todennäköisyyksien haaraa yhdistetään ja näistä muodostuu uusi haara, jolla on yhdistyneiden haarojen yhteenlaskettu todennäköisyys. Mikäli löytyy useampia merkkejä tai merkkiyhdistelmiä, jotka tuottavat saman todennäköisyyden voidaan valita eri yhdistelmiä, kunhan uuden haaran todennäköisyys on pienin mahdollinen. Tästä seuraa ettei Huffman- puu ole kaikissa samasta lähtöjoukosta lasketuissa tapauksissa samanlainen. Haarojen yhdistämistä jatketaan kunnes viimeisen haaran todennäköisyys on yksi. Puun ollessa valmis annetaan haarojen yläosalle arvo nolla ja alaosalle arvo yksi ja arvot luetaan ylhäältä seuraten haaroja alkuperäiselle merkille. Kuvassa 3.1 on esimerkki viiden arvon huffmanpuusta. Merkki Todennäköisyys koodi a 1 0.4 0 a 2 0.3 10 a 3 0.2 110 a 4 0.1 1110 a 5 0.1 1111 Taulukko 3.1: Huffman esimerkin arvot Kuva 3.1: Huffman- puu Taulukon 1 arvoille

11 Esimerkin keskimääräinen koodin tilantarve on 0.4 * 1+ 0.3 * 2 + 0.2 * 3 + 0.1 * 4 + 0.1 *4 = 2.4 bittiä/ merkki. Puu olisi voitu muodostaa myös toisin. Todennäköisyydet a 345 ja a1 ovat samat, joten oltaisiin myös voitu muodostaa haara a 1345. [2] 3.1.2. Erilaiset variaatiot Huffman olettaa että pakkausvaiheessa merkkien todennäköisyydet ovat tunnetut. Näin ei kuitenkaan aina ole ja tähän on kehitetty eri menetelmiä. Yksi näistä on adaptiivinen huffman- algoritmi, jossa puuta päivitetään pakkaamisen ja purkamisen yhteydessä jokaisen merkin kohdalla. Huffmanista on kehitetty myös merkkisarjoille soveltuva versio aritmeettinen koodaus. Tässä työssä testataan alkuperäistä huffman algoritmia, mutta on huomion arvoista mainita, että erilaisia variaatioita on olemassa. 3.2. Sanakirjakoodaus LZW Terry Welchin vuonna 1984 julkaisema algoritmi, joka pohjautui Abraham Lempelin ja Jacob Zivin vuonna 1978 julkaistuun LZ78- algoritmiin. Algoritmista tuli nopeasti laajalti käytetty kun sitä ryhdyttiin käyttämään GIF- kuvaformaatissa 1987. Algoritmin käyttöä rajasi siihen tehty patentti, joka kuitenkin vanhentui vuonna 2003. Tekijöidensä mukaan nimettyä LZW: tä pidetään kehittyneinpänä yleistarkoitukseen sopivana pakkaustekniikkana sen yksinkertaisuuden ja monimuotoisuuden ansiosta. Algoritmin arvioidaan pakkaavan tekstiä ja ajettavaa koodia puoleen alkuperäisestä koosta.[3] Pakkausalgoritmi muodostaa 12- bittisen kooditaulukon arvoista, joihin algoritmi iteroi syötteessä esiintyviä bittijonoja ja korvaa ne sanakirjassa esiintyvillä arvoilla. Taulukon ensimmäiset 256 arvoa on alustettu yhden tavun sisältämiin arvoihin (0-255) ja tästä eteenpäin (255-4095) ovat 3 tavun yhdistelmiä, jotka on saatu pakattavasta signaalista. Uusi heräte siirrettään aluksi puskuriin, jota verrataan sanakirjan vanhoihin arvoihin. Mikäli puskurin arvo löytyy sanakirjasta, se korvataan sillä. Jos arvoa ei ole, lisätään se sanakirjaan ja alustetaan puskuri uusimmalla arvolla. Aina kun puskurista löytyvä maksimissaan kolmen tavun yhdistelmä tulee signaalista vastaan se korvataan taulukosta löytyvällä arvolla. Taulukon 3.2 esimerkki kuvastaa algoritmin kulkua virkkeelle the/rain/in/spain/falls/mainly.

12 Puskuri Löytyykö sanakirjasta Lisätty sanakirjaan t kyllä - Ulostulo th ei th= 256 t he ei he = 257 h e/ ei /e = 258 e /r ei /r = 259 / ra ei ra = 260 r ai ei ai = 261 a in ei in = 262 i n/ ei n/ = 263 n /i ei /i = 264 / in kyllä (262) - in/ ei in/ = 265 262 /s ei /s = 266 / sp ei sp = 267 s pa ei pa = 269 p ai kyllä (261) - ain ei ain = 269 261 n/ kyllä (263) - n/f ei n/f = 270 263 fa ei fa = 271 f al ei al = 272 a ll ei ll = 273 l ls ei ls =274 l s/ ei s/ = 275 s /m ei /m = 276 / ma ei ma = 277 m ai kyllä (261) - ain kyllä (269) - ainl ei ainl = 278 269 ly ei ly = 279 l y kyllä - y Taulukko 3.2: LZW- algoritmin esimerkki

13 3.3. Jakson pituuden koodaus Jakson pituuden pakkaaminen perustuu signaalissa esiintyviin sarjoihin, joissa esiintyy samaa arvoa monta kertaa peräkkäin. Tämä toisto voidaan korvata sarjan ensimmäisellä arvolla, mikä kertoo mitä toistetaan ja toisella arvolla, mikä kertoo montako kertaa ensimmäisen arvon luku esiintyy tämän jälkeen. Yksinkertaisena esimerkkinä lukujono 1, 1, 1, 3, 3, 4, 4, 4, 4, 5, 6 > 1, -2, 3, -1, 4, -3, 5, 6. Tässä toistoa kuvaava arvo on annettu negatiivisena, koska se sopii mittaussignaalin kanssa käytettäväksi, mutta muitakin vaihtoehtoja on. Esimerkiksi tekstiä pakattaessa ascii- merkit käyttävät vain seitsemää bittiä 128 arvoa ja kahdeksas bitti jää vapaaksi ilmoittamaan onko käytetty toistoa [4]. Joissain tilanteissa on myös järkevää ilmoittaa toisto ainoastaan yhdelle tai vain muutamalle arvolle yksinkertaisuuden vuoksi ja laittaa toiston määrä aina kyseisen arvon perään. Tätä ominaisuutta käytettäessä on mahdollista että muokataan koodattu signaali alkuperäistä isommaksi, jos yksittäisiä arvoja on paljon. Tämä voisi kuitenkin tulla käytetyksi esimerkiksi nollien kohdalla, jotka audiossa vastaavat hiljaisuutta tai kuvissa mustia alueita.

14 4. ALGORITMIEN TESTAUS Algoritmeja testataan 16- bittisillä signaaleilla, jotka on saatu teollisuusprosessista. Signaali 1 on hienosti käyttäytyvä lämpötilasignaali ja signaalit 2 ja 3 ovat painesignaaleja. Signaalissa 3 kohinan määrä on huomattava. Kuva 4.1: Käytetyt testisignaalit

15 4.1. Pakkaustehokkuus Ensin pyritään pakkaamaan signaalit suoraan kolmella luvussa 3 esitellyllä algoritmilla. Kaikki signaalit ovat 22634 näytettä ja ne pakkautuvat taulukon 4.1 mukaisesti. Huffmanista on ensiksi ilmoitettu yhteiskoko, joka koostuu pakatusta signaalista ja toiseksi huffman- puusta. Kaikki taulukon arvot ovat tavuja. Signaali 1 Signaali 2 Signaali 3 Pakkaamaton 45268 45268 45268 Jakson pituus 40950 42390 39890 Huffman 73059 = 31827 + 41232 57026 = 26354 + 30672 150246 = 34134 + 116112 LZW 36558 36012 39320 Taulukko 4.1: Pakkaustehokkuus esikäsittelemättömille signaaleille Huffman ei onnistu pakkaamaan signaaleita, vaan kasvattaa kokoa miltei kaksinkertaiseksi. Pakkauksessa käytetty Huffman- puu kasvaa signaalia isommaksi. Tarkastelemalla signaalin histogrammia kuvasta 4.2 voidaan todeta tämän pitävän paikkansa, signaalin arvot ovat jakautuneet melko tasaisesti suurimmalle osalle alueesta ja entropiaan perustuva huffman ei onnistu pakkaamaan signaalia. Toistoa hyödyntävä jakson pituuden koodaus vähentää muistin käyttöä 6,4 prosentista 11,9 prosenttiin. LZW pakkaa signaalin keskimäärin 17,6 % pienemmäksi. Signaalin 3 tapauksessa Huffman on kasvattanut signaalin yli kolminkertaiseksi. Vertailun vuoksi muodostettu täysin tasajakautunut signaali kasvoi 6,8 kertaiseksi.

16 Kuva 4.2: Signaalin 1 histogrammi Kuva 4.3: Erotussignaalin 1 histogrammi

17 4.1.1. Esikäsittely erotussignaalilla Toisena kokeena pakataan testisignaalien erotussignaaleja samoilla algoritmeilla. Vertailun vuoksi kuvassa 4.3 on ensimmäisen erotussignaalin histogrammi. Histogrammi on rajattu nollan ympäristöön ja siitä puuttuu muutamia suuria negatiivisia arvoja, jotka näkyvät Kuvassa 2.1 terävinä piikkeinä alaspäin. Erotussignaali on kasvattanut arvojen esiintymistiheyttä kymmenistä näytteistä satoihin näytteisiin ja tämä on edullista pakkausalgoritmeille. Huffman:ssa on ensiksi ilmoitettu yhteiskoko, joka koostuu pakatusta signaalista ja toiseksi Huffman- puusta. Kaikki taulukon arvot ovat tavuja. Signaali 1 Signaali 2 Signaali 3 Pakkaamaton 45266 45266 45266 Jakson pituus 41892 43244 38640 Huffman 17423=14831+ 2592 38453 = 22061 + 16392 72025 = 19873 + 52152 LZW 18252 33980 28436 Taulukko 4.2: Pakkaustehokkuus erotussignaaleille Esiintymistiheyksien kasvusta on eniten hyötyä Huffmanin tapauksessa. Signaalit 1 ja 2 pakkautuvat hyvin, mutta voimakkaasti jakautunut kolmas signaali ei pakkaudu pakkaamatonta signaalia pienemmäksi edes erotussignaalilla. Kolmannen signaalin Huffman- pakkaus on kuitenkin pudonnut yli puoleen esikäsittelemättömään verrattuna. Jakson pituus antaa samansuuntaisia tuloksia kuin ilman esikäsittelyä. LZW:n tapauksessa kaikkien signaalien pakkaustehokkuus on kasvanut, mutta toisin kuin ensimmäisessä kohdassa signaalien välille on tullut huomattavia eroja. 4.1.2. Esikäsittely lineaarisen ennustuksen kertoimilla Kolmantena testinä signaaleille on laskettu lineaarisen ennustuksen kertoimet kymmenellä arvolla ja näillä arvoilla on suodatettu alkuperäiset signaalit. Huffmanissa on ensiksi ilmoitettu yhteiskoko, joka koostuu pakatusta signaalista ja toiseksi huffmanpuusta. Kaikki taulukon arvot ovat tavuja.

18 Signaali 1 Signaali 2 Signaali 3 Pakkaamaton 45268 45268 45268 Jakson pituus 41892 44428 39800 Huffman 17423=14831+ 2592 38317 = 22765 + 15552 119000 = 31928 + 87072 LZW 18252 34724 38700 Taulukko 4.3: Pakkaustehokkuus, kun signaalit on suodatettu LPC:n kertoimilla. LPC:n antamat kertoimet signaalille 1 lähestyvät erotussignaalia kymmenestuhannesosien tarkkuudella toisesta vanhasta näytteestä eteenpäin, joten signaalille 1 arvot ovat samat kuin edellisessä taulukossa. Lineaarisen ennustuksen kertoimilla suodatettu signaali 2 saa pakkaustuloksiksi samansuuntaisia arvoja kun erotussignaalilla. Kolmanteen testisignaaliin lineaarisilla kertoimilla suodatettu signaali toimii erotussignaalia huonommin.

19 5. JOHTOPÄÄTÖKSET Kaikista yksinkertaisin testattu koodaustapa, jakson pituuden koodaus, pääsi signaalista riippuen parista prosentista reiluun kymmeneen prosenttiin. Tulos oli odotetunlainen mittaussignaalille. Huffman- pakkaus osoitti selkeästi olevansa eniten riippuvainen alkuperäisen signaalin jakautumisesta. Signaalin 1 ja 2 tehokkuus kasvoi käsiteltäessä erotussignaalia, joka signaalin 1 tapauksessa vastasi lineaarisen ennustuksen antamaa tulosta. Erotussignaali on siis tälle signaalille optimaalinen esikäsittely. Toisessa ja etenkin kolmannessa signaalissa esiintyvä kohina laajensi pakkauspuun tilantarvetta, mikä vei pakkaustehokkuutta. Signaalia 3 ei onnistuttu pakkaamaan alkuperäistä pienemmäksi esikäsittelyistä huolimatta, vaikka sen kokoa saatiinkin huomattavasti pienennettyä. LZW oli kolmen testatun signaalin monikäyttöisin ja onnistui pakkaamaan kohinaisiakin signaaleja hyvin, kun Huffman ei siihen pystynyt. Algoritmin huonoksi puoleksi on luettava sen raskaus, joka on aivan eri kertaluokkaa kun muut testatut menetelmät. Kohtuullisen tehokkaalla työasemalla pitkien signaalien, 2 miljoonaa näytettä, pakkausajat lähentelivät tuntia, Huffmanin laskiessa saman kymmenissä sekunneissa. Molempien algoritmien Matlab- funktioissa on varmasti optimoinnin varaa, mutta luvut antavat kyllä suuntaa- antavan arvon.

20 LIITE 1 Jakson pituuden matlab- koodi, toistoa merkitään negatiivisilla arvoilla. % jakson pituus enkoodaus function jp_data = jaksonpituus(data) jp_data = int16([]); jp_data = [jp_data; data(1,1)]; laskuri = 0; for index=2:length(data) if ( data(index,1) == jp_data(,1) ) laskuri= laskuri+1; elseif ( laskuri == 0 ) rlc_data = [jp_data; data( index, 1)]; else jp_data = [jp_data; -1*laskuri ]; % tästä voi muuttaa helpost%toimimaan merkkibitillä korvaamalla -1 sopivalla kokonaisluvulla jp_data = [jp_data; data(index,1)]; laskuri = 0; if (laskuri ~= 0) jp_data = [jp_data; -1* laskuri ];

21 LIITE 2 Giuseppe Ridinon 2004 julkaisemaan Huffman- funktioon perustuva matlabtoteutus[5]. function [zipped,info] = norm2huff(vector) vector = vector(:)'; % frequency f = frequency(vector); % simbols presents in the vector are simbols = find(f~=0); % first value is 1 not 0!!! f = f(simbols); % sort using the frequency [f,sortindex] = sort(f); simbols = simbols(sortindex); % generate the codewords as the 52 bits of a double len = length(simbols); simbols_index = num2cell(1:len); codeword_tmp = cell(len,1); while length(f)>1, index1 = simbols_index{1}; index2 = simbols_index{2}; codeword_tmp(index1) = addnode(codeword_tmp(index1),uint16(0)); codeword_tmp(index2) = addnode(codeword_tmp(index2),uint16(1)); f = [sum(f(1:2)) f(3:)]; simbols_index = [{[index1 index2]} simbols_index(3:)]; % resort data in order to have the two nodes with lower frequency as first two [f,sortindex] = sort(f); simbols_index = simbols_index(sortindex); % arrange cell array to have correspondance simbol <-> codeword codeword = cell(65536,1); codeword(simbols) = codeword_tmp; % calculate full string length len = 0;

22 for index=1:length(vector), len = len+length(codeword{double(vector(index))+1}); % create the full 01 sequence string = repmat(uint16(0),1,len); pointer = 1; for index=1:length(vector), code = codeword{double(vector(index))+1}; len = length(code); string(pointer+(0:len-1)) = code; pointer = pointer+len; % calculate if it is necessary to add padding zeros len = length(string); pad = 8-mod(len,8); if pad>0, string = [string uint16(zeros(1,pad))]; % now save only usefull codewords codeword = codeword(simbols); codelen = zeros(size(codeword)); weights = 2.^(0:51); maxcodelen = 0; for index = 1:length(codeword), len = length(codeword{index}); if len>maxcodelen, maxcodelen = len; if len>0, code = sum(weights(codeword{index}==1)); code = bitset(code,len+1); codeword{index} = code; codelen(index) = len; codeword = [codeword{:}];

23 % calculate zipped vector cols = length(string)/8; string = reshape(string,8,cols); weights = 2.^(0:7); zipped = uint8(weights*double(string)); % store data into a sparse matrix huffcodes = sparse(1,1); % init sparse matrix for index = 1:numel(codeword), huffcodes(codeword(index),1) = simbols(index); % create info structure info.pad = pad; info.huffcodes = huffcodes; info.ratio = cols./length(vector); info.length = length(vector); info.maxcodelen = maxcodelen; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% function codeword_new = addnode(codeword_old,item) codeword_new = cell(size(codeword_old)); for index = 1:length(codeword_old), codeword_new{index} = [item codeword_old{index}]; function f = frequency(vector) f = histc(vector(:), 0:65535); f = f(:)'/sum(f); % always make a row of it return;

24 LIITE 3 Giuseppe Ridinon 2004 julkaisemaan lzw- funktioon perustuva matlab- toteutus[6]. function [output,table] = norm2lzw(vector) %NORM2LZW LZW Data Compression (encoder) % For vectors, NORM2LZW(X) is the compressed vector of X using the LZW algorithm. % [...,T] = NORM2LZW(X) returns also the table that the algorithm produces. % % For matrices, X(:) is used as input. % % Input must be of uint8 type, while the output is a uint16. % Table is a cell array, each element containig the corresponding code. % % This is an implementation of the algorithm presented in the article % http://www.dogma.net/markn/articles/lzw/lzw.htm % % See also LZW2NORM % $Author: Giuseppe Ridino' $ % $Revision: 1.0 $ $Date: 10-May-2004 14:16:08 $ % How it encodes: % % STRING = get input character % WHILE there are still input characters DO % CHARACTER = get input character % IF STRING+CHARACTER is in the string table then % STRING = STRING+character % ELSE % output the code for STRING % add STRING+CHARACTER to the string table % STRING = CHARACTER % END of IF % END of WHILE % output the code for STRING

25 % ensure to handle uint8 input vector %if ~isa(vector,'uint8'), % error('input argument must be a uint8 vector') % % vector as uint16 row vector = uint16(vector(:)'); % initialize table (don't use cellstr because char(10) will be turned to empty!!!) table = cell(1,256); for index = 1:256, table{index} = uint16(index-1); % initialize output output = vector; % main loop outputindex = 1; startindex = 1; for index=2:length(vector), element = vector(index); substr = vector(startindex:(index-1)); code = getcodefor([substr element],table); if isempty(code), % add it to the table output(outputindex) = getcodefor(substr,table); [table,code] = addcode(table,[substr element]); outputindex = outputindex+1; startindex = index; else, % go on looping substr = vector(startindex:index); output(outputindex) = getcodefor(substr,table); % remove not used positions output((outputindex+1):) = [];

26 % ############################################### function code = getcodefor(substr,table) code = uint16([]); if length(substr)==1, code = substr; else, % this is to skip the first 256 known positions for index=257:length(table), if isequal(substr,table{index}), code = uint16(index-1); % start from 0 break function [table,code] = addcode(table,substr) code = length(table)+1; % start from 1 table{code} = substr; code = uint16(code-1); % start from 0

LÄHTEET [1] Parsons, T., Voice and Speech Processing,, McGraw-Hill. pp. 138-141, 1987. [2] Salomon, D., Data Compression The complete reference, Springer-Verlag London Limited. pp. 74-75, 2007. [3] Smith, S. W., The Scientist and Engineer's Guide to Digital Signal Processing, California Technical Publishing. 488s, 1997. [4] Ascii- taulukko [WWW]. [viitattu 21.4.2009]. Saatavissa: http://www.asciitable.com/ [5] Huffman koodi Matlab:yn [WWW]. [viitattu 2.5.2009]. Saatavissa: http://www.mathworks.com/matlabcentral/fileexchange/4900 [6] LZW koodi Matlab:yn [WWW]. [viitattu 2.5.2009]. Saatavissa: http://www.mathworks.com/matlabcentral/fileexchange/4899