simpele beeldherkenning voor computer screenshots

[liquid_ice]

Sinds een paar maanden volg ik zangles en om mijzelf te helpen met het krijgen van feedback over mijn gekrijs gebruik ik een tool van Canta software.

Deze tool laat visueel zien wat je dient te zingen (qua tonen) en wat je daadwerkelijk zingt.


Wat ik nog mis is een soort score...
Dit wil ik gebruiken om m'n voortgang over tijd te kunnen meten.

Omdat ik niet zo snel een goede API heb kunnen vinden wil ik proberen vanaf het beeldscherm af te lezen.

Nou kan ik in C# screenshots maken en die zelf proberen te analyseren, maar ik vraag me af of er geen talen, frameworks of tools zijn die me kunnen helpen met het stukje beeldherkenning.

Ik heb al gegoogled, maar ik denk dat ik niet de juiste termen weet hiervoor omdat ik eigenlijk niks gevonden krijg.

[gekkie]

er zijn genoeg beeldherkennings frameworks .. bijvb openCV .. het levert je semi lowlevel tools waarmee je van alles kunt bouwen.

[EddoH]

Als de tekening die je gepost hebt ook daadwerkelijk is hoe het er in Canta uitziet zou je simpelweg het absolute verschil in y-coördinaten van de groene en rode pixels kunnen optellen.
Wel even de exacte rgb waardes uitzoeken, en voor de meting begint het 0-niveau bepalen (andere onderdelen van het scherm kunnen ook dezelfde kleuren bevatten).

[liquid_ice]

@Eddoh, het is inderdaad vrij basic.

de hele UI ziet er zo uit:


ik had dus ook als eerste idee om het op pixel kleuren te doen, maar voordat ik dat ga doen hoopte ik hier een andere mogelijkheid te vinden mbv bestaande tools.

[MSalters]

EddoH schreef op dinsdag 19 augustus 2014 @ 13:33:
Als de tekening die je gepost hebt ook daadwerkelijk is hoe het er in Canta uitziet zou je simpelweg het absolute verschil in y-coördinaten van de groene en rode pixels kunnen optellen.

Vrijwel iedereen gebruikt hiervoor het kwadraat van het verschil. Kleine fouten wil je significant minder zwaar laten wegen dan grote fouten.

[ValHallASW]

De source van Canta is ook gewoon beschikbaar: http://sourceforge.net/p/canta/code/HEAD/tree/trunk/ (wel in Ada en half in het Frans). Ik vermoed dat de sourcecode doorspitten (en desnoods gewoon waarden naar een tekstbestand te dumpen) sneller is dan beeldherkenning in C# op te zetten.

[ThaStealth]

Je moet zo te zien ook gebruik maken van een timeshift tussen de groene balk en de rode lijn. Zo te zien ben je net wat later met inzetten en stoppen van de noten dan het programma verwacht. Dus je moet niet de 2 lijnen direct met elkaar vergelijken.

[liquid_ice]

@ValHallASW: Jammer genoeg heb ik nooit opgelet bij de Franse les

MSalters schreef op dinsdag 19 augustus 2014 @ 17:33:
[...]
Vrijwel iedereen gebruikt hiervoor het kwadraat van het verschil. Kleine fouten wil je significant minder zwaar laten wegen dan grote fouten.

Al beter, maar je vergeet de zoom optie van Canta
De horizontale lijnen zijn steeds 1 noot.

Je moet het aantal pixels tussen de noten in tellen, dat gelijk stellen met 100 (of een random ander getal).
Dan weet je hoe zwaar 1 pixel afwijking telt.

(aantal pixels afwijking*zwaarte van de pixels)^2

Daarbij moeten dan ook de horizontale lijnen bekeken worden om te bepalen of de zanger een stabiele noot of juist heel onstabiel zingt

[EddoH]

MSalters schreef op dinsdag 19 augustus 2014 @ 17:33:
[...]

Vrijwel iedereen gebruikt hiervoor het kwadraat van het verschil. Kleine fouten wil je significant minder zwaar laten wegen dan grote fouten.

Bij een lineaire schaal zie ik in dit geval niet in waarom je dat zou willen doen eigenlijk...:)

[liquid_ice]

Ondanks dat ik het in eerste instantie eens was met MSalters, bedenk ik me nu dat je het misschien juist niet wilt.

Mijn doel is voortgang in de gaten houden.
Naar mate dat je beter wordt ergens in wordt de vooruitgang steeds minder.

juist dan wil je nog steeds kleine verbeteringen kunnen meten en zichtbaar maken.
Eigenlijk wil je een soort hyperbool, waarbij exact goed een hoop punten levert.
iets minder redelijk streng wordt afgestraft, maar het verschil tussen slecht en slechter maar weinig is.

