Muzikale controller aan de hand van videobeelden Jaan...
110
Jaan Claeys Muzikale controller aan de hand van videobeelden Academiejaar 2007-2008 Faculteit Ingenieurswetenschappen Voorzitter: prof. dr. ir. Herwig Bruneel Vakgroep Telecommunicatie en informatieverwerking Master in de toegepaste informatica Masterproef ingediend tot het behalen van de academische graad van Begeleiders: Rik Bellens, Werner Goeman Promotor: prof. dr. ir. Wilfried Philips
Transcript of Muzikale controller aan de hand van videobeelden Jaan...
Jaan Claeys
Muzikale controller aan de hand van videobeelden
Academiejaar 2007-2008Faculteit IngenieurswetenschappenVoorzitter: prof. dr. ir. Herwig BruneelVakgroep Telecommunicatie en informatieverwerking
Master in de toegepaste informaticaMasterproef ingediend tot het behalen van de academische graad van
Begeleiders: Rik Bellens, Werner GoemanPromotor: prof. dr. ir. Wilfried Philips
Ontwikkeling van een muzikale controller aan de hand van videobeelden door
Jaan CLAEYS
Masterproef ingediend tot het behalen van de academische graad van
Master na Master toegepaste informatica
Academiejaar 2007-2008
Promotor: Prof. Dr. Ir. W. PHILIPS
Begeleider: Ir. R. BELLENS, Ir. W. GOEMAN
Faculteit Ingenieurswetenschappen
Universiteit Gent
Vakgroep Telecommunicatie en informatieverwerking
Voorzitter: Prof. Dr. Ir. W. PHILIPS
Samenvatting
Een muzikale controller wordt ontwikkeld die aan de hand van videobeelden muziek
controleert
In de inleiding wordt de problematiek uitgelegd.
Hoofdstukken 2 tot en met 5 behandelen de methode vanuit een musicologisch
kader
Hoofdstukken 6 tot en met 8 behandelen de ontwikkeling van de software
Hoofdstuk 9 behandelt enkele mogelijke toepassingen.
Het besluit bevat enkele verdere evoluties in de software
Trefwoorden: muzikale controller, videoanalyse, interactief systeem
ii
Toelating tot Bruikleen
“De auteur geeft de toelating deze masterproef voor consultatie beschikbaar te
stellen en delen van de masterproef te kopiëren voor persoonlijk gebruik.
Elk ander gebruik valt onder de beperkingen van het auteursrecht, in het bijzonder
met betrekking tot de verplichting de bron nadrukkelijk te vermelden bij het aanhalen
van resultaten uit deze masterproef.”
iii
A Musical Controller with video images Jaan Claeys
Supervisor: Wilfried Philips
I. INTRODUCTION A low-cost multi-useable realtime musical
controller for Microsoft Windows was made that enhances musical expressiveness for performers, musicians and physically disabled people. With a simple webcam, a musical controller was developed. A framework from musical science was used for developing this controller.
II. FRAMEWORK The structure of Claeys’ thesis was used for
constructing and evaluating a gestual controller [1]. Benford et al was used for deciding on the movements used [2]. Desirable, Sensable, and Sensible movements for the interface where evaluated for the development for the software. The mapping of musical parameters to physical movements followed the structure of Hunt [3]. He describes a distinction between explicit parameters and generative mechanisms. A two-layer mapping was used, where the data from the input was separated from the musical output. The generation of music hereby lies with the user.
III. STRUCTURE
A. Input A webcam was used because of the wide-
spread commercial availability. Microsoft Windows DirectShow was used to get the input for the webcam
B. Image analysis The open source library OpenCv was used
to analyze images. A non-recursive method was used for fast realtime background extraction. After evaluation a median difference method was used for extracting the background. A median filter was used to minimize unwanted noise in the resulting image.
The user has the ability to draw rectangles on the screen that can be manipulated as a slider or as a trigger for musical events. In addition, a bounding rectangle was drawn around the user, and the parameters of this rectangle where stored for sending to an external application.
C. Output Two protocols where used for sending
parameters to an external application, or external device.
OpenSound Control by Matt Wright was used for sending parameters of the bounding recatnle, and the drawn rectangles [4]Error! Reference source not found.. The protocol can be send through a network to other systems or the Internet in a UDP packet.
MIDI was used for sending parameters of the drawn rectangles to external devices.
D. Musical generation The controller can be used to control
external devices or a wide range of musical software applications.
Max/MSP was used to illustrate the usefulness of the controller. Three applications where made, these include • A sampler controlled by fingers
• An analysis of movements that implements the theory of effort from Rudolf Laban [5][5].
• A controller for a synthesizer Other applications for physical disabled
people where suggested.
IV. CONCLUSION A low-cost musical controller was made
that can be used in many ways, through a simple interface. Algorithms were evaluated for speed. Because of the support for wide used musical protocols, the software can interact with the most common musical applications and devices. Many applications can be thought of for the controller. It can be a tool for musicians with instrument, for laptop musicians and for disabled people.
REFERENCES [1] Claeys, J. (2006). Gestuele interactieve
systemen. Naar een technisch analysekader voor extractie van expressieve bewegingen. Unpublished Thesis, Universiteit Gent, Gent.
[2] Benford, S., Schnadelbach, H., Koleva, B., Gaver, B., Schmidt, A., Boucher, A.,Steed, A., Anastasi, R., Greenhalgh, C., Rodden, T., and Gellersen, H. (2003). Sensible, Sensable and Desirable: a Framework for Designing Physical Interfaces, Technical Rapport Equator-03-2003, Equator.
[3] Hunt, A., Kirk, R. (2000). Mapping Strategies for Musical Performance. In M. M. Wanderley, M. Battier (Eds.), Trends in Gestural Control of Music, [CDROM]. Parijs: Ircam.
[4] . Wright, M., Freed, A., Momeni, A. (2003). OpenSound Control: State of the Art 2003. In Proceedings of the 2003 Conference on New Interfaces for Musical Expression (NIME-03) (pp. 153-159). Montreal: McGill University
[5] Laban, R., Lawrence F. C. (1974). Effort (2nd Edition). London: MacDonald and Evans.
Inhoudstafel
1. Inleiding................................................................................................................................. 1
2. Interactief muzieksysteem ..................................................................................................... 4
3. Relevante bewegingen ........................................................................................................... 5
4. Verwante programma’s......................................................................................................... 9 4.1. Visuele Dataflow programmeertalen........................................................................................ 9 4.2. EyesWeb.................................................................................................................................... 11 4.3. Vvvv........................................................................................................................................... 11 4.4. Andere....................................................................................................................................... 12 4.5. Evaluatie ................................................................................................................................... 13
5. Opbouw Systeem.................................................................................................................. 14 5.1. De Webcam............................................................................................................................... 14 5.2. Verwerking van de gegevens................................................................................................... 15 5.3. Output van de gegevens........................................................................................................... 15 5.4. Muziekgeneratie ....................................................................................................................... 16
6. Behoeftenanalyse en architectuur ...................................................................................... 19 6.1. Behoeftenanalyse...................................................................................................................... 19
6.1.1. Operationele Scenario’s..................................................................................................................... 19 6.1.2. UML case Diagram ........................................................................................................................... 23 6.1.3. Use-Case beschrijving ....................................................................................................................... 24
6.2. Architectuur: statische analyse............................................................................................... 32 6.2.1. Projectbeschrijving ............................................................................................................................ 32 6.2.2. Klassenlijst ........................................................................................................................................ 33 6.2.3. UML klassendiagram ........................................................................................................................ 35
6.3. Architectuur: dynamische analyse ......................................................................................... 36 6.3.1. Interactiediagrammen ........................................................................................................................ 36
7. Systeem- en gedetailleerd ontwerp...................................................................................... 44 7.1. Systeemontwerp ....................................................................................................................... 44
7.1.1. Subsystemen ...................................................................................................................................... 44 7.1.2. Packagediagram................................................................................................................................. 46 7.1.3. Contracten tussen subsystemen ......................................................................................................... 47
7.2. Gedetailleerd ontwerp ............................................................................................................. 49 7.2.1. Subsysteem: <Netwerk>.................................................................................................................... 49 7.2.2. Subsysteem: <Analyse> .................................................................................................................... 50 7.2.3. Subsysteem:<Instellingen>................................................................................................................ 52 7.2.4. Subsysteem: <GUI> .......................................................................................................................... 53 7.2.5. Subsysteem: <Rechthoeken Tekenen> .............................................................................................. 55
8. Implementatie ...................................................................................................................... 57 8.1. Implementatie en integratie .................................................................................................... 57
8.1.1. Naam ................................................................................................................................................. 57 8.1.2. Programmeertaal................................................................................................................................ 57 8.1.3. Module afhankelijkheid..................................................................................................................... 59 8.1.4. Testen ................................................................................................................................................ 87
iv
9. Toepassingen ....................................................................................................................... 89 9.1. Volledige lichaamsbeweging, convergente strategie ............................................................. 89 9.2. Hulpmiddel voor muzikanten met instrument ...................................................................... 92 9.3. Hulpmiddel voor elektronische muzikanten.......................................................................... 93 9.4. Muziek voor fysiek gehandicapte mensen.............................................................................. 94
10. Besluit ................................................................................................................................ 95
Bijlagen.................................................................................................................................... 97
Referenties ............................................................................................................................... 98
v
Gebruikte afkortingen en symbolen
API Application Programming Interface
CMNAT Center for New Music and Audio Technologies
CMOS Complementary Metal Oxide Semiconductor
COM Component Object Model
CPU Central Processing Unit
DMX Digital MultipleX
GEM Graphics Environment for Multimedia
GUI Graphical User Interface
HCI Human Computer Interaction
HTTP Hypertext Transfer Protocol
IP Internet Protocol
IRCAM Institue de Recherche et Coordination Acoustique/Musique
ISPW IRCAM Signal Processing Workstation
MCI Media Control Interface
MFC Microsoft Foundation Classes
MIDI Musical Instrument Digital Interface
MIT Massachusetts Institute of Technology
MOG Mixture of Gaussians
MSP Max Signal Processing
MTU Maximum Transfer Unit
OpenGL Open Graphics Library
OSC OpenSound Control
RGB Red Green Blue
RS232 Recommended Standard 232
RTP Real Time Protocol
SIMD Single Instruction Multiple Data
SQL Structured Query Language
SSE2 Streaming SIMD Extensions 2
TCP Transmission Control Protocol
UDP User Datagram Protocol
UML Unified Modelling Language
vi
URL Uniform Resource Locator
USB Universal Serial Bus
vii
1. Inleiding De komst van de computer in de tweede helft van de twintigste eeuw heeft alle
aspecten van het dagelijks leven beïnvloed. De laatste twintig jaar zijn computers
sterk genoeg om digitale media te verwerken en te produceren. Technologische
verbeteringen op audiovisueel vlak, zoals grafische kaarten en geluidskaarten maken
van de computer een hulpmiddel bij de verwerking en de productie van zintuiglijke
signalen.
Kunstenaars maken dankbaar gebruik van deze technieken om nieuwe kunst te
produceren. Interactieve kunst is daar een onderdeel van. Waar de hoofdzakelijk via
muis en keyboard gebeurt in de metafoor van een bureau, zoekt men in de
interactieve kunst naar meer natuurlijke methodes om computers kunst te laten
produceren.
De industrie van muzikale controllers breidt zich dan ook uit. Met de komst van
muziekproductie programma’s als Ableton, Cubase, Reason en vele andere, zoeken
muzikanten ook steeds meer een houvast in hun optredens. Enerzijds om een fijnere
controle te hebben over de muziekproductie, waar aanslaggevoeligheid van een
controller essentieel is, en anderzijds om bij optredens het publiek een visueel
spektakel te bezorgen. Laptop performances zijn dan ook heel statisch en zonder
visuele projecties of lichten zijn ze betrekkelijk eentonig om naar te kijken.
De eerste muzikale controllers voor computer waren MIDI keyboards (Musical
Instrument Digital Interface). Het MIDI protocol is een standaard in de
muziekindustrie die informatie bevat over de aanslaggevoeligheid en de toonhoogte.
Vele controllers uit de jaren ‘80 en ‘90 werken met dit protocol.
Geluidseffectenmodules, snaarinstrumenten en zelfs blaasinstrumenten werden
vervaardigd die dit protocol ondersteunen. Het voordeel was dat apparaten aan
elkaar gekoppeld konden worden. Een viool kan het geluid voortbrengen van een
synthesizer, een blaasinstrument van een drum enzovoort. Het nadeel was echter
dat het MIDI protocol toonhoogte gericht is, het beslaat tien octaven, omgerekend
128 verschillende noten. De grote kritiek is uiteraard dat dit nooit kan instaan voor de
subtiliteit van een akoestisch instrument. Het beslaat nooit de totale dynamiek die
een muzikant kan vormen, het kan ook geen tonen produceren die niet in het octaaf
1
liggen, toch niet rechtstreeks. Als trigger van geluiden is het echter een voldoende
protocol en kent het nu nog altijd een groot succes in de muziekindustrie.
In de academische wereld ging er meer aandacht naar alternatieve controllers.
Sensorische input was hier de meest gebruikte vorm van muzikale interactie. Radar,
sonar, infrarood, biometrie, capaciteit, druksensoren, zelfs warmte en vochtigheid
werden gebruikt om exotische controllers of gehele instrumenten te bouwen voor
muzikanten. Deze creaties zien echter alleen het daglicht op conferenties,
gespecialiseerde evenementen, of performances. Uiteraard heeft dit veel te maken
met de kostprijs van de ontwikkeling en ook met de gebruikte sensoren. Dit
weerhoudt de modale muzikant om deze controllers daadwerkelijk te gaan
gebruiken.
De laatste vijf jaar zijn er echter bedrijven gesprongen op het vervaardigen van
controllers die tevens dienen als interface. De monome, de ReacTable en de lemur
zijn multi-touch interfaces die moduleerbaar zijn en samenwerken met
muziekproductiesoftware. De monome bestaat uit een matrix van knoppen die licht
kunnen geven en waarvan iedere knop instelbaar is. De ReacTable is een multi-
touch tafel, waarop men objecten kan plaatsen die een specifieke functie krijgen,
bijvoorbeeld een oscillator. De lemur is een scherm waarop men controls kan zetten
die je normaal in software met de muis aanstuurt. Het scherm is een multi-touch
interface en aanpasbaar naar de noden van de gebruiker. Deze apparaten geven
een aangenamere manier om muziek te controleren, maar met uitzondering van de
ReacTable, die met fysische objecten werkt zijn het controllers die voor een kijkend
publiek minder interessant zijn. Ze combineren software en hardware in één
interface. Uiteindelijk zijn deze producten duur en vervangbaar. Zoals een waakzame
muzikant opmerkt kun je dezelfde resultaten bekomen voor 40 dollar, met gebruik
van een infrarode sensor en een Nintendo wii controller (op voorwaarde dat je deze
bezit uiteraard).
Hier begint dan ook de zoektocht naar een muzikale controller die kosteloos is,
visueel interessant is, moduleerbaar is, samenwerkt met andere software, met
meerdere personen bespeelbaar is en zelfs personen met een fysieke handicap
toelaat om muziek te spelen.
De goedkoopste sensor, naast het keyboard en de muis, die wijd ondersteund is voor
de computer is de webcam. Voor 15 tot 20 euro is een webcam beschikbaar in de
winkel. Het wordt veelvuldig gebruikt bij instant messenger toepassingen. Het laat
2
mensen toe visueel te communiceren, zonsopgangen te zien in andere landen en
meer.
Deze masterproef behandelt het vervaardigen van een softwarematige muzikale
controller aan de hand van bewegingen geregistreerd door een webcam.
Hoofdstukken 2 tot 5 beschrijven de noden van het project vanuit enkele
musicologische kaders en de praktische keuzes die hierbij gemaakt zijn.
Hoofdstukken 6 tot 8 behandelen de ontwikkeling van de software. Hoofdstuk 9
behandelt enkele van de mogelijke toepassingen.
3
2. Interactief muzieksysteem Mijn onderzoek tijdens mijn studie musicologie hield een technisch analysekader in
voor gestuele interactieve systemen (Claeys 2006). Computersystemen zijn in staat
gegevens van de buitenwereld te ontvangen, te interpreteren, te verwerken, en deze
gegevens terug uit te sturen naar de wereld. Muzikale mens-machine interactie is
dan ook een lus die start bij de mens. De mens verricht een handeling vanuit zijn
geheugen en cognitie. Hij voert dit uit via musculaire arbeid. Deze handeling wordt
dan door sensoren opgenomen en omgezet naar een digitale gegevens. Deze
gegevens worden op hun beurt door software verwerkt en terug omgezet naar
analoog geluid. Dit zijn de noodzakelijke voorwaarden voor muzikale interactie
tussen mens en machine. Er moet opgemerkt worden dat mijn systeem geen totaal
interactief systeem zal zijn. Doordat enkel een controller vervaardigd wordt, ligt de
muziekcreatie enigszins open. Men kan kiezen voor een interactief systeem, door
over langere tijd informatie te verzamelen, en beslissingen te laten nemen, of men
kan reactief werken, zodoende dat elke input een nieuwe muzikale input geeft. De
weg ligt enigszins open voor de gebruiker van het programma, alsmede zijn rol in het
interactief proces.
De reden voor het ontbreken van een totaal systeem is in de eerste plaats om de
artistieke vrijheid te waarborgen voor de gebruikers van de controller. Op technisch
gebied laat het ook toe de analyse en synthese te splitsen op meerdere systemen.
Vele instanties van de controller kunnen één muzikaal systeem beïnvloeden.
4
3. Relevante bewegingen Het onderzoek naar relevante data voor muzikale expressie werd onderzocht in mijn
masterproef musicologie. Een interactief systeem wordt geëvalueerd vanuit zijn
mogelijkheden. Benford heeft onderzoek gedaan om te komen tot een zinvolle
fysieke interactie met interfaces (Benford et al. 1993). Hij onderscheidt sensible,
sensable en desirable types bewegingen voor interfaces. Sensible movements zijn
alle bewegingen die verwacht worden van mensen in de context van de interface.
Het zijn natuurlijke bewegingen voor de combinatie van de gebruiker, interface en
omgeving. Bijvoorbeeld de muis horizontaal bewegen op een oppervlak is sensible,
de muis opheffen en verplaatsen naar een ander deel van de tafel is ook sensible.
Minder sensible is er constant mee in de lucht zwaaien. De bewegingen die niet
sensible zijn, zijn de bewegingen die fysiek onmogelijk zijn met de interface.
Sensable movements zijn bewegingen die kunnen gedetecteerd worden door de
interface. Alhoewel bijvoorbeeld de muis opheffen en ze verplaatsen zinvol is voor de
gebruiker is deze echter niet detecteerbaar door de controller zelf, en dus niet
sensable. Desirable movements zijn bewegingen die nodig zijn om specifieke taken
uit te voeren. De bewegingen die zowel sensible, sensable en desirable zijn, zijn de
bewegingen die instaan voor de muziekcreatie (zie figuur 1).
5
Figuur 1
De eerste vraag is dan wat sensable en sensible is met een webcam. Een
alleenstaande webcam is uiteraard beperkt door een tweedimensionale representatie
van de werkelijkheid. Diepte kan niet gezien worden met een enkele camera. De
camera heeft ook de limiet van zijn kader, en het aantal beelden per seconde. Omdat
de webcam gebruikt zal worden voor het traceren van bewegingen moet de
lichtgevoeligheid vermeld worden. Snelle veranderingen in lichtomstandigheden
kunnen verstoring geven van het gebruikte algoritme.
Wat overblijft is een representatie van verticale en horizontale verplaatsing en de
snelheid van de beweging over tijd. Door het verschil tussen twee frames kan de
verticale versnelling en horizontale versnelling berekend worden. Naast deze
elementaire berekeningen zijn er ook geavanceerde technieken om dingen te
traceren. Objecten kunnen getraceerd en gevolgd worden, of specifieke objecten,
bijvoorbeeld ogen of gezichten kunnen herkend worden.
Hieruit kunnen we desirable movements extraheren. Uit wat we kunnen traceren
zinvolle bewegingen halen voor de creatie van muziek. De beste opstelling voor de
interace is een webcam juist boven of onder het scherm. De gebruiker beweegt dan
met het gezicht en lichaam recht voor het scherm of projectie en gebruikt ledematen
6
om te bewegen in twee dimensies. Doordat hij zijn eigen persoon en enkele
getekende objecten of indicaties ziet kan hij zichzelf corrigeren. Het beeld dat
getoond wordt fungeert dus als spiegel voor de bewegende persoon. De gebruiker
zal dus het inkomende beeld kunnen spiegelen als hij dat nodig acht. De beperking
van de webcam wordt zo enigszins gereduceerd. Globaal gezien kunnen we stellen
dat als de persoon beweegt er sprake is van actie en ook van muzikaal geluid en
omgekeerd is er bij volledige stilstand geen muzikaal geluid.
Het eerste wat we nodig hebben is dus een afdruk van het bewegend lichaam.
Hiervoor moeten we alles wat sensable is en niet desirable elimineren. In een eerste
instantie is dit de kleur van het beeld. Kleuren brengen trouwens weinig zinvolle
informatie voor bewegingsinteractie. In een tweede instantie bevat de statische
achtergrond geen zinvolle informatie. Een kleurloos beeld van de bewegende
persoon is de informatie die desirable is voor deze toepassing.
Uit dit beeld moeten nu parameters gehaald worden voor controle van muziek. Hier
staan we voor een moeilijke kwestie op artistiek vlak. Er moeten namelijk
bewegingsparameters verbonden worden met muzikale parameters. De controller
moet veel kunnen toelaten om de artistieke vrijheid van zijn gebruiker niet te
beknotten, maar eveneens genoeg informatie verschaffen. Er zijn echter
verschillende mogelijkheden om parameters op mekaar af te stellen. Hunt et al.
(Hunt, Kirk, 2000) geven een goed overzicht van de problematiek. Mapping wordt in
deze context omschreven als de verbinding of correspondentie tussen parameters
van controle en parameters van geluidssynthese. Hij onderscheidt twee grote
strategieën voor de mapping:
• Expliciete mappingsstrategieën
• Generatieve mechanismen
Het eerste type is een directe controle. Parameters worden rechtstreeks aan mekaar
verbonden. Onderscheid wordt hierbij gemaakt met het aantal parameters aan beide
zijde (Rovan et al 1997).
• Een naar een: één gestuele parameter aan één muzikale parameter
• Divergentie: één gestuele parameter aan vele muzikale parameters
• Convergentie: vele gestuele parameters aan één muzikale parameter
Elke soort heeft uiteraard zijn nadelen. Het eerste biedt weinig expressiviteit, maar is
eenvoudig en sterk controleerbaar. Divergentie geeft nadelen voor intieme controle
7
van het instrument, maar vereenvoudigt de gestuele controle. Convergentie kan veel
expressiviteit bieden maar bemoeilijkt het aanleren van het instrument.
Een generatieve mappingsstrategie biedt het voordeel dat de mapping niet vaststaat.
Met behulp van artificiële intelligentie kan ze veranderd of aangepast worden.
Neurale netwerken kunnen bijvoorbeeld getraind worden, tot het gewenste resultaat
bekomen is.
Het onderzoek van Hunt kwam tot de conclusie dat twee-lagige mapping flexibiliteit
creëert. Door twee lagen te introduceren wordt de input en dus het sensoriële
gedeelte losgekoppeld van het synthese gedeelte. Dit is ook wat deze controller
beoogt. Enerzijds velerlei toepassingen en uitvoeringen mogelijk te maken, en
anderzijds zo zinvol mogelijke informatie meegeven om tot muzikale controle te
komen.
Voorbeelden van mappingsstrategieën zijn te vinden bij de toepassingen in deel 3.
Er worden twee pistes bewandeld voor deze strategieën veel mogelijkheden te
bieden. Voor de expliciete convergente en divergente mappingsstrategieën, alsook
voor generatieve mechanismen zal er een snelle achtergrondextractie worden
geïmplementeerd die zich snel aanpast, zodat bij stilstaande fases het lichaam als
achtergrond beschouwd wordt. Daarboven wordt een omsluitende rechthoek
getekend.
Redenen hiervoor zijn de volgende:
• Een stilstaande fase kan makkelijk herkend worden. Het laatste bewegend
beeld kan beschouwd worden als stilstaande fase.
• Het biedt ledematen de kans om individueel te reageren. Zo kan een arm en
bewegende hand gebruikt worden voor controle, terwijl andere delen van het
lichaam niet bewegen.
• Een algoritme dat snel verandert is minder rekenintensief dan die over lange
tijd, ook een omsluitende rechthoek tekenen vergt weinig rekenkracht. Cf. Infra
in deel twee onder testen
Voor één naar één mappingsstrategieën zal er een tekenmodule geïmplementeerd
worden, waar rechthoeken getekend kunnen worden, die dienst doen als controle
over een zelf in te vullen muzikale parameter. De rechthoeken kunnen ofwel
schuifbalken zijn met een bepaalde oriëntatie, of gewoon triggers. De tekeningen
kunnen opgeslagen worden in een bestand met type drw.
8
4. Verwante programma’s Uiteraard is er software op de markt die webcam beelden analyseert. Sommige zijn
zelf specifiek toegeënt op interactieve media. Ik beschrijf hier enkele van die
programma’s en ook de motivering waarom ik deze niet gebruik.
4.1. Visuele Dataflow programmeertalen De meeste programma’s die speciaal ontwikkeld zijn voor interactieve systemen te
bouwen zijn visuele dataflow programmeertalen. Het dataflow model werd
uitgevonden door William Robert Sutherland in 1966 (Sutherland 1966). Hij stelde
een interactieve grafisch systeem voor als tweedimensionale programmeertaal. Hij
ontwikkelde dit op een TX-2 computer. Het is een natuurlijke manier om parallelle
processen uit te drukken. In zekere zin bouwt hij voort op aspecten van de HCI
(Human Computer Interaction), zoals Sketchpad van Ivan Sutherland (Sutherland
1963). Maar hij past dit toe in een visualisatie van procedures.
Het dataflow programmeermodel gaat lijnrecht in tegen het imperatief
programmeren. Waar een series van opdrachten worden gegeven bij imperatief
programmeren, en de data onzichtbaar is, brengt men met het dataflow model de
data op de voorgrond. Opdrachten worden vervangen door objecten die een functie
voorstellen met input en output. Van zodra ze genoeg data ontvangen voeren ze hun
functie uit en geven ze de output door naar een andere functie. We hebben
bijvoorbeeld deze simpele functie in een imperatieve programmeertaal:
BACYB
YXA
*9
=−=+=
Het is meteen duidelijk dat de twee eerste opdrachten simultaan kunnen uitgevoerd
worden. Opdracht B moet in feite niet wachten totdat opdracht A zijn bewerking
gedaan heeft. Ze kunnen simultaan gebeuren want ze beschikken al over de nodige
data. In dataflow programmeertaal ziet de opdracht er als volgt uit (zie figuur 2)
9
Y X 9
-+
*
C
Figuur 2
De twee eerste opdrachten worden nu parallel uitgevoerd. Voor parallelle processen
is dit handig, om dat de status van verschillende condities die in het systeem
aanwezig zijn, niet moet worden bijgehouden. Alle functies zijn klaar om data te
verwerken op hetzelfde moment. De praktijk is natuurlijk anders dan de theorie. Waar
men in theorie oneindige parallelle processen kan creëren, is dit natuurlijk onmogelijk
op hardware gebied. Meeste computers hebben slechts één tot vier processoren.
Men moest in de jaren ’80 constateren dat het dataflow model, waarbij telkens één
en slechts één instructie werd uitgevoerd per functie, een inefficiënt model was. Een
hybride model, tussen het dataflow model, en een sequentieel model was veel
efficiënter. De functies zelf konden zo enkele sequentiële codes bevatten, zodoende
werd het parallelle aspect op grotere schaal toegepast (Johnston et al 2004). In de
beginjaren van het dataflow model werd deze niet visueel gerepresenteerd, maar via
speciale hardware tekstueel werd ingebracht. In de jaren ’90 was er dan een
opkomst van visuele dataflow programmeertalen. Hierbij werd de programmeertaal
visueel voorgesteld, en de muis werd hierbij gebruikt om objecten met elkaar te
verbinden. In praktijk zijn deze programma’s handig bij signaalverwerking, en
metingen. Ze werken op een intuïtieve, grafische manier en er is een minieme kennis
van programmeren nodig. Het meest gekende programma is ongetwijfeld LabView
10
van National Instruments. De hardware van National Instruments ontvangt data aan
hoge bitsnelheden. Met de LabView programmeeromgeving wordt die data verwerkt.
Geluidssynthese, of verwerking is vergelijkbaar met de signalen die LabView
ontvangt, hierdoor was er een steile opkomst van visuele dataflow programmeertalen
eind jaren ’80.
4.2. EyesWeb EyesWeb is een open software platform dat de ontwikkeling van realtime
multimodale gedistribueerde interactieve applicaties ondersteunt. Met andere
woorden, een platform om aan interactie met de computer te doen. Het werd
ontwikkeld door het InfomusLab in Genoa, Italië. Het leunt sterk aan bij mijn project,
omdat er een grote focus is op videoanalyse. Het programma zelf is een visuele
dataflow programmeertaal. Blokjes die een functie voorstellen kunnen met mekaar
verbonden worden. Deze blokjes hebben enkele parameters die aangepast kunnen
worden. De parameters kunnen aangepast worden door de parameters te verbinden
met andere functies of door in het eigenschappenvenster van de blokjes wijzigingen
uit te voeren. Nadat je een aantal blokjes met mekaar verbonden hebt kan je het
programma doen lopen. Het programma is echter niet aanpasbaar vanaf dat het
loopt in tegenstelling tot sommige andere visuele programmeertalen. Het aanvaardt
enkel externe input of output, gedurende de periode dat het programma loopt. Het
programma laat input toe via de webcam en kan vele bewerkingen doen op het
inkomend beeld. Het gebruikt de OpenCV bibliotheek voor videobewerking. Met een
beetje oefening kan veel bereikt worden met EyesWeb. Het grote probleem is echter
de snelheid van de verwerking. Alleen al bij het tonen van het beeld is er tot 100 ms
vertraging. Wat zeer onbruikbaar is voor realtime controle. Voor het bespelen van
een instrument is dit veel te traag. In andere projecten kan dit echter wel van nut zijn.
Bijvoorbeeld als de muziek over de lange duur verandert, door de analyse van grote
buffers van beeldmaterialen. Om bijvoorbeeld als drummachine te kunnen gebruiken
is het systeem zeer onpraktisch, maar om grote muzikale parameters over tijd te
doen veranderen kan dit programma zeker dienst doen.
4.3. Vvvv Vvvv is een software programma voor realtime video synthese. Het werd ontworpen
voor de behandeling van grote media omgevingen met fysieke interfaces,
11
gegenereerde visuals en audio. Het is eveneens een visuele dataflow
programmeertaal. Het draait onder Windows en gebruikt de DirectX bibliotheek. Het
is gratis beschikbaar voor niet commercieel gebruik. Indien je professioneel bezig
bent met videosynthese is een licentie wel vereist. Het bevat heel wat methodes om
de grafische kaart rechtstreeks aan te spreken, en zo objecten te tekenen. In
tegenstelling tot EyesWeb gebeurt alles in realtime. Er is geen startknop voorzien.
Vvvv voorziet video input en enkele standaard videoanalyse algoritmes. Deze zijn
echter ook geschreven met behulp van OpenCV en Freeframe. Freeframe is een
standaard voor video-plugins, die op vele platformen en in vele programmeertalen
gebruikt kan worden. Op zich laat Vvvv niet toe om externe objecten te maken, maar
dus wel deze Freeframe plugins. Daardoor ben je weer aangewezen om te
programmeren in C++ indien je aan videoanalyse wil doen met behulp van OpenCV.
Het programma is bedoeld voor mooie bewegende beelden te genereren aan de
hand van de videokaart. Zou dit programma echter zich meer toeleggen op
videoanalyse, dan zou het een groot succes worden bij mensen die realtime beelden
willen analyseren. Het werkt veel sneller dan EyesWeb en is veel intuïtiever om mee
te werken. Daarenboven ondersteunt het vele protocollen en talen: TCP, UDP, MIDI,
OSC, DMX, HTTP, SQL en meer. Spijtig genoeg dient dit programma meer de VJ
gemeenschap dan de muzikant.
4.4. Andere Naast deze twee visuele dataflow programmeertalen bestaan er nog andere kleine
programma’s die een open bron hebben. Zo is er Peripheral Midi Controller, een leuk
programma van Ben X Tan. Het is zijn bedoeling om meerdere externe apparaten te
kunnen verbinden en zijn input om te zetten naar MIDI-signalen. Hij is begonnen met
de input van een webcam. Het algoritme berekent de positie van het meest witte
punt. Dit kan dus een lichtje zijn of een witte handschoen. Het scherm kan je
verdelen in vier gelijke delen. Naargelang dit punt in één van de vier delen zit, kan je
tot vijf MIDI signalen uitzenden. Een andere modus, is het berekenen van drie
dimensies. De x en y coördinaat van het punt, en de lichtsterkte van het punt Het
programma is geschreven in C++ met behulp van OpenCV. Alhoewel het programma
heel eenvoudig is, is dit programma het meest gebruiksvriendelijk. Je installeert het
programma en dan kun je al aan de slag. Iedereen is vertrouwd met de
12
windowsomgeving en zijn interface, zodat een gebruiker snel weet wat ieder object
doet.
4.5. Evaluatie Het programma dat geschreven wordt is bedoeld voor de modale muziekgebruiker.
Het werken met EyesWeb of Vvvv is gespecialiseerd in het maken van performances
voor individuen, het geeft hen wijde mogelijkheden. Eenmaal dat zij dit programma,
en de manier van programmeren onder de knie hebben kunnen ze het aanwenden.
Het is echter een visuele programmeertaal, dus enige kennis is toch vereist. Echter
voor totale controle is men toch hier en daar aangewezen op het programmeren van
externe objecten voor deze programmeertalen. Alhoewel dit in EyesWeb kan, is het
programma zelf te traag voor realtime video analyse. In Vvvv kunnen enkel
Freeframe plugins geschreven worden. Er kunnen dus geen andere externe objecten
geschreven worden. De twee programmeeromgevingen zijn dus beide insufficiënt
voor het project. Daarenboven kan voor de gebruiker van het programma het nogal
verwarrend zijn om met deze programma’s direct aan het werk te gaan. Daarom gaat
de keuze ook naar een project dat met behulp van de OpenCV bibliotheek
geprogrammeerd wordt. Het laat totale controle toe voor het implementeren van een
goede videoanalyse, en aan de hand van een gebruikersinterface raakt iedereen er
snel mee vertrouwd.
13
5. Opbouw Systeem Om keuzes te kunnen maken in het gebruik van de programmeertaal en eventueel
externe bibliotheken beschrijf ik een stap voor stap proces. Dus van de webcam tot
het uiteindelijk muzikale resultaat.
5.1. De Webcam De webcam is een ingeburgerde apparaat bij de modale computergebruiker. Het
bestaat meestal uit een CMOS lens ingebouwd in een behuizing, die toelaat de
camera ergens op aan te hechten. De eerste webcam stamt uit 1991, en zond
beelden uit van een koffiepot aan de Universiteit van Cambridge. Een USB connectie
laat toe om met het apparaat met de computer te verbinden. Andere modellen van
hogere prijsklasse bieden een snellere FireWire verbinding aan of een draadloze
verbinding. De standaard webcam heeft typisch een snelheid van 15 beelden per
seconde, en een resolutie van 320x240. Duurdere exemplaren bieden meer beelden
per seconde en hogere resoluties.
De registratie van beelden van een webcam wordt op verschillende platformen
anders behandelt. De drivers die geleverd worden bij de webcam zijn bijna altijd voor
Windows, soms voor Macintosh en geen voor Linux. Enkele van de grote verdelers
van commerciële webcams zijn Logitech, Creative, Microsoft en LabTec. Creative,
LabTec en Microsoft hebben geen webcams die compatibel zijn met Macintosh
platform. De MacBook en IMac hebben echter standaard een ISight camera
ingebouwd op het scherm. Deze was ook apart verkrijgbaar voor andere Apple
computers tot 2006. Logitech heeft één product momenteel beschikbaar voor Apple:
De Quickam Vision Pro. In vele gevallen werkt de webcam echter zonder
aangepaste drivers, en desnoods zijn er sites die oplossingen aanbieden voor het
ontbreken van drivers. Het project Macam distribueert gratis een driver voor
webcams voor het Macintosh platform. Ze ondersteunen een breed gamma van
verschillende fabrikanten. Webcams uitsluitend voor Linux zijn niet te vinden. Maar
ook hier hebben mensen drivers ontwikkeld voor verschillende webcams. Het
vertalen van de data naar het scherm gebeurt op alle platformen ook anders.
Windows gebruikt de DirectShow bibliotheek om beelden te tonen op het scherm,
Linux gebruikt Video 4 linux en Macintosh gebruikt Quicktime Capture, een
14
onderdeel van Quicktime. Een programma maken dat op alle platformen zou kunnen
werken is dus al een moeilijke start. Er moeten minimum drie verschillende interfaces
geprogrammeerd worden om de webcams te doen werken op alle drie de platformen.
Mijn keuze ligt dan ook bij de keuze van een webcam onder microsoft Windows.
5.2. Verwerking van de gegevens Om bruikbare data te halen uit de beelden van een webcam is beeldverwerking
nodig. Een standaard in de verwerking van beelden is OpenCV. Deze bibliotheek van
Intel werd ontwikkeld om commerciële gebruiken van computer visie bij mens-
machine interactie, robotica of biometrie bij te staan, door een gratis en open
infrastructuur te bezorgen aan de gemeenschap. De bibliotheek bestaat uit
algoritmes gecodeerd in C++ die allerlei beeldverwerkingstechnieken toepassen. De
algoritmes zijn gecodeerd met de instructieset van Intel processoren in het
achterhoofd. De bibliotheek is gratis te downloaden via Sourceforge. De bibliotheek
heeft een DirectShow filter die de beelden omzet van een externe camera naar het
formaat dat OpenCV hanteert.
5.3. Output van de gegevens Een protocol was nodig om de verwerkte data om te zetten naar andere
programma’s. MIDI heeft veel beperkingen, die te wijten zijn aan de seriële
verbinding die het gebruikt. Hierdoor kunnen er slechts 10 bits verzonden worden
met 8 bits waardevolle informatie aan een snelheid van 31,250 bits per seconde. Ook
de lengte is beperkt tot 15 meter afstand.
Doorheen de jaren zijn er echter wel wat verbeteringen en aanpassingen gekomen
aan het MIDI protocol. De 7bits toonhoogte, die voor de beperking zorgt van 128
verschillende waarden kan verhoogt worden door twee MIDI protocollen te laten
lopen zodat men 128² verschillende waarden krijgt. De snelheid van het MIDI
protocol werd verhoogt door USB te gebruiken. Verschillende MIDI-interfaces zijn
verkrijgbaar op de markt die de seriële verbinding omzetten naar een USB-
verbinding. Een andere mogelijkheid is het transporteren via netwerk. RTP-MIDI
(Real Time Protocol Midi) is zo een protocol beschreven in RFC4695. Het verpakt
MIDI in het RTP-protocol en wordt verstuurd door ethernet verbindingen via UDP.
Het grote voordeel van MIDI is zijn ondersteuning sinds het ontstaan van het
protocol. Bijna elk elektronisch muzikaal instrument voorziet MIDI ondersteuning.
15
Een nieuwer protocol is OSC, OpenSound Control ontwikkelt door Matt Wright aan
het CMNAT (The Center for New Music and Audio Technologies) in de Universiteit
van California, Berkeley (Wright et al 2003). Het werkt via ethernet, met TCP of UDP
en geeft enkele grote voordelen ten opzichte van MIDI. Het laat enorme flexibiliteit
toe aan de gebruiker om zijn data door te zenden. Enkele voordelen van OSC:
• Verschillende data kan doorgezonden worden. Van 32 bit gehele getallen tot
64 bit zwevende komma getallen.
• Een grote troef is ook de adressering. Men stuurt data door naar een adres
bijvoorbeeld: ‘/parameter6’. Door toevoeging van jokers en wildcards kunnen
meerdere adressen aangesproken worden. ‘/parameter?’ Komt dan aan bij het
adres ‘/parameter5 /parameter6’ enzovoort.
• Bijkomend voordeel is het zenden van een tijdswaarde bij ieder pakket. Op die
manier weet de ontvanger wanneer een pakket verzonden is. Voor realtime
toepassingen kan dit handig, zoniet onmisbaar zijn.
• Daarnaast bestaat er ook bundeling van data. Zodoende dat data die bij
mekaar hoort ook op hetzelfde moment toekomt. Bundels kunnen ook bundels
bevatten.
Het protocol wint veld bij professionele en vooral interactieve muzieksoftware. De
grote applicaties ondersteunen het echter nog niet. Er zal dus naast ondersteuning
van OpenSound Control, ook nog ondersteuning van MIDI moeten zijn. Dit laat toe
om samen te werken met alle muzieksoftware en alle externe muziekhardware die
voorhanden is op de markt.
5.4. Muziekgeneratie Uiteindelijk wordt deze output verzonden naar een muziekprogramma naar keuze, of
een extern apparaat dat MIDI of OSC ondersteunt. Dit kan een sequencer zijn, zoals
Ableton Live, waardoor je samples kunt aansturen. Een externe synthesizer kan via
MIDI aangestuurd worden. Of men kan een heel orkest van gebruikers laten
interageren op hun eigen systeem en dan via een netwerk de bewegingsdata
doorsturen naar een centrale computer, die de muziek genereert. De mogelijkheden
zijn dan ook eindeloos. Persoonlijk houd ik nog van het programma Pure Data en het
programma Max/MSP, het commercieel broertje van Pure Data. De geschiedenis van
Max/MSP en Pure Data begint in 1957 bij Max Matthews, naar wie het programma
16
genoemd is. Manning beschrijft de geschiedenis van programmeertalen voor muziek
(Manning 2004). Matthews ontwikkelde MUSIC I in 1957 aan Bell Labs. Het was het
eerste computerprogramma voor het genereren van digitaal geluid door synthese.
MUSIC I kon enkel sinustonen produceren. Een verdere versie, MUSIC IV was een
uitbreiding, en het eerste volwaardige muziekprogramma voor synthese in assembler
code. Het programma kon drie soorten sinustonen creëren: zaagtandgolven,
vierhoeksgolven en driehoeksgolven, en het kon vibrato, reverb, band pass filters, en
envelope aan. Dit is de basis van wat een synthesizer tegenwoordig kan. Een hele
reeks adaptaties van MUSIC werden gemaakt voor andere programmeertalen zoals
Fortran en Algol. Het programma kreeg vaste vorm wanneer Barry Vercoe CSound
ontwikkelde aan het MIT. De implementatie in C maakte het bruikbaar tot op
vandaag. MUSIC en CSound waren echter niet realtime. De computerkracht was in
die tijd ook nog te beperkt. Het was pas sinds de jaren ’80 dat systemen krachtig
genoeg werden om geluidssynthese realtime te laten verlopen. Miller S. Puckette
ontwikkeld in 1986 Max aan het IRCAM (Institue de Recherche et Coordination
Acoustique/Musique) in Parijs (Winkler 1997). Max verwerkte MIDI-gegevens die hij
uitstuurde naar externe apparaten. Hij voegde er wat later FTS (Faster Than Sound)
aan toe, die de synthesizer ISPW (IRCAM Signal Processing Workstation)
rechtstreeks aanstuurde. De toevoeging van MSP kan aanzien worden als de eerste
realtime toepassing voor muziek synthese, met de grondslagen van MUSIC en
CSound erin verwerkt. Het laat muzieksynthese toe op via de CPU. Het is
ondertussen een standaard geworden voor interactieve muziektoepassingen. Het is
net zoals EyesWeb en Vvvv een visuele dataflow programmeertaal. Net als MUSIC is
de grote troef van het programma het genereren van geluid op wiskundige basis.
Men kan vertrekken vanuit sinustonen voor de generatie van het geluid, en aan de
hand van verschillende oscillatoren kan men een synthesizer opbouwen. Het werkt
ook met vele protocollen, zodat er heel wat externe apparaten mee kunnen
interageren. Het verschil tussen Pure Data en Max/MSP is qua programma
verwaarloosbaar. Max/MSP is iets gebruiksvriendelijker, maar er moet voor betaald
worden. Pure Data is kosteloos, open bron, en werkt op ieder platform, maar is ietwat
minder gebruiksvriendelijk en heeft een moeizame grafische interface. Ze hebben
dezelfde basisobjecten aangezien ze ontwikkeld zijn door dezelfde persoon. Een
groot voordeel aan Max/MSP en Pure Data is dat er externe objecten vervaardigd
kunnen worden voor het programma in C. Dus als er ergens iets niet lukt met de
17
objecten voorhanden kan je nog altijd extern programmeren. Naast de grote focus op
muziek, zijn later pakketten bijgekomen voor grafische objecten te maken. Pure Data
heeft hiervoor GEM (Graphics Environment for Multimedia), dat met OpenGL werkt
en Max/MSP heeft Jitter, wat werkt met DirectX, OpenGL en Quicktime. Door de
ongekende groei in de interactieve wereld van dit programma heeft het collectief
GOTO10, een Linux distributie ontwikkeld op basis van de dyne:bolic Linux Live CD
distributie. Het project pure:dyne, heeft speciale optimalisaties op niveau van de
kernel voor realtime audio en video. Hierdoor is het zeer geschikt voor interactieve
performance. Het kan gestart worden vanaf Cd-rom, en bevat onder andere Pure
Data, CSound en SuperCollider. Dit zijn allemaal gespecialiseerde muziek synthese
programma’s. Uiteraard kan via netwerk ook met dit besturingssysteem
gecommuniceerd worden vanuit de applicatie die ik zal ontwikkelen.
Aan de hand van Max/MSP of Pure Data kan er interactief gewerkt worden. De
gegevens die het van de controller krijgt kunnen geïnterpreteerd worden zoals de
gebruiker wilt. Alhoewel ontwikkeling in Max/MSP betalend is, voorziet het een
Max/MSP Runtime applicatie, die gratis verspreid mag worden. Ontwikkelde
programma’s kunnen dus gebruikt worden door deze versie.
18
6. Behoeftenanalyse en architectuur 6.1. Behoeftenanalyse
6.1.1. Operationele Scenario’s
A. Scenario 1: Camera Instellingen aanpassen 1. De gebruiker kiest in het menu Options, Select Camera
Een venster verschijnt met de volgende controls • Combobox met keuze camera • Checkbox met keuze Background Difference
ernaast een checkbox met keuze Fullscreen • Checkbox met keuze Drawing Module ernaast een
checkbox met keuze Fullscreen • Checkbox met keuze Render Original ernaast een
checkbox met keuze Fullscreen • Checkbox met keuze Bounding Rectangle • Checkbox met keuze Mirror • Checkbox met keuze Flip • Editbox met width • Editbox met Framerate • DShow Properties drukknop • OK drukknop • Cancel drukknop
2. De gebruiker klikt op een item in de combobox camera De camera wordt geselecteerd
3. De gebruiker klikt op één van de checkboxes Drawing Module of Render Original
De checkbox verandert van status, de corresponderende checkbox Fullscreen wordt uit het grijs gehaald als de checkbox aan staat, en wordt in het grijs gezet als de checkbox uit staat.
4. De gebruiker klikt op checkbox Background Difference De checkbox verandert van status, de corresponderende checkboxes Fullscreen en Bounding Rectangle worden uit het grijs gehaald als de checkbox aan staat, en wordt in het grijs gezet als de checkbox uit staat.
5. De gebruiker klikt op een andere checkbox De checkbox verandert van status.
6. De gebruiker klikt op een editbox De gebruiker kan iets invoeren
7. De gebruiker klikt op de knop Dshow Properties Een venster verschijnt met de eigenschappen van de geselecteerde camera
19
8. De gebruiker klikt op de knop OK Het venster sluit
9. De gebruiker klikt op de knop Cancel Het venster sluit
B. Scenario 2: Externe connecties instellen 1. De gebruiker kiest in het menu Options, External Connections
Een venster verschijnt met de volgende controls • Checkbox met keuze Connect to OSC • Radioknopgroep met keuze IP-Address en URL • Editbox voor Port • Editbox voor IP address • Editbox voor URL address • Checkbox met keuze MIDI Out • Combobox met keuze Select MIDI Device • OK drukknop • Cancel drukknop
2. De gebruiker klikt op de checkbox Connect to Osc of MIDI Out checkbox verandert van status
3. De gebruiker klikt op de radioknop IP- Address of URL De radioknop wordt aangevinkt, de andere wordt uitgevinkt
4. De gebruiker vult port,URL, IP-Address in 5. De gebruiker maakt een keuze in de combobox Select MIDI Device 6. De gebruiker klikt op drukknop OK
Het venster sluit 7. De gebruiker klikt op drukknop Cancel
het venster sluit
C. Scenario 3: Rechthoeken tekenen 1. De gebruiker kiest in het menu Options, Draw Module
Een dialoogvenster verschijnt met de volgende controls • Pick Color drukknop • Save drukknop • Open drukknop • Undo drukknop • Clear Drawing drukknop • Combobox met optie Type • Combobox met optie Channel • Checkbox met optie Midi Control • Editbox met optie Value • Editbox met optie Range • Editbox met optie Offset • OK drukknop • Cancel drukknop • Een vierkantje met een gekozen kleur
20
• Een tekenvenster verschijnt waarin met de muis rechthoeken kunnen getekend worden
2. De gebruiker klikt en sleept met de muis in het tekenvenster en laat dan los
Een niet gevulde rechthoek wordt getekend, in het tekenvenster, in dezelfde kleur als het vierkantje
3. De gebruiker klikt op Pick Color Een dialoogvenster verschijnt waarin men een kleur kan kiezen
4. De gebruiker klikt op Undo De laatst getekende rechthoek verdwijnt
5. De gebruiker klikt op Clear Drawing Alle getekende rechthoeken verdwijnen
6. De gebruiker klikt op Open Een dialoogvenster verschijnt waarin de gebruiker een bestand kan openen
7. De gebruiker klikt op Save Een dialoogvenster verschijnt waarin de gebruiker een bestand kan opslaan
8. De gebruiker klikt op Type De gebruiker kan een keuze maken uit vijf verschillende types rechthoeken
9. De gebruiker klikt op Midi Control Channel, Value, Range en Offset worden in het grijs gezet
10. De gebruiker klikt op Channel De gebruiker kan een keuze maken uit nummers 1 tot 16
11. De gebruiker klikt op Value, Range, of Offset De gebruiker kan een getal invoeren
12. De gebruiker klikt op OK Het dialoogvenster en het tekenvenster sluiten
13. De gebruiker klikt op Cancel Het dialoogvenster en het tekenvenster sluiten
D. Scenario 4: Parameters instellen 1. De gebruiker kiest in het menu Options, Parameters
Een venster verschijnt met volgende controls • Checkbox met Weight of Non-Moving Pixels • Checkbox met Horizontal position • Checkbox met Horizontal size • Checkbox met Vertical position • Checkbox met Vertical size • Checkbox met Size of rectangle relative to whole
frame
21
• Checkbox met Drawed Rectangles • Naast iedere checkbox een editbox • Editbox met Root address • Drukknop OK • Drukknop Cancel
2. De gebruiker klikt op één van de checkboxes De checkbox wordt aan- of uitgevinkt de aanpalende editbox wordt respectievelijk uit het grijs gehaald of in het grijs gezet
3. De gebruiker klikt op één van de editboxes die uit het grijs zijn De gebruiker kan iets invoeren
4. De gebruiker klikt op OK Het venster sluit
5. De gebruiker klikt op Cancel Het venster sluit
E. Scenario 5: De analyse starten 1. De gebruiker kiest in het menu Run, Run
Een venster verschijnt met de volgende controls • Run drukknop • Stop drukknop • Exit drukknop • Tekst met keuzes van scenario 1 tot 4 komt te
voorschijn 2. De gebruiker klikt op de knop Run
Vensters verschijnen met beeld van het oorspronkelijke beeld en mogelijks het bewerkte beeld
3. De gebruiker klikt op de knop Stop De vensters met de camerabeelden verdwijnen
4. De gebruiker klikt op de knop Exit Het dialoogvenster met de controls verdwijnt alsook de vensters met de camerabeelden
22
6.1.2. UML case Diagram
Gebruiker Camera Selecteren
Analyse Starten
ParametersInstellen
Externe connectiesinstellen
1
1
1
1
1
1
Register
«uses»
«uses»
«uses»
OpenCV
DirectShow
«uses»«uses»
Open Sound Control
1
1
«uses»
Rechthoeken tekenen
1
1
«uses»
Harddisk
«uses»
«uses»
«uses»
«uses»
«uses»
23
6.1.3. Use-Case beschrijving
Use-Case 1
Use-case titel: Camera Instellingen aanpassen
Main Succes Scenario: 1. Programma nummert de gevonden camera’s en toont deze in een
Combobox, selecties worden uit het register gehaald en aangepast in het venster. De camera wordt geselecteerd die in het register opgeslagen was, indien geen waarde gevonden in het register zet de selectie zich op de eerst gevonden camera.
2. Gebruiker selecteert een camera 3. Gebruiker klikt op OK 4. Het nummer van de camera wordt opgeslagen in het register 5. De status van alle checkboxen worden opgeslagen in het register 6. De tekst van alle editboxen worden opgeslagen in het register 7. Het Venster sluit
Extensies 1. Er worden geen camera’s gevonden alles wordt in het grijs gezet
behalve de drukknop cancel 2. [Gebruiker selecteert één van de checkboxes Drawing Module of Render
Original] 1. Checkbox verandert van status 2. De corresponderende checkbox Fullscreen wordt uit het grijs gehaald als de status aangevinkt staat, en in het grijs gezet als de status uitgevinkt staat
[Gebruiker selecteert checkbox Background Difference] 1. checkbox verandert van status 2. De corresponderende checkbox Fullscreen wordt uit het grijs gehaald als de status aangevinkt staat, en in het grijs gezet als de status uitgevinkt staat 3. De checkbox Bounding Rectangle wordt uit het grijs gehaald als de status aangevinkt staat, en in het grijs gezet als de status uitgevinkt staat
[Gebruiker klikt op één van de editboxes] 1. Er verschijnt een blinkende cursor in de editbox 2. De gebruiker vult iets in, eventueel wordt de input op geldigheid getest
[Gebruiker drukt op OK] 1. Ga naar stap 4
[Gebruiker drukt op Cancel] 1. Ga naar stap 7
3. [Gebruiker selecteert DShow Properties]
1. Venster verschijnt met de eigenschappen van de camera 2. Gebruiker doet instellingen 3. Gebruiker klikt op OK
24
4. Instellingen worden opgeslagen in de filtereigenschappen van DirectShow
[Gebruiker drukt op Cancel] 1. Ga naar stap 7
Pre-condities 1. De analyse is niet aan het lopen
Post-condities 1. Het nummer van de geselecteerde camera is mogelijk opgeslagen in
het register, zoniet behoudt ze de vorige waarde 2. De status van alle checkboxes zijn mogelijk opgeslagen in het register,
zoniet behouden ze hun vorige waarde.
Triggers 1. Gebruiker selecteert Options, Select Camera
25
Use-Case 2
Use-case Titel: Externe Connecties Instellen
Main Succes Scenario 1. Selecties worden uit het register gehaald en aangepast aan het venster,
het venster wordt getoond 2. Gebruiker klikt op Connect to Osc [Gebruiker vinkt Connect to Osc aan]
1. De radioknopen IP-Address en URL en bijhorende tekst, en de editbox Port die in het grijs staan worden uit het grijs gehaald 2. Gebruiker vinkt één van de radioknoppen aan
3. [Gebruiker selecteert IP-Address radioknop] 4. 1. De URL radioknop en bijhorende Editbox worden grijs gemaakt 5. 2. De gebruiker vult IP adres in
6. [Gebruiker selecteert URL radioknop] 7. 1. De IP-Address radioknop en bijhorende Editbox worden grijs gemaakt 8. 2. Gebruiker vult URL adres in
9. Gebruiker vult poort nummer in 10. 1. De input wordt gecontroleerd op een geldig poort nummer
[Gebruiker vinkt Connect to Osc uit] 1. De radioknopen IP-Address en URL en bijhorende tekst, en de editbox Port worden in het grijs gezet
3. Gebruiker klikt op MIDI Out [Gebruiker vinkt MIDI Out aan]
1. De combobox Select MIDI Device en bijhorende tekst worden uit het grijs gehaald 2. De gebruiker selecteert een MIDI apparaat
[Gebruiker vinkt MIDI Out uit] 1. De combobox Select MIDI Device en bijhorende tekst worden in het grijs gezet.
3. Gebruiker klikt op OK 4. Het poort nummer wordt op geldigheid gecontroleerd, zoniet verschijnt
er een foutbericht 5. Het IP adres de URL, het poort nummer, de status van Connect to Osc ,
het nummer van het gekozen MIDI apparaat en de status van MIDI Out worden opgeslagen in het register
6. Venster sluit
Extensies 2. [Gebruiker drukt op Cancel]
1. Ga naar stap 6 [Gebruiker drukt op OK]
1. Ga naar stap 5 3.
26
[Gebruiker drukt op Cancel] 1. Ga naar stap 6
[Gebruiker drukt op OK] 1. Ga naar stap 5
Post-Condities 1. Het IP-adres, de URL, het poortnummer, en het nummer van het MIDI-
apparaat zijn mogelijks opgeslagen in het register 2. De status van Connect to Osc, van MIDI Out en van de radioknopgroep
IP-Address en URL zijn mogelijks opgeslagen in het register
Triggers 1. Gebruiker selecteert Options, External Connections
27
Use-case 3
Use-Case Titel: Rechthoeken tekenen
Main Succes Scenario 1. Selecties worden uit het register gehaald en aangepast aan het venster,
een ander venster verschijnt waarin men kan tekenen 2. Gebruiker kiest een type uit de combobox Type 3. Gebruiker tekent enkele rechthoeken 4. Stap 2 en 3 worden enkele keren herhaald 5. Gebruiker drukt op OK 6. De rechthoeken en hun types worden opgeslagen in een tijdelijk
bestand temp.drw in de temp directory van de gebruiker. 7. Het venster sluit
Extensies 2. [Gebruiker klikt op Pick Color]
1. Er verschijnt een dialoogvenster met kleuren voor te kiezen 2. De gebruiker kiest een kleur 3. Gebruiker drukt op OK in het dialoogvenster met kleuren 4. Het dialoogvenster sluit 5. Het kleur wordt getoond in een vierkantje op het dialoogvenster 6. De volgende rechthoeken zullen in dit kleur getekend worden 7. Ga naar stap 2 of stap 5
[Gebruiker klikt op Open] 1. Een dialoogvenster verschijnt waarin men bestanden kan openen van type drw 2. De gebruiker kiest een bestand 3. De gebruiker klikt op Openen 4. Het dialoogvenster verdwijnt 5. De rechthoeken opgeslagen in het bestand worden getekend in het venster 6. Ga verder met stap 2 of stap 5
[Gebruiker klikt op Midi Control] 1. Value, Range, Offset en Channel worden in het grijs gezet als de checkbox uitgevinkt wordt, of uit het grijs gehaald als de checkbox aangevinkt wordt 2. de volgende getekende rechthoeken krijgen midi code 0 als de checkbox uitgevinkt staat 3. Ga verder met stap 2 of stap 5
[Gebruiker klikt op Channel] 1. De gebruiker kiest uit één van de 16 getallen 2. De volgende rechthoeken krijgen een MIDI-boodschap mee, uit het getal gekozen in Channel, de waarde van Value, Range, en Offset 3. Ga verder met stap 2 of stap 5
[Gebruiker klikt op Value] 1. De gebruiker vult een waarde in
28
2. De volgende rechthoeken krijgen een MIDI-boodschap mee, uit het getal gekozen in Channel, de waarde van Value, Range, en Offset 3. Ga verder met stap 2, of stap 5
[Gebruiker klikt op Range] 1. De gebruiker vult een waarde in 2. De volgende rechthoeken krijgen een MIDI-boodschap mee, uit het getal gekozen in Channel, de waarde van Value, Range, en Offset 3. Ga verder met stap 2 of stap 5
[Gebruiker klikt op Offset] 1. De gebruiker vult een waarde in 2. De volgende rechthoeken krijgen een MIDI-boodschap mee, uit het getal gekozen in Channel, de waarde van Value, Range, en Offset 3. Ga verder met stap 2 of stap 5
9. [Gebruiker klikt op Undo]
1. De laatst getekende rechthoek wordt gewist 2. Ga verder met stap 2 of stap 5
[Gebruiker klikt op Clear Drawing] 1. Alle rechthoeken worden gewist 2. Ga verder met stap 2 of stap 5
[Gebruiker klikt op Save] 1. Een dialoogvenster verschijnt waar men bestanden kan opslaan van het type drw 2. De gebruiker vult een bestand in, of kiest een bestand 3. De gebruiker klikt op Opslaan 4. Het dialoogvenster verdwijnt 5. De rechthoeken worden opgeslagen in het bestand 6. Ga verder met stap 2 of stap 5
10. [Gebruiker klikt op Cancel]
1. Ga naar stap 7
Post-Condities 1. De rechthoeken en hun types zijn mogelijks opgeslagen in temp.drw in
de lokale temp directory van de gebruiker
Triggers 1. Gebruiker selecteert Options, Draw Module
29
Use-Case 4
Use-Case Titel: Parameters instellen
Main Succes Scenario 1. Selecties worden uit het register gehaald en aangepast aan het venster,
het venster wordt getoond. 2. [Gebruiker vinkt een parameter aan]
1. De bijhorende editbox wordt uit het grijs gehaald 2. De gebruiker kan een naam invullen 3. De naam wordt gecontroleerd op correctheid
[Gebruiker vinkt een parameter uit] 1. De bijhorende editbox wordt in het grijs gezet
3. De gebruiker herhaalt stap 2 een aantal keer 4. De gebruiker drukt op OK 5. De parameters worden getest op correctheid 6. De inhoud van de editboxes en de status van de checkboxes worden
opgeslagen in het register. 7. Het venster sluit
Extensies 2. [Gebruiker drukt op Cancel]
1. Ga naar stap 7 [Gebruiker drukt op OK]
1. Ga naar stap 5
Post-Condities 1. De namen van de parameters en het al of niet berekenen van de
parameters tijdens de analyse zijn mogelijks opgeslagen in het register
Triggers 1. De gebruiker kiest menu Options, Parameters
30
Use-Case 5
Use-Case Titel: De analyse starten
Main Succes Scenario 1. Selecties worden uit het register gehaald en getoond in het venster in
de vorm van tekst 2. Gebruiker drukt op Run 3. Cameranummer wordt opgehaald 4. De netwerkconnectie indien geselecteerd wordt opgezet 5. Eén tot drie vensters verschijnen met het oorspronkelijke beeld, het
verwerkte beeld, en de tekenmodule naargelang de renderopties, geheugen wordt vrijgemaakt voor de berekeningen
6. De knop Stop wordt uit het grijs gehaald 7. De knop Run wordt in het grijs gezet 8. Gebruiker drukt op Stop 9. Vensters verdwijnen, de netwerkconnectie wordt stopgezet, geheugen
wordt vrij gemaakt 10. De knop Stop wordt in het grijs gezet 11. De knop Run wordt uit het grijs gehaald 12. Terug naar stap 2
Extensies 2. [Gebruiker drukt op Exit]
1. Alle vensters sluiten 4. [Er werd geen cameranummer gevonden in het register]
1. Een foutbericht verschijnt 2. Use-case 1 wordt opgestart 3. Terug naar 2
5. [De connectie met het netwerk faalt] 1. Een foutbericht verschijnt 2. Ga verder met stap 6
Pre-Condities 1. Indien er geen camera geselecteerd is of in het systeem aanwezig is
kan de analyse niet van start gaan 2. Indien er een ongeldig URL adres of IP adres ingegeven werd, of er
geen netwerkconnectie aanwezig is kunnen er geen parameters verzonden worden door het netwerk
Post-Condities 1. Alle berekeningen zijn stopgezet 2. Het geheugen is vrij gemaakt 3. De netwerkconnectie is stopgezet
Triggers 1. De gebruiker kiest menu Run,Run
31
6.2. Architectuur: statische analyse
6.2.1. Projectbeschrijving Bedoeling is een applicatie te vervaardigen die in staat is bewegingen van een gebruiker te analyseren en zinvolle informatie voor de generatie van muziek door te zenden naar een andere applicatie via OSC, of via MIDI. De gebruiker kan hiervoor enkele instellingen doen, deze worden opgeslagen in het register. Hij kan een videocamera kiezen uit een lijst van beschikbare camera’s. Hij kan instellingen doen rondom externe connecties. Er wordt het volgende bijgehouden:
- een IP-adres of URL - een poortnummer - een MIDI apparaat
De gebruiker kan ook rechthoeken tekenen op een scherm met de muis. Deze rechthoeken representeren een instrument. Hij kan rechthoeken wissen, en de lijn van kleur veranderen. Hij kan de rechthoeken opslaan in een bestand, of openen uit een bestand. De rechthoek kan als trigger, of schuifbalk geïdentificeerd worden. Indien de getekende rechthoek als schuifbalk geïdentificeerd is, kan ze een MIDI-boodschap meekrijgen. De eigenschappen van de rechthoeken wordt tijdelijk opgeslagen in een bestand op de harde schijf. Er wordt ook een omsluitende rechthoek rondom het totaal bewegende deel getekend. Hij kan kiezen welke parameters van die rechthoek worden doorgezonden. De parameters zijn:
- de grootte (zowel horizontaal als verticaal) van een rechthoek die de beweging omsluit
- de positie (zowel horizontaal als verticaal) van de rechthoek die de beweging omsluit
- de hoeveelheid beweging in de rechthoek die de beweging omsluit - De status en waarde van de getekende rechthoek
Bij het starten van de analyse wordt de camera geïnitialiseerd eerst overbodige informatie weggehaald. Een aantal opeenvolgende frames worden vergeleken met elkaar om niet bewegende delen er uit te halen, met andere woorden de achtergrond weg te halen. Er wordt eventueel een rechthoek getekend rondom het bewegende deel om een indruk te krijgen van de grootte en positie van het bewegende deel ten opzichte van het gehele beeld. De parameters van de rechthoek rondom het bewegende deel worden verzonden. De rechthoeken die getekend werden door de gebruiker worden getoond op het scherm, en doen dienst naargelang hun initialisatie als trigger of schuifbalk. De parameters worden verzonden doorheen een netwerk met het protocol OpenSound Control naar een andere toepassing die in staat is deze parameters te ontvangen, of ze worden verzonden met het protocol MIDI naar een MIDI apparaat.
32
6.2.2. Klassenlijst Klassenaam Attributen/Operaties Opmerkingen CameraSettings cameraName
renderBackgroundDifference renderBoundingRect renderOriginal renderDrawing mirror flip fullscreen width framerate getCameras() getPropertiesCamera()
Verzorgt instellingen rond de camera
Run settingsCamera settingsParameters settingsExternalConnect Camera camera
Toont instellingen van de camera, externe instellingen en van OSC, laat de analyse starten
External Connections
oscConnected ipAddressSelected urlSelected ipAddress urlAddress portNumber midiOut midiDevice
Verzorgt instellingen omtrent het netwerk gedeelte
Camera BoundingRect boundingRect Sender sender Background background Initialize() Analyse()
De camera zelf, en analyse onderdelen
Parameters calculateRectangleSize calculateRectangleHorizontalSize calculateRectangleVerticalSize calculateNonzeroPixels calculateHorizontalPosition calculateVerticalPostion
Sender StoreInt() StoreFloat() SendMIdi() Socket oscClient
Slaat variabelen op in een OSC buffer en verzendt ze naar socket
Register getDataInt(string location) getDataString(string location) writeDataInt(string location, int state) writeDataString(string location, string text)
Schrijft instellingen in het Windows register
Background Difference() Update()
Berekent Verschil tussen een aantal opeenvolgende frames
Socket SendBytes() ConnectToClient()
Socket zendt bytes naar een Client
BoundingRect nonzeropixels rectanglesize; rectangleverticalposition; rectanglehorizontalposition; rectanglehorizontalsize; rectangleverticalsize; CalculateBoundingRect()
Berekent een rechthoek omheen het bewegende deel, en berekent gegevens van die rechthoek
OscParameterFloat parameter OpenSound Control
33
address parameter voor zwevende komma getallen
OscParameterInt parameter address
Een OpenSound Control parameter voor gehele getallen
DrawModule SaveFile() OpenFile() midiChannel midiValue midiRange midiOffset DrawWindow drawwindow
Toont teken module, met aantal instellingen
DrawWindow Showwindow() Destroywindow() On_mouse() Undo() ClearAll() SetColor() SetType() SetMidi() GetRectangles() SetRectangles()
Het venster waarin getekend kan worden
RectangleInstrument lefttop width height color type midi
Een getekende rechthoek, die dienst kan doen als instrument
34
6.2.3. UML klassendiagram
+SetObjectInt()+SetObjectText()+GetObjectInt()+GetObjectText()+GetLocation()+SetLocation()
-location : CString-state : int-text : CString
GUIobject
CameraSettings
Network
Parameters
Draw Module
Start
+GetDataInt()+WriteDataInt()+GetDataString()+WriteDataString()
Register
+Analyse()+Initialize()
Camera
+CalculateBoundingRect()
BoundingRect
+Update()+DifferenceMask()
Background
+StoreFloat()+StoreInt()
Sender
+ConnectToClient()+SendBytes()
Socket
1
*
1
*
1
*
1
*
1
*
1 1
1
1
1 1
1
1
11
35
6.3. Architectuur: dynamische analyse
6.3.1. Interactiediagrammen
Scenario 1: Camera Instellingen Aanpassen
Gebruiker
CameraSettings Register
menu keuze camera instellen
cameras en vorige instellingen worden getoond
klikt op properties
Voor iedere camera een entry in de combobox
GuiObject
<<create>>
GetLocation:=GetLocation()
return location
getDataInt:=getDataInt(location)
return state
SetObjectInt(state)
getCameras
getPropertiesCamera
SetObjectText(text)
SetObjectInt(state)
gebruiker doet instellingen en drukt op OK
venster wordt getoond met directShow instellingenDit is een externe toepassingmet minimale controle
doet instellingen
SetObjectInt(state)
gebruiker klikt op OK
GetLocation:=GetLocation()
return location
GetObjectInt:=GetObjectInt()
return state
WriteDataInt(state, location)
<<destroy>>
Voor iedere knop aanwezig:hier dus:GUIObject renderBackgroundDifferenceGUIObject renderBoundingRectGUIObject mirrorGUIObject flip3 x GUIObject fullscreenGUIObject widthGUIObject framrate
Voor iedere knop aanwezig:hier dus:GUIObject renderBackgroundDifferenceGUIObject renderBoundingRectGUIObject mirrorGUIObject flip3 x GUIObject fullscreenGUIObject widthGUIObject framrateGUIObject cameraCombobox
36
Scenario 2: Externe connecties Instellen
Voor iedere EditBox aanwezig, hier dus:ipAddressurlAddressportNumber
Gebruiker
External Connections Register
alle keuzes worden getoond
GUIobject
<<create>>
GetLocation:=GetLocation()
return location
getDataInt:=getDataInt(location)
return state
SetObjectInt(state)
Voor ieder GUIObject
getDataString:=getDataString(location)
return text
SetObjectText(text)
instellingen worden gedaan
SetObjectInt(state)
SetObjectText(text)
Gebruiker klikt op OK
GetLocation:=GetLocation()
return location
GetObjectInt:=GetObjectInt()
return state
WriteDataInt(state, location)
GetObjectText:=GetObjectText()
return text
WriteDataString(text, location)
<<destroy>>
Voor iedere EditBox aanwezig, hier dus:ipAddressurlAddressportNumber
menu externe connecties instellen
Voor iedere knop aanwezig, hier dus:isConnectedipAddressSelectedurlSelectedmidiOutmidiDevice
Voor iedere knop aanwezig, hier dus:isConnectedipAddressSelectedurlSelectedmidiOutmidiDevice
37
Scenario 3: Rechthoeken tekenen
38
DrawModule
menu draw module
GUIobject
GetLocation()
<<create>>
return location
Register
getDataInt(location)
return state
SetObjectInt(state)
getDataString(location)
return text
SetObjectText(Text)
DrawWindow
<<create>>
ShowWindow()
SetType(state)
SetColor(state)
SetMidi(state)
RectangleInstrument
<<create>>
list
<<create>>
SetObjectInt(state)
type veranderen
SetType(state)
SetObject(Text)
SetMidi(midi)
ColorDialog
Midi veranderen
<<create>>
Gebruiker kiest kleur en drukt ok
return color
SetObjectInt(color)
<<destroy>>
SetColor(color)
Gebruiker kiest kleur
Voor ieder GUIObject
Herhalen voor GuiObjectenEditbox ValueEditbox RangeEditbox Offset(
Elk GuiObject verandert de MIDI statusGuiObjecten zijnEditbox ValueEditbox RangeEditbox OffsetCombobox Channel (hier SetObjectInt(state) in plaats van SetObjectText(text)
FileDialog
Voor GUIObjectCombobox TypeCombobox ChannelCheckbox MidiControl
Draw Module GUIobject Register DrawWindow RectangleInstrument list ColorDialog
Gebruiker drukt Open
FileDialog
<<create>>
Gebruiker kiest file en drukt op OK
return file
OpenFile(file)
SetRectangleList(list)
Clear()
* add(RectangleInstrument)
<<destroy>>
Gebruiker drukt op Save
<<create>>
Gebruiker kiest file en drukt op OK
return file
SaveFile(file)
GetRectangleList(list)
return list
<<destroy>>
39
40
Gebruiker tekent rechthoek
add(RectangleInstrument)
ColorDialoglistDraw Module GUIobject Register DrawWindow RectangleInstrument FileDialog
Gebruiker drukt Undo
Undo()
Remove(RectangleInstrument)
Clear()
Gebruiker drukt op Clear
Clear()
RectangleInstrument(x,y,width,height,color,type,midi)
Gebruiker drukt OK
GetLocation()
return location
GetObjectInt()
return state
WriteDataInt(state, location)
GetObjectText()
return text
WriteDataString(text,location)
DestroyWindow()
SaveFile(temp)
<<destroy>>
GetRectangleList()
return list
Scenario 4: De analyse starten
41
Actor1
RunDialog GUIObject
menu run run
<<create>>
Register
getDataString(location)
return text
getDataInt(location)
return state)
SetObjectText(text)
Camera
<<create>>
Background Sender BoundingRect
<<create>>
<<create>>
<<create>>
Socket
<<create>>
42
RunDialog Camera Background Sender BoundingRect Socket
Gebruiker drukt op Run
Initialize()
GetSettings()
GetRectangleList()
InitializeSender(host,port)
Update(image* image)
ProcessRectangleList(image *image)
DrawRectangleList(image* image,list)
StoreFloat(list OscParameterFloat)
StoreInt(list OscParameterInt)
SendMidi(list OscParameterFloat,list OscParameterInt, list)
Difference(image* image)
CalculateBoundingRect(image *image)
StoreFloat(list OscParameterFloat)
* Analyse(image *image)
return *image
SendBytes(oscBuffer,length)
SendBytes(oscBuffer,length)
SendBytes(oscBuffer,length)
RunDialog Camera BackgroundGUIObject Register
Sender
Release()
Release()
Release()
<<destroy>>
Gebruiker klikt op Stop
Gebruiker klikt op Exit
43
7. Systeem- en gedetailleerd ontwerp 7.1. Systeemontwerp
7.1.1. Subsystemen Naam Relevante klassen Verantwoordelijkheden Instellingen Register - De instellingen die door de
gebruiker bepaald worden door de grafische omgeving worden opgeslagen in het register
GUI Dialog Frame MainWindow DrawModuleDialog DrawWindow CameraSettingsDialog ExternalConnectDialogParametersDialog RunDialog
- Voorziet in een grafische omgeving
Analyse Camera Background BoundingRect
- Geeft enkele algoritmen om beelden te analyseren
ExterneConnecties Sender Socket
- Zendt parameters naar een externe toepassing of apparaat via het OpenSound Control protocol en MIDI
Rechthoeken tekenen
DrawWindow - Laat toe rechthoeken te tekenen
Opmerkingen: De Grafische omgeving zal uiteraard bestaan uit meerdere vensters en knoppen.
Maar de specifieke naam van die objecten zal afhangen van het bestaande
raamwerk dat zal gebruikt worden. De volgende objecten zullen zeker aanwezig zijn:
- Een hoofdvenster
- Een menubalk
Dialoogvensters voor CameraSettings, ExternalConnect, Parameters, Analysis, en
DrawModule
Aangezien de klassen camera, externe connecties, parameters en teken module
enkel grafische objecten vertegenwoordigen worden ze hernoemd tot
CameraSettingsDialog, ExternalConnectDialog, en ParametersDialog, RunDialog, en
44
DrawModuleDialog. DrawWindow hoort hier niet bij omdat het een venster is dat
gebruik maakt van de OpenCV bibliotheek.
Externe bibliotheken of code is nodig voor sommige onderdelen:
- Bij de analyse zal OpenCV gebruikt worden
- Bij de instellingen van de camera zal DirectShow gebruikt worden
- DrawWindow gebruikt OpenCV voor rechthoeken te tekenen
- Bij het Netwerk zal de OpenSound Control broncode gebruikt worden
45
7.1.2. Packagediagram
Analyse
GUIInstellingenExterneConnecties
Rechthoeken tekenen
46 46
7.1.3. Contracten tussen subsystemen
Name Type Collaborators Classes Operations MessageFormat RegisterSocket
GetHost
String GetHost()
RegisterSocket
GetPort String GetPort()
RegisterSender
GetRootAddress String GetRootAddress()
NetwerkContract CS ExterneConnectiesInstellingen
RegisterSender
GetMidiDevice BOOL GetMidiDevice()
Name Type Collaborators Classes Operations MessageFormat
Register BoundingRect
GetParamName String GetParamName(int)
Register BoundingRect
GetParamCalculate BOOL GetParamCalculate(int)
Register Camera
GetMidiOut BOOL GetMidiOut()
Register Camera
GetOscConnect BOOL GetOscConnect()
Register Camera
GetFlip BOOL GetFlip()
Register Camera
GetMirror BOOL GetMirror()
Register Camera
GetWidth String GetWidth()
Register Camera
GetFramerate String GetFramerate()
Register Camera
GetCameraSelect Int GetCameraSelect()
Register Camera
GetRenderOriginal BOOL GetRenderOriginal()
AnalyseContract CS Analyse Instellingen
Register Camera
GetFullscreen BOOL GetFullscreen()
Name Type Collaborators Classes Operations MessageFormat
Register Dialog
GetData void GetData() GUIContract PP GUI Instellingen
Register Dialog
SetData void SetData()
Name Type Collobarators Classes Operations MessageFormat TekenContract CS Analyse
Rechthoeken tekenen
Camera DrawWindow
GetRectangleList void GetRectangleList()
47
Name Type Collaborators Classes Operations MessageFormat Camera Sender
StoreFloat
StoreFloat (list<OscParameterFloat>)
Camera Sender
StoreInt StoreInt (list<OscParamaterInt>)
ZenderContract CS Analyse ExterneConnecties
Camera Sender
SendMidi SendMidi (list<OscParameterFloat> ,list<OscParameterInt> ,list<RectangleInstrument>
48
7.2. Gedetailleerd ontwerp
7.2.1. Subsysteem: <Netwerk>
UML klassendiagram
1
1
Subsysteem:Netwerk
+StoreFloat(in OscParameterFloat : list<OscParameterFloat>)+StoreInt(in OscParameterInt : list<OscParameterInt>)+SendMidi(in oscParameterInt : list<OscParameterInt>, in oscParameterFloat : list<OscParameterFloat>, in rectangleInstrument : list<RectangleInstrument>)
-oscClient : Socket
Sender
-ConnectToClient(in host : string, in port : int)+SendBytes(in buffer : const char *OSCBuf, in length : int)
Socket
Algoritmen en datastructuren:
Datastructuren
OSCbuf is een buffer voor het verzenden van data gecodeerd in het
OpenSound Control protocol
Algoritmen
StoreFloat verpakt een lijst van zwevend komma getallen, en hun
adressen in de OpenSound Control gegevensstructuur en verzendt
deze naar een socket.
StoreInt verpakt een lijst van gehele getallen, en hun adressen in de
OpenSound Control gegevensstructuur en verzendt deze naar een
socket.
SendMidi zal MIDI verzenden naar een extern apparaat
ConnectToClient initieert een verbinding tussen de applicatie en
opgegeven host en poort.
SendBytes verzendt de data als karakters naar de cliënt.
49
7.2.2. Subsysteem: <Analyse>
UML klassendiagram
Algoritmen en datastructuren
Datastructuren
boundingRect zorgt voor een berekening van alle relevante
parameters van een omsluitende rechthoek, die kunnen
doorgezonden worden.
sender verzorgt interactie met het netwerk.
originalDrawing is de lijst met getekende rechthoeken door de
gebruiker
processedDrawing is de lijst met rechthoeken die na analyse van het
beeld moet getekend worden
50
valueDrawing is een lijst met parameters van de getekende
rechthoeken, na analyse. hun x of y waarde, naargelang hun
oriëntatie en type
statusDrawing is een lijst met parameters van de getekende
rechthoeken na analyse, de parameter is 1 of 0. Respectievelijk
beweging in de rechthoek of geen beweging in de rechthoek
Algoritmen
CalculateBoundingRect berekent alle parameters uit één frame
Analyse is de functie die iedere frame analyseert rekening houdend
met de instellingen die gemaakt zijn.
Update past een buffer met achtergrondbeelden aan.
Difference haalt de achtergrond weg.
GetRectangleList is een functie die de getekende rechthoeken uit
een tijdelijk bestand halen en opslaan in originalDrawing
DrawRectangleList tekent rechthoeken op het scherm
ProcessRectangleList analyseert als er beweging is in de
rechthoeken, en waar
51
7.2.3. Subsysteem:<Instellingen>
UML klassendiagram
Subsysteem:Instellingen
+getDataInt(in location : string) : int+WriteDataInt(in state : int, in location : string)+getDataString(in location : string) : string+WriteDataString(in text : string, in location : string)+getParamName(in number : int) : BOOL+getBgRender() : BOOL+getBoundingRender() : BOOL+getOSCConnect() : BOOL+getIPorURLSelected() : BOOL+getCameraName() : string+getCameraSelect() : int
Register
Algoritmen en datastructuren
Datastructuren
Het register levert enkel services, het bevat geen datastructuren.
Opmerking hierbij is wel dat BOOL een type is dat een boolean
verpakt als een integer waarbij TRUE identiek is aan de integer 1 en
FALSE identiek is aan 0.
Algoritmen
De methodes zijn implementaties van GetDataInt en WriteDataInt op
specifieke locaties die vast staan. Elke grafisch object dat
manipuleerbaar is krijgt zo een specifieke hiërarchische locatie of
pad. GetCameraName zal bijvoorbeeld dezelfde methode als
GetDataString oproepen met de locatie ingevuld. In die zin kunnen
we de locatie beschermen. Ze worden hier niet allemaal getoond,
omdat de lijst veel te lang zou zijn
52
7.2.4. Subsysteem: <GUI>
UML klassendiagram
Subsysteem:GUI
ParametersDialog NetworkDialog
Dialog
MainWindow
Frame
+GetCameras()+GetPropertiesCamera()
CameraSettingsDialog
RunDialog DrawDialog
Algoritmen en datastructuren
Datastructuren
De datastructuren van de dialoogvensters zullen uiteindelijk grafisch
manipuleerbare objecten zijn. De namen zijn nog niet gekend omdat
pas later voor een raamwerk gekozen wordt. In combinatie met
instellingen zullen de luister objecten ervoor zorgen dat het register
bijgewerkt wordt. Typisch wordt het register bijgewerkt bij opstarten
en afsluiten.
53
Algoritmen
GetCameras spreekt DirectShow functies aan die in de eerste plaats
een nummer geeft aan alle video input die beschikbaar is op het
systeem van de gebruiker. Hij toont deze apparaten in een kader.
GetPropertiesCamera toont een venster op het scherm met de
instellingen die voorhanden zijn voor het specifiek apparaat. Dit
verschilt van apparaat tot apparaat. Bij het maken van DirectShow
filters zullen deze instellingen in acht genomen worden.
54
7.2.5. Subsysteem: <Rechthoeken Tekenen>
UML Klassendiagram
Subsysteem: Rechthoeken tekenen
+SaveFile()+OpenFile()+on_mouse()+SetType()+SetMidi()+SetColor()
-list <RectangleInstrument>DrawWindow
Algoritmen en datastructuren
Datastructuren
Een lijst van de klassen RectangleInstrument worden bijgehouden
om op te slaan en te tekenen
Algoritmen
On_mouse voorziet het tekenen van rechthoeken in een venster en
luistert naar berichten van de muis. Het slaat in principe de
linkerbovenhoek en rechterbenedenhoek van de rechthoek op.
SetType stelt het type van de rechthoek in
55
SetMidi stelt de MIDI-boodschap die verbonden is aan de rechthoek
in
SetColor zet de kleur van de lijn van de rechthoek
SaveFile zal de lijst van rechthoeken opslaan in een bestand, al dan
niet tijdelijk, om zo beschikbaar te zijn voor de analyse.
OpenFile haalt rechthoeken op uit een bestand met de extensie drw
56
8. Implementatie 8.1. Implementatie en integratie
8.1.1. Naam
De naam MovementAnalyzer werd gekozen voor de toepassing.
8.1.2. Programmeertaal
Aangezien de klant mezelf is en andere gebruikers die eventueel willen beschikken
over dit programma is de keuze voor de programmeertaal vrij. Het programma is
echter aangewezen op bestaande bibliotheken die het programmeerwerk aanzienlijk
vergemakkelijken, maar ook de keuzes beperken. In die mate dat ik bijna geen keuze
meer had. Ik behandel kort de gebruikte bibliotheken:
OpenCV
OpenCV staat voor Open Computer Vision Library en is een open bron bibliotheek
die bedoeld is voor onderzoekers, softwareontwikkelaars en camera verkopers. De
gedachte achter de bibliotheek is snelle code te ontwerpen die voornamelijk bedoeld
is voor Intel processoren. Gebruiksdomeinen zijn HCI of Human Computer
Interaction, videobewaking en robotica.
De bibliotheek is geschreven in C++. Datastructuren hebben de vorm
Cv<naam><object> en functies hebben de naam cv<name><object>. De kern van de
OpenCV bibliotheek is echter de datastructuur IplImage. Dit is een erfenis van de
Intel Image Processing Library. De datastructuur voorziet naast evidente factoren
zoals breedte, hoogte, aantal kanalen en diepte van het beeld ook ROI en COI.
Respectievelijk Region Of Interest en Channel Of Interest. De eerste bepaalt een
rechthoek in het beeld dat belangrijk is de tweede bepaalt het kanaal dat belangrijk is
bijvoorbeeld het rode kanaal bij een RGB beeld.
De bibliotheek is dus vooral geënt op Windows en Linux gebruikers. De OpenCV
bibliotheek voorziet echter ook methodes om via DirectShow binnenkomende
apparatuur te detecteren en te gebruiken als input. Uiteraard is dit enkel beschikbaar
voor Windows gebruikers.
57
DirectShow
De DirectShow API of Aplication Programming Interface (nu versie 9.0) is een media-
streaming architectuur voor het Windows platform. Het vereenvoudigt de detectie van
apparaten en verzorgt hoogwaardige captatie van deze apparaten. DirectShow is
nog steeds gebaseerd op het Component Object Model een architectuur om
componentgebaseerde toepassingen te ontwikkelen. Deze architectuur wordt nu als
verouderd gezien ten opzichte van het .NET raamwerk. Code blijft echter makkelijker
te schrijven in C++ in plaats van C# voor deze applicaties.
OpenSound Control
OpenSound Control is een protocol voor communicatie tussen computers,
synthesizers en multimedia apparaten en wordt ondersteund door verschillende
applicaties. Het voordeel aan dit protocol is de ondersteuning en het feit dat het
onderliggende protocol UDP is. Wat handig is voor snelle datatrafiek en realtime
behandeling. Het is vooral de ondersteuning van Max/MSP of Pure Data die dit
protocol onontbeerlijk maken. Deze programma’s zijn 4de generatie
programmeeromgevingen die realtime controle toelaten. Deze
programmeeromgevingen worden veel gebruikt bij interactieve muziekinstallaties.
Voor een overzicht van deze applicaties en interactieve muziekinstallaties in het
algemeen refereer ik naar mijn vorige scriptie (Claeys 2006). De broncode voor het
maken van een cliënt voor dit protocol is geschreven in C.
Windows Microsoft Foundation Classes
Aangezien OpenCV gebaseerd is op C++ en DirectShow eveneens ben ik al snel op
deze programmeertaal aangewezen. Dan moet ik nog een raamwerk kiezen voor de
grafische omgeving. Hier had ik nog twee keuzes over. Het .NET raamwerk of het
verouderde MFC of Microsoft Foundation Classes. Voor het gebruik van het .NET
raamwerk ben ik aangewezen op C# of managed C++. Aangezien C++ en de
combinatie MFC sterk geïntegreerd zijn met elkaar en probleemloos C code
integreren voor OpenSound Control gaat mijn voorkeur hier naar uit. Ook is er voor
deze applicaties veel informatie voorhanden zowel in de boekhandel als op het
internet. Uiteraard is het mogelijk om .NET te gebruiken maar het zou enigszins de
implementatie van de bibliotheken moeilijk maken.
58
8.1.3. Module afhankelijkheid
De GUI
Omdat de grafische omgeving enkel instellingen omvat lag het voor de hand om
eerst deze grafische omgeving te programmeren en pas daarna de bibliotheken te
integreren. Drivers werden gecreëerd om de grafische omgeving te testen. Hiervoor
werd Microsoft Visual Studio 2008 versie 9.0.21022.8 gebruikt. De versie van MFC
is 9.0.30411 die beschikbaar gesteld werd op 7 april 2008. Het programma voorziet
een simpele manier om grafische omgevingen op te bouwen. De wizard ontwerpt bij
het maken van een Windows applicatie automatisch een hoofdvenster aan en
menubalk. Deze objecten zijn interactief wijzigbaar. Toch ben je soms nog
aangewezen op het handmatig wijzigen van de zogenaamde resource files die de
gebruikte grafische objecten definiëren. De algemene klasse voor grafisch
hanteerbare objecten is CWnd. De meest gebruikte klasse is hier CDialog voor de
dialoogvensters. Een exemplarisch dialoogvenster ziet er als volgt uit:
// dialog.cpp #include "stdafx.h" #include "mainapplication.h" #include "dialogvoorbeeld.h" // CDialogVoorbeeld dialog IMPLEMENT_DYNAMIC(CDialogVoorbeeld, CDialog) CDialogVoorbeeld:: CDialogVoorbeeld (CWnd* pParent /*=NULL*/) : CDialog(CDialogVoorbeeld::IDD, pParent) { } CDialogVoorbeeld::~ CDialogVoorbeeld () { } void CDialogVoorbeeld::DoDataExchange(CDataExchange* pDX) { CDialog::DoDataExchange(pDX); DDX_Control(pDX, ID_BUTTON, knop); DDX_Control(pDX, ID_CHECK, checkknop); } BEGIN_MESSAGE_MAP(CDialogVoorbeeld, CDialog) ON_BN_CLICKED(IDOK, OnOK) ON_BN_CLICKED(ID_CANCEL, OnCancel) END_MESSAGE_MAP() BOOL CDialogVoorbeeld::OnInitDialog() { CDialog::OnInitDialog(); GetData();
59
} void CDialogVoorbeeld::OnOK() { SetData(); CDialog::OnOK()
} void CDialogVoorbeeld::OnCancel() { CDialog:OnCancel() } void CDialogVoorbeeld::GetData() { } void CDialogVoorbeeld::SetData() { }
De headers verwijzen naar de hoofdapplicatie (mainapplication.h), de header van dit
dialoogvenster zelf (dialogvoorbeeld.h) en de optionele precompiled header die het
compileren van de applicatie versnelt (stdafx.h).
De constructor voorziet een bepaling van het bovenliggende venster. Bij NULL
waarde is deze de hoofdapplicatie.
De functie DoDataExchange voorziet in het koppelen van een grafisch object aan
een variabele. Deze variabele maakt het werken met deze objecten makkelijker.
Grafische objecten worden geïdentificeerd aan de hand van een constante unieke
integer die vastgelegd wordt in de resource file. ID_BUTTON kan hier bijvoorbeeld
staan voor het geheel getal 1001. Het uitwisselen is optioneel maar kan heel handig
zijn. De resource file staat in voor de grafische weergave van de objecten. De positie
en het gedrag van de grafische objecten kunnen daar ingesteld worden.
De Message Map koppelt een specifieke actie van de gebruiker op een grafisch
object aan een functie. Iedere actie moet dus hier eerst gekoppeld worden aan een
grafisch object.
OnInitDialog, OnOK en OnCancel zijn herdefinieerbare methodes. OnInitDialog is
een routine die opgeroepen wordt als het dialoogvenster gecreëerd wordt. De
returnwaarde BOOL laat toe fouten te onderscheppen. OnOK geeft een
returnwaarde ID_OK terug aan de hoofdapplicatie. OnCancel geeft een returnwaarde
ID_CANCEL terug aan de hoofdapplicatie.
Hanteerbare objecten uit de klasse CWnd die in een dialoogvenster kunnen
ingevoegd worden zijn bijvoorbeeld CComboBox (een combobox), CButton (kan
60
zowel radio als checkbutton zijn), CEdit (een tekstvakje dat ingevuld kan worden),
CStatic (objecten enkel voor weergave), en specifieke controls zoals CIPAddressCtrl
(voor het invullen van een IP adres) CDateTimeCtrl (een kalender) die meer
gespecialiseerde functies oplevert. Een object kan verschillende soorten methodes
krijgen om naar de handelingen van gebruikers te luisteren, afhankelijk van het type
object. Een grafisch object kan ook verschillende variabelen bevatten die ofwel
refereren naar de inhoud of naar het object zelf.
Bij iedere dialoog heb ik zelf een functie gemaakt die contact maakt met het register.
Deze zijn GetData en SetData en roepen statische functies op van de klasse
Register. Alle instellingen kunnen dus geschreven worden naar het register of eruit
gehaald.
Het dialoogvenster kan op twee manieren gecreëerd worden. Door het oproepen van
DoModal in de hoofdapplicatie krijgt men een dialoogvenster dat moet gesloten
worden vooraleer men met andere vensters wil werken. Met de Create functie krijgt
men een dialoogvenster dat men niet moet sluiten als men met andere vensters wil
werken. Omdat het hier om vensters gaat die instellingen doen werd gekozen voor
de eerste optie.
Een voorbeeld van een hoofdapplicatie:
#include "stdafx.h" #include "mainapplication.h" #include "MainFrm.h" #include "AboutDlg.h" #ifdef _DEBUG #define new DEBUG_NEW #endif BEGIN_MESSAGE_MAP(CMainApplication, CWinApp) ON_COMMAND(ID_DIALOG_VOORBEELD, OnDialogVoorbeeld) END_MESSAGE_MAP() CMainApplication::CMainApplication() { } CMainApplication theApp; BOOL CMainApplication::InitInstance() { InitCommonControls(); CWinApp::InitInstance(); AfxEnableControlContainer(); SetRegistryKey(_T("MainApplication")); CMainFrame* pFrame = new CMainFrame; if (!pFrame)
61
return FALSE; m_pMainWnd = pFrame; pFrame->LoadFrame(IDR_MAINFRAME, WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE, NULL, NULL); EnableShellOpen(); pFrame->ShowWindow(SW_SHOW); pFrame->UpdateWindow(); return TRUE; } void CMainApplication::OnDialogVoorbeeld() { CDialogVoorbeeld dlg; dlg.DoModal(); }
De hoofdapplicatie werkt gelijkaardig aan een dialoogvenster. De message map
koppelt acties van de gebruiker in het venster aan methodes. InitInstance is
vergelijkbaar met OnInitDialog. Het maakt een registersleutel aan en maakt een
frame aan, hier pFrame. Dit is het hoofdvenster van waaruit de gebruiker zijn
interactie start.
Dit hoofdvenster en bijkomende dialoogvensters volstaan voor het schrijven van mijn
applicatie. Al de instellingen kunnen via deze vorm ingesteld worden.
Merk op dat een globale variabele van de instantie zelf wordt gemaakt. Deze is
handig bij het behandelen van het register.
Het register
Een volgende stap is het aanmaken van het register en zijn functies. Ieder
dialoogvenster heeft een GetData en SetData functie. Het register heeft functies om
de instellingen te bewaren en de instellingen op te halen. Iedere parameter krijgt dus
twee functies in de vorm van Get<parameter> en Set<parameter>. De
dialoogvensters staan dan in voor het plaatsen van deze informatie aan het juiste
grafische object. De applicatie kan in het register schrijven aan de hand van vier
functies:
CWinApp::GetProfileInt
CWinApp::SetProfileInt
CWinApp::GetProfileString
CWinApp:SetProfileString
Deze worden gebruikt in de klasse register en nemen een sectie, een sleutel en een
waarde (int of string) aan. SetProfileInt(“Sectie”,”Sleutel”,3) schrijft dus in het register
62
/Sectie/Sleutel en kent waarde 3 toe aan sleutel. GetProfileInt(“Sectie”,”Sleutel”,0)
retourneert die waarde, maar als de sleutel niet gevonden is retourneert ze de
waarde 0.
In mijn geval is de instantie waarop deze methodes gebruikt worden de
hoofdapplicatie zelf, gedefinieerd als een globale variabele.
De grafische objecten zijn hanteerbaar op een aantal verschillende manieren:
CButton::GetCheck() retourneert een geheel getal die de status van de knop
beschrijft bij zogenaamde checkbuttons. CWnd::GetWindowText(CString) schrijft
tekst van het object in een CString, dit is handig bij de klasse CEdit. Omgekeerd zijn
er natuurlijk de functies CButton::SetCheck() en CWnd::SetWindowText(CString).
Een klein voorbeeld:
Klasse Register:
BOOL Register::GetBoundingRender(void) { return theApp.GetProfileInt("optionsCamera","boundingRectSelected"
,FALSE); } void Register::SetBoundingRender(BOOL boundingRender) { theApp.WriteProfileInt("optionsCamera","boundingRectSelected",
boundingRender); }
Hierbij is theApp de hoofdapplicatie.
En een voorbeeld van een klasse waarin deze gebruikt wordt:
void CCameraDlg::GetData() { renderBoundingRect.SetCheck(Register::GetBoundingRender()); } void CCameraDlg::SetData() { Register::SetBoundingRender(renderBoundingRect.GetCheck()); }
Aangezien de functies in de klasse register statisch gedefinieerd zijn kunnen ze
opgeroepen worden uit ieder dialoogvenster of bewerking.
Op deze manier is het ophalen van instellingen zeer eenvoudig en worden de
instellingen fysiek opgeslagen.
63
Het ophalen van de input
Een volgende functie is het ophalen van de camera’s via DirectShow. Hiervoor
nummeren we de apparaten van de categorie input en tonen deze in een combobox.
Er wordt eerst een instantie gecreëerd van een CLSID, dit is een unieke identiteit
voor een COM object opgeslagen in het register. In dit geval is de CLSID een object
dat systeemapparaten nummert. Deze instantie creëert op zijn beurt een object dat
videoapparaten nummert. Het pseudoniem van elk object wordt opgehaald en
toegevoegd aan een combobox. De selectie die gemaakt wordt refereert zo naar een
nummer, die identiek is aan het nummer van het apparaat.
Bij het uitvoeren van de applicatie zal enkel dit nummer gebruikt worden om een
specifiek apparaat aan te sturen.
Een tweede functie is het ophalen van de DirectShow eigenschappen voor het
specifiek apparaat. Dit is gekoppeld aan het nummer dat gekozen is in de combobox.
Het nummert opnieuw, maakt de filter aan en toont de eigenschappen pagina van
deze filter.
Het nadeel van deze methode is dat sommige filters aanwezig zijn als het apparaat
niet aangesloten is. Zodoende kan men apparaten kiezen die in het systeem
aanwezig zijn, maar niet fysiek aanwezig zijn. Echter een klein nadeel, omdat de
gebruiker wel weet als het apparaat aangesloten is of niet. Hij kan trouwens het
apparaat aankoppelen juist voordat hij de applicatie start. In die zin kan hij
instellingen doen en dan het apparaat aankoppelen. Het heeft dus voordelen en
nadelen.
De code is als volgt:
Cameras ophalen:
BOOL CCameraDlg::GetCameras() { HRESULT hr; ICreateDevEnum *pSysDevEnum = NULL; hr = CoInitialize(NULL); hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,IID_ICreateDevEnum,
(void **)&pSysDevEnum); if (FAILED(hr)) {
AfxMessageBox("could not create System Device Enumerator");
return FALSE; } // Nummeren van video-input
64
IEnumMoniker *pEnumCat = NULL; hr = pSysDevEnum->CreateClassEnumerator
( CLSID_VideoInputDeviceCategory, &pEnumCat, 0 );
if (hr == S_OK) { // Nummeren van de namen IMoniker *pMoniker = NULL; ULONG cFetched; while(pEnumCat->Next(1, &pMoniker, &cFetched) == S_OK) { IPropertyBag *pPropBag; hr = pMoniker->BindToStorage(
0, 0, IID_IPropertyBag, (void **)&pPropBag);
if (SUCCEEDED(hr)) {
//ophalen van de naam VARIANT varName; VariantInit(&varName); hr = pPropBag->Read(L"FriendlyName",
&varName, 0); if (SUCCEEDED(hr)) { CString s(varName.bstrVal); cameraComboBox.AddString(s); UpdateData(); // naam wordt toegevoegd aan de // combobox } VariantClear(&varName); pPropBag->Release(); } pMoniker->Release(); } pEnumCat->Release(); } pSysDevEnum->Release(); CoUninitialize(); return TRUE; }
Eigenschappen pagina ophalen: BOOL CCameraDlg::GetPropertiesCamera() { int selected; selected = cameraComboBox.GetCurSel(); HRESULT hr; ICreateDevEnum *pSysDevEnum = NULL; hr = CoInitialize(NULL); hr = CoCreateInstance
( CLSID_SystemDeviceEnum, NULL,
CLSCTX_INPROC_SERVER,IID_ICreateDevEnum, (void **)&pSysDevEnum );
65
if (FAILED(hr)) { AfxMessageBox("Could not create System Device Enumerator"); return FALSE; } IEnumMoniker *pEnumCat = NULL; hr = pSysDevEnum->CreateClassEnumerator
(CLSID_VideoInputDeviceCategory, &pEnumCat, 0);
if (hr == S_OK) { // Nummeren van de apparaten IMoniker *pMoniker = NULL; ULONG cFetched; for(int i=0;i<=selected;i++) hr = pEnumCat->Next
(1, &pMoniker, &cFetched); if (SUCCEEDED(hr)) { IPropertyBag *pPropBag; hr = pMoniker->BindToStorage(
0, 0, IID_IPropertyBag, (void **)&pPropBag );
if (SUCCEEDED(hr)) { //creëert instantie van filter IBaseFilter *pFilter; hr = pMoniker->BindToObject
( NULL, NULL, IID_IBaseFilter,(void**)&pFilter );
ISpecifyPropertyPages *pProp; hr = pFilter->QueryInterface
( IID_ISpecifyPropertyPages, (void **)&pProp);
if (SUCCEEDED(hr)) { // de naam wordt opgehaald FILTER_INFO FilterInfo; hr = pFilter->QueryFilterInfo
(&FilterInfo); IUnknown *pFilterUnk; pFilter->QueryInterface
(IID_IUnknown, (void **)&pFilterUnk);
// Toont de pagina CAUUID caGUID; pProp->GetPages(&caGUID); CWnd* c = this->GetParent(); OleCreatePropertyFrame
( c->m_hWnd,0, 0,FilterInfo.achName, 1, &pFilterUnk,caGUID.cElems, caGUID.pElems,
0,0, NULL );
66
// Opruimen if (pFilterUnk!=NULL)
pFilterUnk->Release(); if (FilterInfo.pGraph!=NULL)
FilterInfo.pGraph->Release(); CoTaskMemFree(caGUID.pElems); } pProp->Release(); pFilter->Release(); } pPropBag->Release(); } pMoniker->Release(); } pEnumCat->Release(); pSysDevEnum->Release(); CoUninitialize(); return TRUE; }
De code kan voor verschillende soorten apparaten gebruikt worden door gewoon de
CLSID te veranderen bij CreateClassEnumerator. Een latere evolutie van dit
programma kan eventueel ook het openen van filmbestanden toelaten voor analyse,
of streaming van het web toelaten.
Rechthoeken tekenen
Nu gaan we rechthoeken tekenen. We kunnen een type kiezen, en ook een MIDI-
signaal, nadat we deze instellingen doen kunnen we één of meerdere rechthoeken
tekenen. Het venster dat daarvoor gebruikt wordt krijgt een statische callback functie
vanuit OpenCV. Deze functie heet on_mouse en luistert naar bepaalde
gebeurtenissen. De gebeurtenissen die behandelt worden beschreven door een
getal, ze hebben echter statische constanten gedeclareerd. Deze constanten zijn
CV_EVENT_LBUTTONDOWN, CV_EVENT_MOUSEMOVE, en
CV_EVENT_LBUTTONUP. De eerste geeft de event als de muisknop ingedrukt
wordt. In dat geval wordt de linkerbovenhoek van de rechthoek vastgelegd. Een
boolean lbuttondown wordt dan op true gezet. De tweede event tekent per
muisbeweging de rechthoek als de boolean lbuttondown true is. Wanneer de
muisknop wordt losgelaten schiet de laatste event in werking, en deze zet de
rechterbenedenhoek van de rechthoek, en voegt ook de gegevens van de rechthoek
aan zoals het nummer van de rechthoek, het type rechthoek, en het kleur van de
rechthoek en de MIDI-boodschap die er aan verbonden is. De gegevens worden nu
67
opgeslagen in een lijst van IplImage structuren, en ook in een lijst van
RectangleInstrument. klassen.
Deze worden gebruikt om de Undo opdracht te kunnen uitvoeren. Als deze ingedrukt
wordt zal uit de lijst één rechthoek verwijderd worden, en één afbeelding. De laatste
afbeelding uit de lijst wordt dan getoond op het scherm. Wanneer de gebruiker klaar
is met rechthoeken tekenen wordt de lijst van rechthoeken opgeslagen in een tijdelijk
tekstbestand met de extensie drw. Elke lijn in het tekstbestand staat voor een
rechthoek, en de eigenschappen van deze rechthoek worden gescheiden door
spaties. De gebruiker kan ook bestanden opslaan of openen met de extensie drw.
Het camerabeeld voorbereiden voor analyse
Een volgende stap is de analyse. Omdat dit het hart is van de applicatie en de
grafische interface in vorige stappen al gecodeerd zijn en getest zijn is dit de
volgende stap. De parameters worden immers berekend hieruit.
Het grote werk is natuurlijk het analyseren van de videobeelden, maar ook eveneens
rekening houden met de snelheid waarmee de analyse gebeurt. Een hoge vereiste
voor deze applicatie.
Het eerste werk is de video ophalen. Hiervoor gebruikte ik in eerste instantie cvcam
van OpenCV dat samenwerkt met DirectShow. Het is eveneens in staat de input te
configureren, maar ik verkoos dit zelf te doen omdat er geen controle was over de
vensters. De kracht van het programma is de conversie van de video input naar een
IplImage. Dit gebeurt aan de hand van de DirectShow filter proxytrans.ax bijgeleverd
bij dit programma. Men kan een callback functie definiëren die in staat is iedere
frame te analyseren die van de video input komt. De bibliotheek is zeer handig aan
ene kant maar heeft toch enkele problemen:
- De callback functie is een statische functie waardoor enkel globale variabelen
gebruikt kunnen worden als men over verschillende frames iets wil verwerken.
- Het venster met de originele input is nagenoeg niet behandelbaar. Het wordt altijd
getoond en kan maar in geringe mate deel uit maken van de applicatie.
- Elke frame moet en zal behandeld worden, waardoor intensieve berekeningen al
snel tot oplopende vertragingen leidden.
- De callback functie aanvaardt geen enkele inkomende parameter buiten het beeld
van de video. Hiervoor zijn we dus ook aangewezen op globale variabelen.
68
Instellingen die aangewezen zijn voor analyse moeten dus ook ingeladen worden
in een globale variabele.
Er was dan ook grote twijfel om hiermee aan te vangen. Maar het was vooral de
compatibiliteit met alle video apparatuur via DirectShow die deze applicatie in eerste
instantie heel interessant maken.
De werking van cvcam is zeer eenvoudig. Eerst telt hij het aantal camera’s die
aanwezig zijn, en geeft ze een nummer. Vervolgens moeten een aantal
eigenschappen gezet worden zoals het venster, de rendering en de callback functie.
De camera wordt geïnitieerd, gestart en voor iedere frame wordt de callback functie
aangeroepen. Bij een bepaalde event kan dan de camera gestopt worden. De
initialisatie wordt ongedaan gemaakt en alle vensters worden verwijderd. In volgorde
zijn volgende stappen nodig voor initialisatie: cvcamGetCamerasCount(); int cameraSelected = Register::GetCameraSelect(); if (Register::GetBgRender()==TRUE) cvNamedWindow("BackGround",1); cvcamWindow original = 0; cvcamSetProperty(cameraSelected,CVCAM_PROP_ENABLE, CVCAMTRUE); cvcamSetProperty(cameraSelected,CVCAM_PROP_WINDOW,&original); cvcamSetProperty(cameraSelected,CVCAM_PROP_RENDER, CVCAMTRUE); cvcamSetProperty(cameraSelected,CVCAM_PROP_CALLBACK,CRunDialog::analysis); cvcamInit(); cvcamStart(); cvcamResume();
De analyse begint nu en de beelden worden opgevangen. Het aanvaardt een pointer
naar een IplImage data structuur.
Voor het stoppen van de camera is volgende code noodzakelijk. cvcamStop(); cvcamExit(); cvDestroyAllWindows();
Veel configuratie van de camera kan niet bepaald worden. Het hart van de operatie
is dan de callback functie.
Door de problemen die ik had met de statische callback functie en zijn globale
variabelen heb ik uiteindelijk de cvcam procedure vervangen door een applicatie van
Dominic Ankers. De bibliotheek dscam is gelijkaardig aan cvcam, maar het haalt alle
nadelen eruit. Dscam staat voor DirectShow camera capture utility. Het voorziet in
ongeveer dezelfde functies als cvcam. Volgende functies zijn gedefinieerd:
69
DSCAM_API int dsCamCount (int *pnCams); DSCAM_API int dsSetCam (int ncam, int *nWidth, int *nHeight, int *nfps); DSCAM_API int dsSetWindow (int ncam, HWND hWnd); DSCAM_API int dsStart (); DSCAM_API int dsStop (); DSCAM_API int dsDoneCam (int ncam); DSCAM_API int dsSetCB (int ncam, dsCallBack *pCB); DSCAM_API char *dsGetLastErrStr (int errcode); DSCAM_API int dsGetCamDescr (int ncam, char *pszdesc, int nsizszdesc); DSCAM_API int dsDispProps (int ncam);
De werking is gelijkaardig. Eerst worden de camera’s geteld, en krijgen elk een
nummer. Dan kan je de camera instellen, met het nummer van de camera, de
breedte, hoogte en het aantal frames per seconde. De camera wordt gestart met
dsStart, een callback functie kan ingezet worden met dsSetCB, en de camera wordt
gestopt met dsStop. Opruimen gebeurt met dsDoneCam. Het grootste voordeel
echter van de bibliotheek is de definiëring van een virtuele klasse namelijk de
dsCallBack klasse.
class dsCallBack { public: void virtual CB (double SampleTime, BYTE *pBuffer, long BufferLen)=0; };
Deze virtuele functie laat toe een klasse te creëren waarin de methode CB kan
overschreven worden. Het datatype BYTE *pBuffer geeft dan een pointer naar het te
verwerken beeld in ruwe data. Hierdoor ben ik verlost van globale variabelen.
Een ander voordeel is dat men het venster al of niet kan tonen. Hiermee ben ik
verlost van het niet te wijzigen originele beeld. De omzetting van data naar IplImage
gebeurt in een andere klasse namelijk thCam. Deze klasse van Dominic Ankers is
een instantie van de dsCallback klasse, en is bedoeld om te werken met kritieke
secties. Hij opent en sluit hierbij kritieke secties in de code, om voorrang te geven
aan de captatie van het beeldmateriaal in DirectShow, en de omzetting naar een
IplImage. De verwerking gebeurt dan in de functie OnMRI. Eveneens een virtuele
functie gedefinieerd als volgt:
virtual void OnMRI (IplImage *pimg);
Een instantie van deze klasse wordt dan mijn klasse Camera waarin het beeld kan
verwerkt worden.
70
De analyse zelf
Bij analyse moeten we iedere pixel in het beeld aanwezig analyseren en eventueel
veranderen. Om de snelheid aanzienlijk te verhogen moeten we daarom enkele
zaken in acht houden. In de eerste plaats kunnen we instellingen doen bij de camera
zelf om het beeld te reduceren:
- De videoresolutie: hoge resoluties zijn hier overbodig. Een lage resolutie tot
640x480 moet meer dan voldoende zijn om tot analyse over te gaan.
- Het aantal kanalen van het beeld: Een beeld kan tot 4 kanalen hebben, waarvan
we er eigenlijk maar één nodig hebben als we kleuren overboord gooien. De
analyse kan tot vier keer sneller gaan als we maar één kanaal bewerken.
- De diepte van het beeld. Hier kunnen we van 8 bit tot 24 bit gaan. Bij een beeld
met 8 bit zal de analyse sneller gaan.
Het binnengekomen beeld kan zo gereduceerd worden tot een werkbare eenheid.
Hiervoor converteer ik het beeld naar een beeld met enkel grijswaarden. Dit houdt
een 8 bit waarde in met één kanaal. Hierdoor is zowel de diepte als het aantal te
analyseren kanalen gereduceerd. Daarnaast is de breedte van het venster instelbaar
zodat ook hier reductie kan plaatsvinden. Om rekentijd te sparen kan dit helpen. De
code is als volgt. IplImage* resize = cvCreateImage
( cvSize(resizew,resizeh),image->depth, image->nChannels );
cvResize(image,resize,CV_INTER_LINEAR); IplImage* gray = cvCreateImage
( cvSize(resizew,resizeh),image->depth,1 );
cvCvtColor(resize,gray, CV_RGB2GRAY);
Nu hebben we een beeld gray dat klaar is voor verdere verwerking. Een volgende
stap is de achtergrond weghalen over een aantal frames.
Hiervoor zijn verschillende technieken voorhanden. Er is een algoritme nodig, dat
realtime werkt, en snel reageert op beweging. De bedoeling is dat er enkel bij
beweging van het lichaam signalen opgevangen worden. Poses zijn niet gewenst als
input. Hierdoor moet over korte tijd berekend worden. Een goede afweging van ieder
algoritme werd beschreven door Cheung en Kamath (Cheung & Kamath 2007). Er
71
zijn twee algemene types volgens hen. Recursieve technieken en niet-recursieve
technieken.
Niet-recursieve technieken slaan een buffer op van een aantal video beelden, en
maakt een schatting van de achtergrond gebaseerd op temporele variaties van
iedere pixel in die buffer. De techniek past zich snel aan, omdat ze niet verder kijken
dan die buffer. Nadeel is dat de opslag hoeveelheid groot kan zijn bij een grote
buffer. Hoe groter de buffer, hoe gevoeliger het algoritme is voor beweging.
Recursieve technieken houden geen buffer bij voor de schatting van de achtergrond.
Ze passen recursief een achtergrond model aan bij ieder inkomend beeld. Hierdoor
hebben alle beelden van begin tot einde invloed op het verwerkte beeld. Deze
technieken voorzien dus minder opslag, maar enige fout in het beeld zal voor langere
periode blijven staan.
Uit de vergelijkende studie tussen technieken kwamen er twee uit als beste. Voor de
recursieve technieken was dit Mixture of Gaussians, en voor niet-recursieve
technieken was dit Median Filter.
Mixture of Gaussians of MoG is een techniek geïntroduceerd in 1997 door Friedman
en Russel (Friedman, Russel 1997). De techniek gebruikt kansrekening. Iedere pixel
kan bij een klasse behoren. Bijvoorbeeld voorgrond en achtergrond. Men kan
eventueel ook schaduw als klasse invoeren of fel licht. De kans dat een pixel bij één
van die klassen behoort wordt bij elk beeld geüpdatet. Ik had het geluk dat OpenCV
een functie voorziet die Mixture of Gaussians toepast. Het model hanteert ook
schaduwdetectie. Het is beschreven in het artikel van Kaewtrakulpong en Bowden
(Kaewtrakulpong, Bowden 2001). Een median filter methode werd voorzien door Ofer
Achler.
De structuur CvBGStatModel van OpenCV laat definiëring van een recursief model
toe voor het weghalen van een achtergrond. Twee standaard modellen zijn aanwezig
in de bibliotheek CvGaussBGModel en CvFGDStatModel. Het Gaussian model werd
hierbij gebruikt, daar het tweede model heel rekenintensief is. De opbouw is als volgt:
if (firstframe==TRUE) { background_model = cvCreateGaussianBGModel(gray); firstframe=FALSE; } cvUpdateBGStatModel(gray, background_model);
72
Als de input van de camera begint wordt het model gemaakt. Het model werd
toegepast op een 8-bit beeld, met 1 kanaal met de naam gray. Het model wordt
steeds aangepast bij ieder inkomend beeld. Uit dit model kan men dan de voorgrond
en achtergrond halen. Het getoonde resultaat wordt als volgt weergeven
cvShowImage("BackGround",background_model->foreground);
Het algoritme werkt relatief snel, het gaat niet boven de 78 ms bij 15 beelden per
seconde. Er is echter veel ruis. Deze kan echter opgelost worden via een functie (Cf.
infra). Minder goed is dat bij de minste aanraking van de webcam, of lichtinval het
model grondig verstoord wordt. Delen komen als witte pixels voor, waarbij het enkele
seconden duurt vooraleer de toestand weer normaal is.
Dit kan echter nefast zijn voor de toepassing. Een heel lichte storing zoals het trillen
van de webcam kan al gevaarlijk zijn. De impact op de rekensnelheid wordt later
geëvalueerd bij het testen.
De Median Filter methode is niet-recursief. Een aparte klasse werd gemaakt voor
deze functie namelijk Background. Er zijn twee functies voor de
achtergrondmethode. De methode update en de methode Difference. De methode
update past een middelste frame aan ten opzichte van het nieuwe binnenkomende
beeld. Het aantal frames of de buffer kan zo gekozen worden, alsook de middelste
waarde die uiteindelijk het beeld vormt. Ik werk hier met een voorbeeld van 6
beelden, waarbij beeld 3 de middelste waarde is. De waarde van elke pixel van ieder
beeld wordt opgeslagen. Als de waarde van de pixel van beeld 1 groter is dan die
van beeld 2 wordt deze waarde verwisseld. Beeld 1 wordt zo vergeleken met alle 5
beelden, waarop beeld 2 aan de beurt is, die wordt vergeleken met de andere 4
beelden. De waarde van het te bekomen beeld is de waarde van beeld 3 na deze
operatie, of de middelste waarde van al die pixels. Het aantal frames en de impact op
de rekensnelheid wordt later geëvalueerd bij het testen.
De update functie ziet er als volgt uit:
void Background::bgupdater(void) { int x,y,w,h,count1,count2,numframes; BW carr[BGFRAMES],cctmp; w = bgframe[0]->width; h = bgframe[0]->height; for (count1=0;((bgframe[count1]!=NULL)&& (count1<BGFRAMES)); count1++);
73
numframes=count1; for (y=0;y<h;y++) { for (x=0;x<w;x++) { for (count1=0;count1<numframes;count1++) { carr[count1].W =
bgframe[count1]->imageData[y *bgframe[count1]->widthStep+x *bgframe[count1]->nChannels];
} //Orderen for (count1=0;count1<numframes;count1++) {
for (count2=count1+1; count2<numframes;count2++)
{ if ( (int)carr[count1].W
>(int)carr[count2].W) { cctmp = carr[count2]; carr[count2] = carr[count1]; carr[count1]= cctmp; } } } bgimage->imageData
[y*bgimage->widthStep+x*bgimage>nChannels] =carr[BGCENTRAL].W;
} } }
Hiermee is het beeld voltooid. En opgeslagen in bgimage. Een volgende stap is het
verschil berekenen tussen het beeld en bgimage. Als de pixel van de ene gelijk is
met een bepaalde marge in acht natuurlijk, en er dus geen beweging is wordt deze 0.
Is deze niet gelijk dan wordt de pixel gezet op 255. Hierdoor krijgt men dus een binair
beeld van zwart en wit. En dit op een snelle manier.
De code is zeer eenvoudig:
IplImage* Background::Difference(IplImage* cur) { cvSub(cur, bgimage, cur); cvThreshold(cur,cur,BGDIFFTHRESHOLD,255,CV_THRESH_BINARY); return cur; }
De functies zijn OpenCV functies. cvSub berekent een verschil in pixels van twee
waarden. cvTreshold vergelijkt een pixel met een waarde, als hij daar niet boven zit
retourneert hij een maximumwaarde, anders retourneert hij nul. Deze functie is ook
74
instelbaar zodat hij de oorspronkelijke pixel toont, of de achtergrond wit maakt en het
te bewegen deel zwart.
Er rest ons dan alleen nog ruis weg te halen. Ook hier heeft OpenCV een handige
functie. Het weghalen van de ruis gebeurt via de functie cvSmooth dat een
definiëring van een matrix vereist en een methode. Dit kan zowel median zijn als
gaussian. Median wordt hier echter verkozen omdat deze enigszins sneller is.
De code:
cvSmooth(gray,gray,CV_MEDIAN,3,3);
Een volgende stap is het aanmaken van een rechthoek die de bewegende delen
omkadert. Deze rechthoek vormt een metafoor voor de focus van het menselijk oog
op de beweging. Hier wordt het beeld één keer overlopen en vindt de functie vier
coördinaten van pixels, waarmee de rechthoek gevormd wordt. De meest linkse en
bovenste witte pixel en de meest onderste en rechtse witte pixel worden uit het beeld
gehaald. Een rechthoek wordt hiermee gevormd. De eigenschappen van die
rechthoek zullen uiteindelijk de parameters zijn die worden doorgezonden. Eveneens
het aantal pixels in deze rechthoek worden bijgehouden en doorgezonden. Echter als
de rechthoek minder dan een factor 120 breed is dan het origineel en dus slechts
enkele pixels omsluit wordt deze niet doorgezonden omdat dit een ruis element
bevat. De waarde van alle parameters wordt dan op nul gezet en dat betekent dat er
geen beweging is. Door parameters uit de rechthoek te halen in combinatie met het
aantal pixels krijgen we een adequaat beeld van de ruimte die de gebruiker hanteert,
alsook de hoeveelheid beweging verspreid over zes frames. Hoe sneller de gebruiker
beweegt hoe meer sporen er op het beeld te zien zijn, dus een maat voor de totale
beweging. Deze parameters kunnen vrij gekoppeld worden aan muzikale waarden, of
zelfs andere waarden. De code is eveneens vrij simpel:
void BoundingRect::CalculateBoundingRect(IplImage *brectimage) { //CvPoint lefttop,rightbottom; int x,y,px1,px2,py1,py2; px1=brectimage->width; py1=brectimage->height; px2=0; py2=0; int pixels=0; for (y=0;y<brectimage->height;y++)
75
{ for (x=0;x<brectimage->width;x++) { if(((uchar *)(brectimage->imageData
+ y*brectimage->widthStep))[x]!=0) { pixels++; if (x <= px1) px1=x; if (x >= px2) px2=x; if (y <= py1) py1=y; if (y >= py2) py2=y; } } } CvPoint lefttop,rightbottom; lefttop.x=px1; lefttop.y=py1; rightbottom.x=px2; rightbottom.y=py2; if (Register::GetBoundingRender()==TRUE) {
CvScalar s; s.val[0] = 255; cvRectangle(brectimage,lefttop,rightbottom,s,1);
} CvRect boundingrect = cvRect(lefttop.x,lefttop.y,
rightbottom.y-lefttop.y,rightbottom.x-lefttop.x); boundingrect.width; if ((brectimage->height/120<boundingrect.height)
&& (brectimage->width/120 < boundingrect.width))
{ rectanglesize=(float)(boundingrect.height
*boundingrect.width) /(float)(brectimage->width *brectimage->height);
rectangleverticalposition =(float)1-(float)(lefttop.y +rightbottom.y)/(float)(2* brectimage->height);
rectanglehorizontalposition =(float)(rightbottom.x + lefttop.y)/(float)(2*brectimage->width);
rectanglehorizontalsize = (float)(boundingrect.width) /(float)brectimage->width;
rectangleverticalsize =(float)(boundingrect.height) /(float)brectimage->height;
nonzeropixels = (float)pixels/ (float)(boundingrect.width *boundingrect.height);
} else { nonzeropixels = 0; rectanglesize = 0; rectangleverticalposition = 0; rectanglehorizontalposition = 0; rectanglehorizontalsize = 0; rectangleverticalsize = 0; } }
76
Enkele OpenCV functies moeten wel verduidelijkt worden. CvScalar is zoals de
naam zegt een scalair datatype die vier verschillende waarden bevat, en gebruikt
wordt om het kanaal te bepalen van een beeld. Hier wordt hij enkel gebruikt om de
rechthoek te tekenen. Deze heeft een scalaire waarde nodig voor de kleur van de lijn
van de rechthoek te bepalen. CvPoint spreekt voor zich. Dit is een punt met twee
waarden x en y. Het datatype CvRect is dan de rechthoek bepaald door een
linkerbovenhoek, een breedte en hoogte. cvRectangle tekent deze rechthoek,
tenminste als deze optie ingesteld is.
De parameters die berekend worden zijn relatief aan de grootte van het beeld en
staan voor een verhouding tussen nul en één. Op deze manier is het gemakkelijk om
factoren hieraan te koppelen, en te rekenen met deze eenheden.
Deze parameters zijn publieke variabelen van de klasse BoundingRect en kunnen
doorgezonden worden naar het netwerk.
Nu rest ons nog het implementeren van de getekende rechthoeken. De rechthoek
kan getekend worden als trigger. In dit geval werkt deze als een knop. Indien er
beweging in de rechthoek gedetecteerd wordt zend deze een 1 door. Indien niet een
0. De rechthoek kan ook getekend worden als een schuifbalk. Deze schuifbalken
kunnen ofwel verticaal of horizontaal georiënteerd worden, en hebben een richting
meegekregen. Bij horizontale schuifbalken is dit van links naar rechts of omgekeerd,
en bij verticale is dit van onder naar boven of omgekeerd. Het principe is dat je met je
hand deze schuifbalken naar beneden, naar boven, naar links of rechts duwt,
naargelang de richting van de schuifbalk. Hierbij is het dus de eerste witte pixel die in
de schuiver bemerkt wordt die telt. De schuiver wordt weergegeven door de
rechthoek op te vullen met het kleur. In feite tekent men dan een nieuwe rechthoek
die gevuld is. De bedoeling is dat als het bewegende deel van de persoon zich
wegtrekt uit de rechthoek, de schuiver blijft staan op deze positie. Telkens dat de
schuiver van waarde verandert, zend het systeem enerzijds een MIDI-signaal uit (als
de persoon dit ingesteld heeft), en een OpenSound Control parameter. De
OpenSound Control parameter zendt een waarde door tussen 0 en 1, waarbij 0 de
waarde is een niet gevulde rechthoek, en 1 de waarde bij een volledig gevulde
rechthoek. Het MIDI-signaal is een control change boodschap. Dit dient om
parameters van een extern apparaat te veranderen. Vooraf kan een kanaal gekozen
worden en een module die verandert moet worden. De waarde van het kanaal ligt
77
tussen 0 en 15. De module ligt tussen 0 en 119 volgens de MIDI standaard. De
parameter die beïnvloedbaar is door bewegingen liggen tussen 0 en 127. Omdat
men soms slechts enkele waarden wil veranderen, kan men ook de reikwijdte
instellen van de waarden. Zodat de beïnvloedbare parameter bijvoorbeeld tussen 20
en 40 ligt, of slechts één getal kan bevatten.
Sockets instellen
Om een netwerkconnectie te maken hebben we een socket nodig. In Windows is dit
redelijk voor de hand liggend. Windows heeft klassen om netwerksockets te maken.
Eerst initialiseren we de werking met sockets, en maken een socket aan dat via UDP
uitzendt. UDP wordt hier verkozen omdat het over data gaat waarbij niet de
consistentie van de data, maar de snelheid van de overdracht data van belang is.
Nadat succesvol een socket gemaakt is kan er verbonden worden met een host. Dit
in de vorm van een IP-adres of URL gekoppeld aan een poort.
Ruwe data kan dan doorgezonden worden via deze socket.
De initialisatie gebeurt aan de hand van WSAStartup. Deze functie bepaalt de
hoogste versie die kan gebruikt worden, fouten worden behandeld en getoond aan
de gebruiker.
Socket::Socket(void) { WSADATA info; if (WSAStartup(MAKEWORD(2,0), &info)) { AfxMessageBox("Could not start Windows Sockets, you will not be able to send via OSC"); error = TRUE; return; } s_ = socket(AF_INET,SOCK_DGRAM,0); if (s_ == INVALID_SOCKET) { AfxMessageBox("Cannot Initialize Sockets, OSC can not be used"); closesocket(s_); error = TRUE; return; } error =FALSE; }
Het datatype dat hier gebruikt wordt is socket en aanvaardt het type IP-adres als
parameter (AF_INET staat hier voor IP versie 4.0) en het type protocol. Hier gebeurt
dit via datagrammen. Er wordt dus gebruik gemaakt van een connectieloze
verbinding met een vaste kleine buffer waarde.
78
Connectie maken met een host gebeurt aan de hand van gelijkaardige functies. Het
adres wordt vertaald naar een werkbaar datatype voor de socket. Uiteraard wordt de
geldigheid gecontroleerd van het adres en ook de connectie zelf kan falen. De
berichten worden getoond aan de gebruiker als de connectie faalt. Een fout wordt
bijgehouden zodat het verzenden niet doorgaat als er een fout opgetreden is bij de
connectie.
De code:
void Socket::ConnectToClient(CString host, int port) { hostent *he; if ((he = gethostbyname(host)) == 0) {
if ((he = gethostbyaddr(host,4,AF_INET)) == 0) {
AfxMessageBox("Illegal Network-Address, could not connect"); error = TRUE; return; } } sockaddr_in addr; addr.sin_family = AF_INET; addr.sin_port = htons(port); addr.sin_addr = *((in_addr *)he->h_addr); memset(&(addr.sin_zero), 0, 8); if (::connect(s_, (sockaddr *) &addr, sizeof(sockaddr))) {
AfxMessageBox("Connection Failed, server doesn't accept"); error=TRUE; } }
Het verzenden van de data naar een socket gebeurt aan de hand van een pointer
naar het datatype char waarbij ook de lengte in bytes wordt meegegeven.
OpenSound Control
Het protocol dat gebruikt wordt is OpenSound Control.. Een typisch OSC-pakket kan
bestaan uit een bericht of een bundel. Vooraleer men een bericht stuurt moet men
een adres toewijzen. Dit adres is in de vorm van een string voorafgegaan door een
backslash (/<root>/<container>/<container>/…/<methode>). Het is vergelijkbaar met
een directory maar heeft extra functionaliteit doordat de inkomende berichten bij een
server gerouteerd kunnen worden. Naast het adres zendt het protocol ook het soort
79
type door dat zal doorgezonden worden, het adres en de types worden gescheiden
door een komma de types zijn:
Argumenten OSC type
32 bit zwevend komma getal f
OSC Blob b
32 bit geheel getal i
OSC String s
Enkele voorbeelden van type strings:
Argumenten OSC type string
Drie gehele getallen “,iii”
Twee blobs en een string “,bbs”
Niets “,”
Een zwevend getal “,f”
Een blob, twee strings en drie zwevende getallen “,bssfff”
De OSC blob type is willekeurige data gegroepeerd in 8 bytes met een 4 bytes
geheel getal als indicator van de grootte van het datatype in bytes aan het begin.
Hiermee kan dus alle soorten datatypen doorgezonden worden met maximale grote
van afgerond 4 GiB (in theorie uiteraard).
Naast de standaard OSC types bestaan er ook niet standaard types die veel gebruikt
worden waaronder 64 bit datatypes, RGB kleur, en MIDI.
Stel dat we de volgende blob met hexadecimale code: 64 3E 87 45 F6. Dan krijgen
we het volgende: 00(0) 00(0) 00(0) 05(5) 64 3E 87 45 F6 00(0) 00(0) 00(0)
De laatste bytes maken de vier bytes compleet.
Elke boodschap bestaat uit een veelvoud van vier bytes, waarbij dus een OSC-string
met vier karakters acht bytes in beslag neemt omdat het nog het scheidingskarakter
moet meegeven, in dit geval een 0. Een adres zal ook vervolledigd worden met
nullen als de waarde geen vier bytes in beslag neemt. We zenden bijvoorbeeld een
OSC boodschap met het adres “/adres” en twee strings “vier” en “één”, een geheel
80
getal drie, en de voorgaande blob door krijgen we volgende ruwe data in
hexadecimale code:
2f(/) 61(a) 64(d) 72(r) 65(e) 73(s) 2c(,) 73(s) 73(s) 69(i) 98(b) 00(0) 76(v) 69(i) 65(e) 72(r) 00(0) 00(0) 00(0) 00(0) E9(é) E9(é) 6E(n) 00(0) 00(0) 00(0) 00(0) 03(3) 00(0) 00(0) 00(0) 05(5) 64 3E 87 45 F6 00(0) 00(0) 00(0)
Elk adres kan dus verschillende gegevens doorzenden. Het interessante aan de
adressen is dat ze aan patroonherkenning kunnen doen. Dit gebeurt met een aantal
karakters toe te voegen aan het zenden van de boodschap.
Stel dat de ontvanger negen adressen heeft:
1. adres/a1/a
2. adres/a1/b
3. adres/a2/a
4. adres/a2/b
5. adres/a3/a
6. adres/a3/b
7. adres/a4/a
8. adres/a4/b
9. adres/b/a
De zender kan dan het volgende zenden:
Adres Bereik
adres/* Alle adressen worden aangesproken
adres/a[1-3] adres 1 tot 6 worden aangesproken
adres/a[14]/a Adres 1 en 7 worden aangesproken
adres/a?/b Adres 2, 4, 6 en 8 worden aangesproken
adres/*/a Adres 1, 3, 5,7 en 9 worden aangesproken
81
Boodschappen kunnen verpakt worden in een OSC bundel. Een OSC bundel bestaat
uit verschillende boodschappen met elk een adres, of verschillende bundels. Elke
bundel krijgt de string “#bundle” mee, en een tijdseenheid van zending. Deze kan de
tijd zijn bij het maken van de bundel of een andere tijd. Elke boodschap of bundel die
in een bundel verzonden wordt krijgt zijn lengte mee die 4 bytes in beslag neemt.
De grafische interface van het menu parameters laat de gebruiker toe voor iedere
parameter een adres toe te wijzen en ook een adres voor de wortel te kiezen. Elk
adres wordt getest op geldigheid terwijl men typt om de gebruiker bij te staan. De
gebruiker kan zo gebruik maken van de patroonherkenning van het protocol, en de
adressen aanpassen aan al bestaande adressen in zijn applicatie. De adressen en
de waarde worden doorgezonden in een bundel met de tijd van het maken van de
bundel. Alle parameters komen toe op hetzelfde tijdstip. Er zijn echter slechts enkele
applicaties die ook de tijdseenheid van dit protocol aanvaarden. Meestal wordt deze
door de servers van de applicaties genegeerd.
Het adres van de wortel werd beperkt tot 35 karakters en het adres van de parameter
werd beperkt tot 36 karakters. Zodoende kan in dit geval een OSC bundel maximum
520 bytes in beslag nemen. De rekensom:
Een maximale boodschap:
4 bytes lengte
36 bytes voor het worteladres, 36 karakters.
35 bytes voor het parameteradres, 35 karakters
1 byte voor 0, het scheidingskarakter
4 bytes voor het type
4 bytes gegevens
De bundel:
8 bytes voor “#bundle”
8 bytes voor de tijdseenheid
84 bytes voor elk bericht:
Met zes parameters te berekenen is dit dus 520 bytes. Een UDP datagram voor de
parameters van de rechthoek zal zo een vaste waarde van 548 bytes in beslag
nemen. De fysieke data die dan verstuurd wordt over de kabel is dan 574 bytes. Met
82
een maximum van 30 beelden per seconde is dit slechts 16 KiB per seconde. Dit kan
dus probleemloos verzonden worden via een netwerk of het internet zelfs met een
trage internetverbinding.
Elk adres van een parameter, het adres van de wortel, en de optie als het moet
verzonden worden of niet worden opgeslagen in het register en bij uitvoering eruit
gehaald.
De parameters voor de getekende rechthoeken, worden eveneens voorzien van een
adres en een waarde. Ze worden verpakt in een bundel van gehele getallen die 4
bytes beslaan, met waarden 1 of 0, en een bundel met zwevende getallen tussen 0
en 1, die eveneens 4 bytes bevatten. De lengte van een adres zal ook hier maximaal
35 zijn. Dus zal de lengte van één parameter ook 84 zijn. De waarden van de
getekende rechthoeken worden verzonden per 6. Zodat er maximaal 520 bytes data
verzonden worden over UDP. Zo houdt dit rekening met de MTU van 576 bytes. De
maximale waarde die kan doorgezonden worden. Deze staat bij alle systemen op
minimaal 576 bytes. De waarde van de buffer voor OpenSound Control wordt dan
ook ingesteld op de waarde 520.
MIDI
De andere externe data die we gaan verzenden is MIDI. Een MIDI signaal heeft
slechts 3 bytes. Een overzicht van de data:
MIDI-SIGNAAL (24 bit)
1 Actie (3) Kanaal (4) 0 Data1 (7) 0 Data2 (7)
De eerste bit is een 1. De volgende 3 bits zijn actie bits. Deze representeren een
actie. Note On, Note Off, zijn acties waarbij men een noot kan spelen op de
synthesizer, of een Control Change actie, waarbij parameters van pedaaltjes kunnen
ingesteld worden. Er zijn in totaal 8 van die types.
Het kanaal heeft 4 bits en gaat van 0 tot 15. Dit wordt meestal gebruikt om een
locatie aan te wijzen. De meeste MIDI apparaten beschikken over kanalen. Dit
kunnen specifieke instrumenten zijn, of gegevensbanken.
Er volgt een scheidingsbit 0 en dan zeven databits die een reikwijdte geven van 0 tot
128. De tweede groep heeft eveneens een scheidingsbit en data van 0 tot 128. In
83
vele gevallen stelt de eerste groep een noot voor, of toonhoogte, en de tweede groep
bits de snelheid, of volume waarmee ze gespeeld moet worden.
Er zijn ook speciale MIDI-signalen zoals de System Exclusive Messages. Ze dienen
voor speciale eigenschappen van specifieke apparatuur waarnaar het verzonden is
aan te passen. Deze beginnen met 11110000. Hierna volgt een speciale code van 7
bits die de producent van het apparaat identificeren. Ze kunnen meerdere databytes
in beslag nemen die met een 0 bit starten. De boodschap eindigt met 11110111.
Omdat de getekende rechthoeken voor controle dienen van muzikale parameters,
werd gekozen om de actie van de MIDI codes te beperken tot de Control Change
actie. De meeste apparaten ondersteunen deze functie. Handleidingen van de
apparaten voorzien een MIDI tabel, met uitleg welke codes gebruikt kunnen worden,
en op welke manier. Zowel het kanaal, en de eerste datagroep kunnen ingesteld
worden in een dialoogvenster. Deze datagroep staat voor het specifiek effect, of
instrument dat moet aangepast worden. De tweede datagroep is dan controleerbaar
door de bewegingen van de gebruiker.
Verzenden
Alle data wordt verwerkt in de klasse Sender. De klasse heeft zowel functies voor het
verzenden van zwevende komma getallen, als gehele getallen voor het OpenSound
Control. De klasse voorziet ook in de verbinding met een MIDI apparaat en het
zenden van MIDI signalen naar die apparaten. De invoer van de functies is een lijst
van ofwel de klasse OscParameterFloat, OscParameterInt, of een MIDI-signaal. De
eerste twee zijn gegevensstructuren die een waarde en een OpenSound Control
adres bevatten. De functies gaan volgens het zelfde principe tewerk: de OpenSound
Control buffer wordt geïnitialiseerd met een grootte van 520 bytes, en een bundel
wordt geopend. Hierin worden de parameters met hun adres opgeslagen en na
voltooiing van het aantal parameters wordt deze doorgezonden naar de externe
toepassing.
De Microsoft interface MCI werd gebruikt (Media Control Interface) voor het
verzenden van MIDI. Deze is op iedere installatie van Microsoft Windows aanwezig.
Eerst wordt er een connectie geopend, en dan wordt een geheel getal verzonden van
32 bits dat de MIDI code voorstelt. De laatste byte van deze 32 bit zijn dan ook
allemaal nullen. Nadat de Analyse afloopt wordt de connectie afgesloten.
84
De netwerkverbinding wordt opgesteld met behulp van de klasse Socket. Deze haalt
de poort en het adres uit het register. Dit adres kan een IP-adres zijn of een URL.
Vervolgens initialiseert deze de verbinding.
Optimalisatie van de code
Het programma moet zo snel mogelijk lopen om realtime interactie te kunnen
vrijwaren. Enkele methodes werden toegepast zowel in de compiler als in de code
om de uitvoering te versnellen. De snelheid van de code werd geprefereerd boven
het aantal instructies. Optimalisatie werd ingesteld voor Pentium 4 processoren en
de instructieset SSE2 werd gebruikt. Deze instellingen zijn gerelateerd aan de
compiler. De gebruiker van het programma heeft ook de keuze om de breedte van
het venster te verkleinen, zodat de analyse sneller kan verlopen. De referentie is
natuurlijk dat iedere analysestap moet doorlopen worden in 33 ms of 66ms. Of het
maximum aantal beelden per seconde van de gebruikte camera. Testen werden
gedaan op een Pentium 4 650 Prescott 3.4 Ghz, met 2 GB RAM. Dit kan aanzien
worden als een normaal tot redelijk sterk systeem op de commerciële markt.
Er werden twee testcases gedaan:
Een input beeld van 15 beelden per seconde met een resolutie van 320x240 en een
RGB24 diepte. En een input beeld van 15 beelden per seconde met een resolutie
van 640x480.
Sequentiële tests werden gedaan door het toevoegen telkens van een lijn code in de
callback functie om te kijken welke intensieve berekeningen verbeterd konden
worden.
De functie werd telkens getest na het verwerken van 5 beelden. Het gemiddelde van
50 waarden na elke 5 beelden werd berekend, en getoond op het scherm. Het
gemiddelde werd in de tabel gezet. De operatie werd uitgevoerd met volgende code: endtime=GetTickCount();
if (counter==5) { counter2++; tolerance=endtime-starttime; total+=tolerance; if (counter2==50) { CString format; format.Format("total: %d",total/50); AfxMessageBox(format,0,0); counter2=0; total=0; }
85
counter=0; } starttime=GetTickCount(); counter++;
Code toegevoegd
In: 320x240 15 fps RGB24 Out: 640x480
In: 320x240 15 fps RGB24 Out: 320x240
niets 35 ms 45 ms
Beeldformaat omzetten 52 ms 48 ms
Kleur omvormen 57 ms 49 ms
Beeld verticaal spiegelen 58 ms 49 ms
Achtergrond Median updaten 102 ms 57 ms
Verschil achtergrond origineel 107 ms 60 ms
Ruis weghalen met median filter (matrix van 3 op 3) 126 ms 63 ms
Getekende rechthoeken berekenen 122 ms 64 ms
Getekende rechthoeken
tekenen
127 ms 65 ms
Omsluitende Rechthoek tekenen 128 ms 65 ms
Parameters doorzenden 131 ms 66 ms
Beeld tonen 131 ms 66 ms
De code is gecumuleerd, dus er werd telkens een functie toegevoegd en gekeken
hoe lang de callback functie er over deed.
Het eerste dat opvalt is dat de output van 640x480 zorgt voor onnodige vertragingen.
Daarom wordt de maximale resolutie van de output op 320x240 ingesteld. Het
tweede dat opvalt is het groot verschil dat de update functie van de achtergrond
teweeg brengt. Alhoewel dit een snelle methode is, zorgt ze toch voor heel wat
rekentijd. Ook de median filter voor het weghalen van ruis is intensief, echter ook
onontbeerlijk. Het doet uitstekend zijn werk en is niet meer reduceerbaar dan 3
pixels.
Een tweede test is de test met 320x240 pixels input, 15 beelden per seconde, en de
twee achtergrond technieken. Median filtering en MoG. Volgende resultaten zijn
behaald, na verwerking van alle data.
86
Mixture of Gaussians 320x240 15 fps
Median Difference 320x240 15 fps
70 ms 66 ms
De niet-recursieve Median Difference methode blijkt hier veruit de snelste in de
berekening. De MoG zorgde voor niet veel overhead, maar haalt de beoogde 66 ms
niet. Daarenboven zorgde
Andere tests werden gedaan, zoals gezichtsherkenning, en optical flow
berekeningen. Code is terug te vinden op de Cd-ROM in bijlage, als commentaar. De
piramidale implementatie van het Lucas Kanade algoritme werd gebruikt voor de
optical flow te berekenen (Bouguet 1999). Haar classificaties werden gebruikt voor
de gezichtsherkenning (Lienhart et Maydt 2002). Lucas Kanade had geen
overdreven grote vertraging, maar haalde toch de benodigde 66 ms niet.
Gezichtsherkenning haalde snel minder dan 10 beelden per seconden.
Origineel Lucas Kanade Gezichtsherkenning
66 ms 74 ms 166 ms
8.1.4. Testen
De code werd getest met de debugger geïntegreerd in Microsoft Visual 2008 versie
9.0.21022.8. Voor compatibiliteit werd met behulp van de virtualisatiesoftware
VMWare een nieuwe installatie gemaakt van Windows XP, Windows 2000 Service
Pack4, en Windows Vista SP1. Windows XP Service Pack 2 en Windows Vista SP1
vertoonden geen problemen. Windows 2000 Service Pack 4 kan de applicatie niet
installeren omdat .NET framework 3.5 nodig is, en deze is niet compatibel met
Windows 2000. Er werd echter gezorgd voor een aparte installatie die wel werkt voor
Windows 2000. Andere voorwaarden zijn een installatie vant DirectX , en de resolutie
van de display moet tenminste 8 bit diepte hebben. Verder moet .NET framework 3.5
geïnstalleerd worden. Bij installatie van het programma wordt dit gedetecteerd, en
gedownload. De camera’s die getest werd waren voornamelijk webcams. Logitech
87
Quickam Communicate en Creative Webcam NX werden getest en doen het
uitstekend. Een externe camera verbonden via de videokaart werd ook getest. Dit
was een Sony DCR-HC40E, waarbij het analoog signaal van de camera werd
binnengetrokken in een ATI Radeon X850.
88
9. Toepassingen 9.1. Volledige lichaamsbeweging, convergente strategie
Een mogelijke piste is het traceren van volledige lichaamsbeweging. Er bestaan een
aantal bewegingstheorieën die expressieve bewegingen classificeren. De meest
gekende is die van Rudolf Laban, de theory of effort. Deze choreograaf had een
indeling voor specifieke bewegingen. De beweging kan als vector beschouwd
worden met vier waarden.
A. Ruimte: direct of indirect Hiermee wordt de ruimte beschreven waarin de persoon zich beweegt. Als
hij van punt a naar b gaat in een rechte lijn, is dit direct. Als hij veel van
richting verandert is dit indirect. Dit geldt voor de persoonlijke ruimte,
alsook de ruimte waarin het lichaam zich verplaatst. We kunnen dit
berekenen door stilstaande fasen te identificeren en tussen die twee
stilstaande fases te kijken hoeveel keer de persoon van richting verandert,
zowel horizontaal als verticaal.
B. Gewicht: sterk of licht De kracht die het lichaam moet uitoefenen bij een bepaalde beweging.
Springen, duwen of lopen is een voorbeeld van een sterk gewicht. Lichte
handelingen vergen niet veel kracht, voorbeelden zijn vallen, traag
wandelen, of staan. Hier is de situatie moeilijker. Springen, en lopen
hebben te maken met snelheid, en verticale en horizontale bewegingen.
Echter bepaalde poses, zoals spreidstand en andere zijn lastig voor het
lichaam, maar onbeweeglijk. Hier kunnen we echter stellen, dat de
breedte en hoogte hier voor instaan. Als het lichaam zeer breed gehouden
wordt, en niet hoog is dit een zwaar gewicht, indien het lichaam in normale
rusttoestand is, is de hoogte bij benadering vier keer de breedte. Springen
is een plotse versnelling van de hoogte van het lichaam, zowel onderaan
als bovenaan. Deze parameters zijn dus min of meer berekenbaar, zowel
als pose of momentaan, als over de tijd.
89
C. Tijd: plots of constant
Dit is de versnelling. Dit is eenvoudig berekenbaar. Tussen twee frames
kan de horizontale en verticale verplaatsing gemeten worden, of tussen
twee stilstaande fases kan de afstand tussen die twee en de tijd gemeten
worden, om zo een beeld te geven van de versnelling.
D. Flow: gebonden of vrij Dit is een parameter met betrekking tot de controle over het lichaam, en
de spanning. Een gebonden beweging is een beweging die een duidelijk
begin en einde geeft. Een vrije beweging zijn ongecontroleerde
bewegingen. De parameter is hoofdzakelijk afleidbaar uit de andere
parameters.
Het nodige materiaal voor deze mappingsstrategie is eenvoudig. Stilstaande fases
moeten herkend worden, en daartussen moet de hoogte en breedte van het
bewegend lichaam per frame berekend worden. Hierdoor volstaat het weghalen van
de achtergrond, met een snel aanpassend achtergrondmodel dat geen input geeft bij
stilstaande fases. Voor de twee dimensies, is een omsluitende rechthoek een nodige
zaak. Tot nu toe is slechts de gewichtsfactor geïmplementeerd voor poses.
De volgende classificaties en grenzen werkten op voorwaarde, dat de gebruiker het
middelpunt verticaal instelt van het lichaam met een cijfer tussen 0 en 1. En dat de
lichaamsbeweging gebeurt met de voeten bij het onderkant van het scherm. Verder
zijn alle waarden tussen 0 en 1. Het moet gezegd worden dat deze berekeningen
geenszins wetenschappelijk zijn onderbouwd, maar slechts een ruwe artistieke
interpretatie.
Verticale grootte: • 0 is geen grootte
• 1 is totale hoogte van het kader
Horizontale grootte • 0 is geen grootte
• 1 is totale breedte van het kader
Verticale positie • 0 is de ondergrens van het kader
• 1 is de bovengrens van het kader
Voor het lichaam werd de man van Vitrivius gebruikt, naar de tekening van Leonardo
da Vinci. Hier is in benadering de breedte van een persoon aan de schouders bij
90
stilstand ongeveer ¼ van de lengte van die persoon. Wanneer de man van Vitrivius
zijn armen strekt naast hem, is de verhouding tussen zijn verticale en horizontale
grootte bij benadering 1.
De berekeningen zijn dan als volgt:
Gewicht: • Type: Momentaan, dus bij berekening van één frame
• afhankelijke factoren: o horizontale grootte
o verticale grootte
o verticale positie
• Zeer zwaar (0.80 – 1)
o springen in spreidstand
verticale positie: 0.15 hoger dan middelpunt
verhouding grootte verticaal horizontaal < 1
• Zwaar (0.60-0.80)
o Springen met armen gestrekt
Verticale positie: 0.15 hoger dan middelpunt
Verhouding grootte verticaal horizontaal > 4
o Springen met armen gespreid
Verticale positie: 0.15 hoger dan middelpunt
Verhouding grootte verticaal horizontaal < 4
• normaal (0.40-0.60)
o twee ledematen gestrekt opheffen
Verticale positie: van 0.15 lager tot 0.15 hoger dan middelpunt
Verhouding grootte verticaal horizontaal < 2
o spreidstand
Verticale positie: lager dan 0.15 van middelpunt
Verhouding grootte verticaal horizontaal tussen 0.5 en 1
• licht: (0.20-0.40)
o één ledemaat opheffen
Verticale positie: van 0.15 lager tot 0.15 hoger dan middelpunt
Verhouding grootte verticaal horizontaal < 4 en > 2
o hurken
91
Verticale positie: lager dan 0.15 van middelpunt
Verhouding grootte verticaal horizontaal: tussen 1 en 2
• zeer licht: (0 – 0.20)
o Staan
Verticale positie: van 0.15 lager tot 0.15 hoger dan middelpunt
Verhouding grootte verticaal horizontaal tussen 4 en 5
o Liggen
Verticale positie: lager dan 0.15 van middelpunt
Verhouding grootte verticaal horizontaal < 0.50
Deze interpretaties kunnen gekoppeld worden aan een muzikale parameter. Volume,
of tempo zijn goede voorbeelden
Berekeningen werden geschreven, in de vorm van een extern object voor Max/Msp ,
dit gebeurde in C (zie bijlage).
9.2. Hulpmiddel voor muzikanten met instrument Een tweede toepassing is het regelen van externe of interne apparaten, die MIDI-
boodschappen aanvaarden. Dit zijn expliciete mappingsstrategieën die meestal één
naar één zijn.
Voorbeeld 1
Een gitarist kan bijvoorbeeld het programma gebruiken bij een optreden. De gitarist
heeft enkele digitale effectpedalen, maar op een bepaald moment komt hij voeten
tekort, of hij wil dit op een meer visuele manier uitdrukken, of hij wil meerdere
parameters tegelijkertijd veranderen van zijn effect. De gitarist kan dan het
programma gebruiken. Indien de effectpedaal gebruik maakt van MIDI, kan de
gitarist de gewenste MIDI-codes opzoeken in zijn handleiding. Enkele rechthoeken
tekenen met het programma, en een kleine monitor en webcam ergens op het
podium inbouwen. De gitarist kan een schuifbalk zo manipuleren door bijvoorbeeld
met zijn kop van zijn gitaar de schuifbalk te verduwen, of over het podium te lopen
(ook stereo effecten kunnen hiermee bekomen worden bijvoorbeeld). Op die manier
kan hij visueel en auditief aan het publiek zijn bewegingen mededelen.
92
Voorbeeld 2
Gelijkaardig hieraan is bijvoorbeeld het manipuleren van een synthesizer, door
bewegingen. Een performer kan schuifbalken tekenen met het programma en enkel
visueel parameters veranderen van een externe synthesizer. Hij kan zo een soort
onzichtbaar muziekinstrument maken. Een voorbeeld is te vinden in het Max/MSP
bestand “synth.pat” op de Cd-rom, de tekening “synth.drw” geeft een aantal
getekende rechthoeken die beïnvloed kunnen worden. Een hele simpele synthesizer
werd hiervoor gebouwd.
Voorbeeld 3
Een drummer kan triggers op bepaalde plaatsen instellen en tekenen met het
programma, en verbinden met samples. Hij kan zo in de lucht drummen, met of
zonder stokken.
9.3. Hulpmiddel voor elektronische muzikanten Met elektronische muzikanten bedoel ik hier performers waarbij geen fysiek
instrument aan de pas komt. DJ’s of laptopmuzikanten zijn hierbij een voorbeeld.
Deze muzikanten werken met muzikale tools op de computer zoals Ableton Live, of
misschien ook Max/MSP. Het houdt ofwel muziekgeneratie in ofwel het werken met
geluidsfragmenten.
Voorbeeld
Een laptopmuzikant werkt veel met samples. Om ze af te spelen drukt hij daarbij op
een knopje, op de computer ofwel op een apparaat dat verbonden is met de
computer. Om zijn performance visueel aantrekkelijk te maken kan hij echter ook dit
programma gebruiken om rechthoeken te tekenen en te verbinden met
geluidsfragmenten. Een voorbeeld is te vinden in de Max/MSP patch “sampler.pat’
op de CD-ROM, de tekening “sampler.drw” geeft een goed voorbeeld voor de
tekening. De bedoeling is dat men met vingers werkt van de hand om vier
geluidsfragmenten te laten afspelen. De geluidsfragmenten herhalen zich
voortdurend. Rechts staan rode rechthoeken die elk geluid kunnen afzetten. Door
vele vingers of slechts één op te heffen wordt het begin van een geluidsfragment
afgespeeld.
93
9.4. Muziek voor fysiek gehandicapte mensen Een fysiek gehandicapt persoon die niets kan bewegen zal natuurlijk met het
programma niets kunnen doen. Echter mensen die niet geheel verlamd zijn
beschikken over de mogelijkheid om triggers te tekenen, en met beweegbare delen
van hun lichaam input te voorzien, en muziek te maken.
Voorbeeld 1
Iemand die vroeger piano speelde, en nu vanaf de heup verlamd is, zou nu de
pedalen kunnen bedienen van een digitaal instrument dat MIDI aanvaardt door met
zijn hoofd te bewegen. Een getekende rechthoek links van hem kan de snaren
dempen of una corda spelen, en een andere rechthoek rechts kan de demping
opheffen van de snaren.
Voorbeeld 2
Rechthoeken kunnen getekend worden zodoende dat ze ook instaan voor de
specifieke handicap van de persoon. Op de oogleden kunnen triggers gezet worden,
voor bijna totaal verlamde personen, of voor fysiek gehandicapten die hun hoofd
kunnen bewegen kan men objecten tekenen rondom het hoofd waarbij zijdelings, en
op en neerwaartse bewegingen getraceerd kunnen worden.
94
10. Besluit In deze masterproef is er een mogelijke oplossing gemaakt voor het vervaardigen
van een muzikale controller aan de hand van videobeelden. Het programma kwam
vanuit de nood voor een alternatieve controle van muziek voor zowel performance
als andere doeleinden, zoals fysiek gehandicapte mensen, of het versterken van
muzikale expressieve bewegingen bij het bespelen van een instrument. Een
softwareprogramma werd hierbij geschreven die beelden afkomstig van een webcam
analyseert, om vervolgens de geanalyseerde data door te sturen naar een extern
muzikaal programma. Er werd vertrokken van een musicologisch analysekader voor
het opstellen van deze software. De globale werkwijze van het programma werd
uitgestippeld aan de hand van dit kader. De vervaardiging van de software werd
uitvoerig besproken, volgens de UML methode, en de gebruikte protocollen,
algoritmes werden getoetst aan de noden van het programma. Het programma werd
getoetst door enkele toepassingen te creëren., of te beschrijven.
Het softwareprogramma heeft nu een eerste versie, maar er zijn nog vele niet
uitgewerkte noden en ideeën voorzien. De implementatie van een volledige laban
analyse moeten nog geïmplementeerd worden. In een latere evolutie, en als de
hardware van modale commerciële systemen sufficiënt is zullen er meerdere
algoritmen geïmplementeerd worden voor nog betere controle. Het in realtime
detecteren van knipperende ogen, kan bijvoorbeeld zeer handig blijken voor fysiek
gehandicapte mensen, alsook het herkennen van de gewrichten van personen.
Testen bleken echter ver onder de eisen voor muzikale controle voor oogherkenning.
Ook de tekenmodule zal worden uitgebreid met meerdere vormen van objecten die
kunnen gemanipuleerd worden. Het tekenen van vrije lijnen als controle element kan
beter instaan voor de bewegingsradius van de mens. Objecten die een fysisch model
vertonen zoals op en neer kaatsende bollen kunnen ook interessant zijn. Het in
realtime tekenen van objecten moet ook geïmplementeerd worden. Ook een tijdslijn
zal geïmplementeerd worden, waarbij objecten zich over tijd veranderen van positie
of vorm. Zo kan men een muzikale partituur van objecten maken. Deze
implementaties kunnen de interactie van het systeem nog aanzienlijk verhogen. Een
evaluatie van de grafische interface staat ook op het programma. Alle modules en
95
opties zullen centraal in één kader gebracht worden, en de menu’s worden
weggelaten.
Het programma zal verleend worden aan muzikanten die daar interesse voor tonen,
met de hoop op feedback voor verbetering, en nieuwe muzikale toepassingen voor
het systeem.
96
Bijlagen Cd-ROM
De Cd-rom bevat volgende mappen
Source: • Visual Studio 2008 Project MovementAnalyzer
• Visual Studio 2008 Project DsCam
• Visual Studio 2008 Project Laban
• Het bestand ‘Readme.txt’ bevat alle informatie over externe bibliotheken
Setup • Een installatiebestand voor de toepassing voor het Windows Platform
• Een directory voor de installatie in Windows 2000
• Het bestand ‘Readme.txt’ met systeemeisen en benodigde instellingen
Toepassingen • ‘Synth.pat’ en ‘Synth.drw’ een synthesizer toepassing voor Max/MSP zoals
beschreven in hoofdstuk 9.2, Voorbeeld 1
• ‘VolumeControl.pat’ en ‘VolumeControl.drw’ een toepassing voor Max/MSP dat
het volume van een geluidsbestand controleert via een laban-analyse en ook
via MIDI. Zoals beschreven in hoofdstuk 9.1
• ‘Sampler.pat’ en ‘Sampler.drw’ een toepassing voor Max/MSP dat samples
afspeelt. Drums, en melodie zijn geïmplementeerd. Zoals beschreven in
hoofdstuk 9.3
• Enkele geluidsbestanden voor gebruik met de toepassingen.
• Twee bestanden: ‘laban.mxe’, en ‘OSC-route.mxe’, beide externals voor
Max/MSP. De ene berekent het gewicht zoals beschreven in hoofdstuk 9.1. De
tweede is een implementatie van OpenSound Control.
Masterproef • Deze tekst in pdf formaat
97
Referenties Benford, S., Schnadelbach, H., Koleva, B., Gaver, B., Schmidt, A., Boucher,
A.,Steed, A., Anastasi, R., Greenhalgh, C., Rodden, T., and Gellersen, H. (2003).
Sensible, Sensable and Desirable: a Framework for Designing Physical Interfaces,
[Online]. Technisch Rapport Equator-03-2003, Equator. Available at:
http://www.equator.ac.uk/var/uploads/benfordTech2003.pdf
Bouguet, J. (1999). Pyramidal implementation of the Lucas Kanade feature tracker:
Description of the algorithm [Online]. Technisch Rapport Intel Research
Laboratory. Available at: http://robots.stanford.edu/cs223b04/algo_tracking.pdf
Claeys, J. (2006). Gestuele interactieve systemen. Naar een technisch analysekader
voor extractie van expressieve bewegingen. Unpublished Thesis, Universiteit
Gent, Gent.
Friedman, N., Russel, S. (1997). Image segmentation in video sequences: A
probabilistic approach. In Proceedings of the Thirteenth Conference on
Uncertainty in Artificial Intelligence (UAI 97) (pp. 175-181). Providence: Brown
University.
Hunt, A., Kirk, R. (2000). Mapping Strategies for Musical Performance. In M. M.
Wanderley, M. Battier (Eds.), Trends in Gestural Control of Music, [CDROM].
Parijs: Ircam.
Johnston, W. M., Hanna, J. R. P., Millar, R. J. (2004). Advances in Dataflow
Programming Languages. ACM Computing Surveys, 36(1), 1-34.
KaewTraKulPong, P., Bowden, R. (2001). An Improved Adaptive background Mixture
Model for Realtime Tracking with Shadow Detection. In Proceedings of the 2nd
European Workshop on Advanced Video based Surveillance Systems (AVBS01)
(pp. 149-153). Kingston: Kingston University.
98
Laban, R., Lawrence F. C. (1974). Effort (2nd Edition). London: MacDonald and
Evans.
Lazzaro, J., Wawrzynek, J. (2006). RTP Payload Format for MIDI [Online], Available
at http://www.rfc-editor.org/rfc/rfc4695.txt [July 2008]
Lienhart, R., Maydt, J. (2002). An Extended Set of Haar-like Features for Rapid
Object Detection. In Proceedings of the 2002 International Conference on Image
Processing (ICIP 2002) (pp. 900-903). Rochester: IEEE.
Manning, P. (2004). Electronic and Computer Music. Oxford: Oxford University
Press.
Rovan, J. B., Wanderley, M. M., Dubnov, S., Depalle, P. (1997). Instrumental
Gestural Mapping Strategies as Expressivity Determinants in Computer Music
Performance. In A. Camurri (Ed.), Kansei, The Technology of Emotion.
Proceedings of the AIMI International Workshop, (pp. 68-73). Genoa:
Associazione di Informatica Musicale Italiana.
Sutherland, I. E., (1963). Sketchpad: A Man-Machine Graphical Communication
System. Ph.D. thesis, Department of Electrical Engineering MIT, Cambridge.
Sutherland, W. R., (1966). The On-Line Graphical Specification of Computer
Procedures, Ph.D. thesis, Department of Electrical Engineering MIT, Cambridge.
Winkler, T. (1997). Composing Interactive Music: Techniques and Ideas Using Max.
Cambridge: The MIT Press.
Wright, M., Freed, A., Momeni, A. (2003). OpenSound Control: State of the Art 2003.
In Proceedings of the 2003 Conference on New Interfaces for Musical Expression
(NIME-03) (pp. 153-159). Montreal: McGill University.
99
Andere:
$40 DIY Lemur (2008) [Online], Available at http://midimeek.blogspot.com/ [July
2008]
EyesWeb [Online], Available at: http://www.infomus.org/EywMain.html [July 2008]
FreeFrame Open Realtime Video Effects [Online], Available at
http://freeframe.sourceforge.net/ [July 2008]
JazzMutant – Lemur (2008) [Online], Available at:
http://www.jazzmutant.com/lemur_overview.php [July 2008]
Logitech Webcams en communicatie [Online], Available at:
http://www.logitech.com/index.cfm/webcam_communications/webcams/&cl=be,nl
[July 2008]
Macam: USB webcam support for Max Os X [Online], Available at: http://webcam-
osx.sourceforge.net [July 2008]
Monome (2008) [Online], Available at: http://www.monome.org [July 2008]
NI LabView [Online], Available at: http://www.ni.com/labview/ [July 2008]
Open Source Computer Vision Library [Online], Available at
http://www.intel.com/technology/computing/opencv/ [July 2008]
Peripheral MIDI Controller [Online], Available at http://pmidic.sourceforge.net [July
2008]
Pure:dyne [Online], Available at: http://code.goto10.org/projects/puredyne/ [July
2008]
100
Reactable (2008) [Online], Available at: http://reactable.iua.upf.edu/ [July 2008]
The Midi Specification (2006) [Online], Available at:
http://www.oktopus.hu/imgs/MANAGED/Hangtechnikai_tudastar/The_MIDI_Specifi
cation.pdf [July 2008]
The Webcam HOWTO [Online], Available at:
http://www.tldp.org/HOWTO/html_single/Webcam-HOWTO [July 2008]
Vvvv: a multipurpose toolkit [Online], Available at: http://vvvv.org/tiki-index.php [July
2008]
Webcam [Online], Available at: http://en.wikipedia.org/wiki/Webcam [July 2008]
101