[Opi]

Dan zou je in plaats van een kwadratische kostenfunctie een kostenfunctie kunnen overwegen die gebaseerd is op de wortel van de absolute waarde.

[Rannasha]

De precieze scorefunctie is natuurlijk slechts een bijzaak. Zodra je eenmaal de data uit het plaatje hebt gehaald kun je daar willekeurig welke functie op toepassen (of meerdere). De bottleneck zit hem in het verwerken van het plaatje.

[liquid_ice]

Dat klopt, waar ik met de bewerking het meest tegen opzie zijn aliasing en kleur effecten..

Dat is ook de reden dat ik eens hier kom vragen voor bestaande oplossingen.

als het op pixel niveau duidelijk pixel[x] = kleurA en pixel[x+1] = kleurB is, dan is het simpel...

Maar waarschijnlijk past de grafiek niet exact in het pixel raster en doet de videokaart meerdere pixels ongeveer de kleur geven. Dat maakt het vervelend.

[Caelorum]

Dan doe je er een eerste pass overheen waar je de kleuren absoluut maakt of iets dergelijks. Dus pixel > rgb(0.8,0,0) = rgb(1.0,0,0) enz. en doe je daarna je berekeningen. Gewoon 1e pass dus terugbrengen tot 3 zaken: achtergrond, band en lijn. Zou niet al te moeilijk moeten zijn.

[ Voor 29% gewijzigd door Caelorum op 20-08-2014 13:43 ]

[EddoH]

Ik zou het gewoon zo simpel mogelijk houden, het gaat hier niet om exacte berekeningen, maar om het globaal zien van je progressie.

Begin nou eerst eens met heel basaal een loop die het verschil tussen 2 exacte pixelwaardes berekent over een bepaalde x range. Grote kans dat gewoon goed genoeg is voor het doel wat je voor ogen hebt. Die aliasing is allemaal niet significant. Desnoods doe je er inderdaad een simpele threshold pass overheen.

[HuHu]

Doe eerst een color decomposition, waarbij je het kleurenbeeld splitst in afzonderlijke kanalen. In het groen-kanaal zit je doel en in het rood kanaal je meting.

Doe daarna een morphological erosion in de y-richting (boven naar beneden), om de horizontale strepen te verwijderen uit je beeld.

Vervolgens bepaal je per kolom in de y-richting de eerste en laatste pixel met een grijswaarde > 10 (bijvoorbeeld). Precies in het midden (ymin + ymax)/2 is je meetpunt.

Al deze stappen doe je voor zowel groen als rood. Vervolgens bepaal je voor elk rood punt waar het dichtstbijzijnde groene punt ligt (eenzijdige hausdorff distance, implementeer snel met een nearest neighbour search in een kd-tree). Dit is je "fout". Kwadrateren, wortelen, enz... hier kun je een leuke fout-functie van maken.

Eenvoudige stappen die je zo kunt implementeren.

[_360_]

Ik heb goede ervaringen met AForge.Net.

AForge.NET is an open source C# framework designed for developers and researchers in the fields of Computer Vision and Artificial Intelligence - image processing, neural networks, genetic algorithms, fuzzy logic, machine learning, robotics, etc.

Deze bevat een Image processing library, waarbij je veel zaken out-of-the-box cadeau krijgt.
Bijvoorbeeld blob / shape detection en een behoorlijk aantal image filters.

linkje:
Detecting some simple shapes in images

[Zoijar]

Ik zou het veel simpeler doen. Scan van boven naar beneden naar een rode pixel per column. Sla (x,y) coordinaten op. Interpoleer y voor ontbrekende x waardes. Doe dat voor rode en blauwe pixels. Loop je twee array door met fixed x, som sqr(y2-y1) en deel door aantal. Done.

Dan krijg je wat situaties van ik heb meer rode/blauwe pixels: middel de y waarde dan.

Waarschijnlijk wil je trouwens geen pure MSE, maar wil je het inverse wegen op je slope oid: bij transities is je error niet zo belangrijk; het is moeilijk een step-functie te zingen.

Punt is dat je het niet als 2d image moet zien, maar een collectie van 1d columns. Dan kan je wat missende data in die set hebben, maar als je dat interpoleert gaat het volgens mij altijd goed.

[ Voor 49% gewijzigd door Zoijar op 20-08-2014 18:48 ]

[ValHallASW]

Ik ben toch nog even op de ada-tour gegaan -- ik blijf erbij dat image processing idioot is als je de data gewoon digitaal beschikbaar hebt ;-) Het is me nog niet gelukt om Canta te compileren, maar hier een paar pointers:

1. Download de source uit mijn clone: https://github.com/valhallasw/canta -- dat is de 1.11 tarball met fixes zodat het bijna te compileren is op GNAT 2014.
2. Download GNAT 2014 en win32ada van http://libre.adacore.com/
3. Open canta.gpr
4. Compile alles, en eindig met:

code:

gcc.exe: error: C:\Users\Merlijn van Deen\Documents\GitHub\canta\\..\obj_dbg\win_resources.o: No such file or directory

Die win_resources.o zou uit een win_resources.ads/.adb gegenereerd moeten worden, maar die lijkt niet in de repository te hangen. Ik heb de auteur een mailtje gestuurd -- ben benieuwd wat daar uitkomt.

[ValHallASW]

De auteur reageerde snel, en er bleek inderdaad wat info te missen: de win_resources.o moet je zelf genereren uit canta.res. Enfin, dat heb ik nu gedocumenteerd en ik heb wat met de code gespeeld. Die is, moet ik zeggen, niet heel gemakkelijk te doorgronden. Ik heb wat geklooid in de buurt van de code die de grafiek updatet -- het is me nu gelukt om de midi-info te krijgen, maar de stemcurve heb ik nog niet te pakken.

Zie https://github.com/valhallasw/canta/compare/liquid_ice voor wat ik gedaan heb;

Voor builden: zie mijn post hierboven en de readme: https://github.com/valhallasw/canta/blob/master/readme.md

[gekkie]

https://github.com/valhal...ter/src/affichage_pkg.adb .. rond lijn 225 ...lijkt me het tekenen van de rode lijn

[ValHallASW]

gekkie schreef op donderdag 21 augustus 2014 @ 21:42:
https://github.com/valhal...ter/src/affichage_pkg.adb .. rond lijn 225 ...lijkt me het tekenen van de rode lijn

Nee, dat is het spectrum, maar het idee van naar 'rouge' zoeken is natuurlijk wel een goede! Ik had twee variabelen door elkaar gehaald -- ik had last_mes_pt (de laaste 'mesure' = maat) ipv last_note_pt (de laatste 'note chantée' = gezongen noot) geprint.

Enfin, het werkt nu, met twee details: 1) als de muziek ophoudt dan blijft de laatste midi-toon nog even hangen -- die wordt immers nog steeds ergens links in het scherm getoond. 2) er is nog geen output naar een bestand, maar dát zou nu niet zo moeilijk meer moeten zijn -- zélfs in ada ;-)

[gekkie]

ValHallASW schreef op donderdag 21 augustus 2014 @ 22:03:
[...]
maar dát zou nu niet zo moeilijk meer moeten zijn -- zélfs in ada ;-)

Klinkt in iedergeval beter en betrouwbaarder en idd gemakkelijker dan beeldherkenning
Nouja een beter voorbeeld dat opensource handig kan zijn is er toch niet zou ik zo zeggen

[RobIII]

Kom toevallig net dit tegen: http://arohatgi.info/WebPlotDigitizer/
Misschien heb je er iets aan, misschien niet

Ik had in ieder geval binnen 2 minuten dit resultaat:

...en er nog nooit eerder mee gewerkt

Having said that: ik zou inderdaad niet de image-processing route kiezen maar gaan voor de rauwe data

[ Voor 63% gewijzigd door RobIII op 10-09-2014 21:11 ]

[BoringDay]

liquid_ice schreef op dinsdag 19 augustus 2014 @ 12:41:
Sinds een paar maanden volg ik zangles en om mijzelf te helpen met het krijgen van feedback over mijn gekrijs gebruik ik een tool van Canta software.

Deze tool laat visueel zien wat je dient te zingen (qua tonen) en wat je daadwerkelijk zingt.
[afbeelding]

Wat ik nog mis is een soort score...
Dit wil ik gebruiken om m'n voortgang over tijd te kunnen meten.

Omdat ik niet zo snel een goede API heb kunnen vinden wil ik proberen vanaf het beeldscherm af te lezen.

Nou kan ik in C# screenshots maken en die zelf proberen te analyseren, maar ik vraag me af of er geen talen, frameworks of tools zijn die me kunnen helpen met het stukje beeldherkenning.

Ik heb al gegoogled, maar ik denk dat ik niet de juiste termen weet hiervoor omdat ik eigenlijk niks gevonden krijg.

Je kan de bitmap uitlezen en met behulp van scan line en pixel coordinaten zien welke kleur op welke positie is. De werking van een bitmap staat in feite volledig uitgelegd op msdn.
http://msdn.microsoft.com...op/ms536298(v=vs.85).aspx

Daarnaast zijn er vast wel zat frameworks die met afbeeldingen over weg kunnen en allerlei nuttige functionaliteiten hebben.

http://www.codeproject.co...Image-Processing-Lab-in-C