Obligatoriska uppgifter i MATLAB

Obligatoriska uppgifter i MATLAB Introduktion Följande uppgifter är en obligatorisk del av kursen och lösningarna ska redovisas för labhandledare. Om ni inte använt MATLAB tidigare är det starkt rekommenderat att ni först löser övningsuppgifterna i övningshäftet "En kort introduktion till MATLAB" innan ni börjar lösa de obligatoriska uppgifterna. Övningsuppgifterna innehåller lerådar och delmoment som det är bra att känna till för att enklare kunna lösa de obligatoriska uppgifterna. Kort om uppgifterna Uppgift 1: Här ska ni manipulera en bild med hjälp av MATLAB. Syftet med uppgiften är att ni ska öva på att indexera och manipulera vectorer och matriser, vilket är viktigt för att kunna använda MATLAB eektivt. Uppgift 2: Här ska ni öva felsökning. Ni får ett nästan fungerande program som ni ska xa till. Delar av lösningen till uppgift 2 kommer sedan att kunna användas som stöd när ni löser uppgift 3. Uppgift 3: Här ska ni använda matlab för att simulera rörelsen hos en satellit i omloppsbana. Redovisning Följande resultat ska redovisas för labbhandledaren: Uppgift 1: Visa den slutgiltiga bilden. Uppgift 2: Visa att programmet fungerar genom att köra med de parametervärden som anges i uppgiften. Uppgift 3: Visa de två gurerna på satellitbanan som jämför de olika algoritmerna. 1

Uppgift 1: Bilder och Vektorindexering En bild består av ett antal färgade punkter, pixlar, arrangerade i ett rutnät. Det vanligaste sättet att beskriva färger i digitala bilder är RGB-format, det betyder att färgen på en pixel beskrivs som en blandning av de tre färgerna röd, grön och blå. Varje pixel kommer därför att vara en vektor med tre komponenter [R, G, B] där varje komponent anger intensiteten av respektive färg. I bilden vi kommer att jobba med kommer intensiteterna vara skalade så att de ligger i intervallet 0 till 1 där 0 betyder ingen intensitet och 1 full intensitet. Så om vi tex vill ha en klarröd pixel sätter vi färgen till [1, 0, 0] medan tex [0.5, 0, 0] skulle vare en mörkare röd nyans. Andra färger kan fås genom att variera de olika intensiteterna tex magenta=[1, 0, 1] eller gul=[1, 1, 0]. Svart får vi genom att sätta alla intensiteterna till noll dvs [0, 0, 0]. Vitt ges av att sätta alla intensiteter till 1 dvs [1, 1, 1]. För att omvandla en färgbild till gråskala måste vi väga ihop de tre färgkomponenterna [R, G, B] till en gemensam intensitet Y. Detta går att göra på era olika sätt, men för att få en bild som ser naturlig ut måste vi ta hänsyn till att det mänskliga ögat inte är lika känsligt för alla färger. En vanlig formel för att omvandla från färg till gråskala är Y = 0.299R + 0.587G + 0.114B (1) där koecienterna är anpassade för att matcha ögats känslighet för de olika färgerna. Vi ser bland annat att ögat är mycket känsligare för grönt än för blått ljus. För att omvandla en RGB bild till gråskala måste vi omvandla färgen på varje pixel så att [R, G, B] [Y, Y, Y ]. Grundläggande bildhantering i MATLAB För att öppna en bild i MATLAB använder vi funktionen, imread, som returnerar en heltalsmatris med bilddata, för att sedan omvandla bilden till en vanlig yttalsmatris och skala om intensiteterna använder vi double. Följande två rader kan användas för att öppna en bild och omvandla den till rätt format: img=imread('filnamn.jpg','jpg'); %load image img=double(img)./255; %convert to double and rescale Variabeln img kommer nu vara en tredimensionell vektor med dimensionerna Y X 3, där X och Y är storleken på bilden i x- respektive y-led, och den sista dimensionen med 3 element motsvarar de tre färgkomponenterna. Om vi vill veta färgen på pixeln med positionen x,y kan vi komma åt den genom img(y,x,:) vilket listar de tre färgkomponenterna i den pixeln. Vill vi komma åt bara en av komponenterna kan vi skriva img(y,x,3) som bara returnerar den blå komponenten av färgen. MATLAB kan rita upp bilden med kommandot image, så för att kontrolera hur bilden ser ut skriver vi image(img); 2

Uppgift Den här uppgiften går ut på att öppna och manipulera en bild i MATLAB. Uppgiften ska lösas helt utan att använda loopar. Använd :-operatorn för att välja ut och manipulera rätt element i bilden. Skriv en eller era M-ler som utför deluppgifterna (a) till (i) nedan. Ett tips är att rita upp bilden efter varje steg så ni är säker på att ni gjort rätt innan ni går vidare till nästa steg. a) Öppna bilden test.jpg och omvandla till rätt format. b) Skriv en funktion new_img=flip_image(img,direction), som tar en RGBbild img vänder den och ger tillbaka en ny bild new_img som är antingen en spegelvänd eller en upp- och nervänd version av den ursprungliga bilden. Värdet på variabeln direction bestämmer hur den nya bilden ska vändas. Om direction=1 så ska bilden vändas upp och ner och om direction=0 så ska bilden spegelvändas. c) Skriv en funktion grayrgb=make_gray(colorrgb) som tar en färgbild colorrgb och omvandlar den till gråskala enligt formel (1) ovan. Den slutgiltiga bilden grayrgb ska vara i gråskala men formatet ska fortfarande vara en giltig RGBbild med dimension y x 3. d) Skriv en funktion small=shrink(large,scale) som tar en RGB-bild large och krymper den till en mindre bild small. Variabeln scale bestämmer hur mycket vi ska krympa bilden. Vi använder en enkel algoritm för att krympa bilden, om scale=1 ska den nya bilden vara lika stor som originalet, om scale=2 ska den nya bilden innehålla varannan pixel (i både x och y-led) från ursprungsbilden och för scale=4 ska den inehålla var fjärde pixel osv. e) Använd funktionerna make_gray och shrink för att göra en miniatyr i gråskala av bilden test.jpg, använd scale=3. f) Öppna bilden puzzle.jpg och omvandla till rätt format. g) Bilden utgör ett lätt pussel. Flytta om delarna i pusslet så att ni får en hel bild, och använd funktionen flip_image för att vrida dem rätt. Tips: börja med att skapa en ny tom bild med funktionen zeros, och ytta sedan över en bit i taget från pusselbilden. h) Infoga bilden som ni gjorde under punkt (e) i det övre högra hörnet på den lösta puzzelbilden. i) Spara den slutgiltiga bilden som en ny bildl med hjälp av kommandot imwrite. 3

Uppgift 2: Felsökning, simulering av kastbana I den här uppgiften ska ni öva felsökning, det nns ett nästan färdigt program som tyvärr inte fungerar som det ska. Det är er uppgift att få det att fungera. Uppgift Koden ni ska jobba med nns i len bounce.m. När programmet fungerar som det ska simulerar det en boll som faller och studsar på ett golv. Det nns ett mål som bollen ska träa. Om bollen träar målet returnerar funktionen 1 annars returnerar den 0. Koden är ganska väl kommenterad så läs kommentarerna och försök lista ut vad som blir fel. Läs MATLABs felmeddelanden, de ger information om vad som behöver xas. Om ni använder MATLABs inbyggda editor kommer den att markera era av felen redan innan ni kört programmet, kolla om ni ser några röda understrykningar i editorn. Men tänk på att editorn inte alltid markerar rätt saker, ibland kan ett fel på en rad lura editorn att tror att det är fel på andra ställen runt omkring, även om de raderna egentligen är riktiga. Använd gärna breakpoints och stega er genom programmet rad för rad för att lättare se vad som blir fel. Ni kan testa om funktionen fungerar som den ska genom att anropa den med följande parametrar >>bounce(0,10,1,0,7.600,1.695) Fungerar allt som det ska så ska bollen träa målet och funktionen ska returnera 1. Algoritmen som används för att simulera bollens rörelse är Eulers explicita metod, det är en stegningsmetod som beräknar bollens nästa position utifrån dess nuvarande position och hastighet. En mer noggrann förklaring av metoden nns i Bilaga 1 för den som är intresserad. 4

Uppgift 3: Simulering av satellitbana Vi ska simulera rörelsen hos en satellit som går i omloppsbana kring jorden. Simuleringen ska genomföras med två olika algoritmer. Det kommer att visa sig att valet av algoritm spelar stor roll för vilket resultat vi får. Beskrivning av systemet v 0 (0, 0) r 0 (r 0, 0) Figur 1: Startpositionen för satelliten vid t = 0 Vi ska lösa satellitens rörelse i två dimensioner och för att göra problemet enklare att hantera antar vi att jorden är mycket tyngre än satelliten så vi kan försumma satellitens påverkan på jordens rörelse. Vilket betyder att jorden kommer ha en x position (0, 0). Medan satellitens position, (x, y), varierar med tiden. Vid tiden t = 0 benner sig satelliten i punkten (r 0, 0) och rör sig med hastigheten (0, v 0 ), se gur 1. y F x (x, y) r F F y x Figur 2: Kraftsituationen vid en goycklig tid. Gravitationskraften F mellan jorden och satteliten ges av F = G Mm r 2, (2) där G är gravitationskonstanten, M är jordens massa, m är satellitens massa 5

och r är avståndet mellan jordens centrum och satelliten och ges av r = x 2 + y 2. (3) För att kunna använda kraften i simuleringen måste den komposantuppdelas, så vi vet hur mycket av kraften som verkar i x- respektive y-riktningen. Figur 2 visar kraft komposanterna. Vi får då F x = F x r, (4) F y = F y r. (5) Från kraften kan vi sedan räkna ut accelerationen med hjälp av Newtons andra lag a = F m och om vi komposantuppdelar accelerationen får vi (6) a x = GM x r 3, (7) a y = GM y r 3. (8) Vi ser att rörelsen hos satelliten är oberoende av satellitens massa m. Eftersom vi vet accelerationen kan vi ställa upp stegningsekvationer för Eulers explicita metod precis som i uppgift 2, x i+1 = x i + v xi y i+1 = y i + v yi v xi+1 = v xi + a xi v yi+1 = v yi + a yi enda skillnaden nu är att a x och a y inte är konstanter och därför måste räknas ut i varje tidsteg. I övrigt kommer koden att till stor del likna lösningen från uppgift 2. Indexet i visar vilket tidsteg en varje term tillhör. För mer detaljer om Eulers explicita method se bilaga 1. Ett tips är att implementera a x, a y och r som tre anonyma funktioner med hjälp av @-operatorn. Tyvärr kommer vi märka att Eulers explicita metod inte är tillräckligt bra för att använda till satellitbanor, metoden är instabil och ger lösningar som liknar spiraler istället för slutna banor. För att få stabila banor behöver vi en annan metod, det visar sig att vi kan få en bättre lösning genom att bara göra en liten förändring av stegningsekvationerna, x i+1 = x i + v xi y i+1 = y i + v yi v xi+1 = v xi + a xi+1 v yi+1 = v yi + a yi+1 (9) (10) Ser ni skillnaden? Den nya metoden kallas Eulers semi-implicita metod och är betydligt stabilare än den explicita metoden. Den nya metoden är fortfarande inte tillräcklig om vi behöver riktigt exakta resultat, men den duger för den här jämförelsen. Varför de två algoritmerna beter sig så olika har vi tyvärr inte tid 6

att gå in på här. Det viktiga för den här uppgiften är bara att testa dem och se vilken skillnad det blir. För att få siror som är enkla att jobba med, anger vi alla avstånd i jordradier (jr) och tider i timmar (h). Då får konstanten GM värdet Uppgift GM = 3.99 10 14 36002 6.38 10 6 = 19.93jr3 /h (11) Uppgiften är att simulera en satellitbana med två olika algoritmer och se vilken skillnad det blir. a) Skriv en funktion [x,y,t]=orbit_unstable(r0,v0,tmax,) som simulerarar en satellit i omloppsbana runt jorden med Eulers explicita metod, enligt beskrivningen ovan. Där r0 anger avståndet mellan jorden och satelliten och v0 anger satellitens hastighet vid t = 0. Simuleringen ska köras från t = 0 till t =tmax med tidsteg med längd. För varje tidssteg ska satellitens position (x, y) och tiden t sparas i vektorer. Funktionen returnerar tre vektorer x,y och t. b) Skriv en funktion [x,y,t]=orbit_stable(r0,v0,tmax,), som fungerar precis som den tidigare men som istället använder Eulers semi-implicita metod. c) Skriv en en m-l som kör de båda simuleringarna med följande parametrar: r0=2, v0=4, tmax=1000, =0.01. Rita upp satellitbanorna från de båda metoderna i var sin gur så att vi lätt kan jämföra resultatet. (Alternativt kan ni rita båda i samma gurfönster med hjälp av subplot.) Extrauppgift: (ej obligatorisk) Båda algoritmerna ska ge samma lösning om är tillräckligt litet. Testa att köra orbit_unstable och orbit_stable med följande parmetrar r0=2, v0=4, tmax=100. Testa olika värden på, och se hur resultatet förändras. 7

Bilaga 1: Föremål i rörelse och Eulers explicita metod Antag att vi har ett föremål med position x, hastighet v och acceleration a. Vi vill beräkna hur föremålets position förändras över tiden, vi vet föremålets position och hastighet vid tiden t = 0. Accelerationen hos ett föremål beskrivs av Newtons andra lag F = ma a = F m, (12) där F är kraften som påverkar föremålet, m är föremålets massa och a är föremålets acceleration. Accelerationen denierats som andraderivatan av positionen a = d2 x 2. (13) Om vi känner till accelerationen (eller kraften) kan vi alltså lösa ovanstående differentialekvation och se hur positionen x varierar med tiden. För vissa problem går ekvationen att lösa för hand, men för mer avancerade problem eller problem med många föremål som rör sig samtidigt är enda lösningen att använda datorhjälpmedel. Det nns många olika algoritmer för att lösa den här typen av problem, algoritmerna har olika egenskaper och en viss algoritm fungerar oftast inte till alla typer av problem. Vi ska nu härleda en av de enklaste algoritmerna, Eulers explicita metod. Den är enkel att förklara men metoden har många brister och lämpar sig ofta inte till mer avancerade problem. Vi börjar med att skriva om ekvationen ovan, vi vet att hastigheten är förstaderivatan till positionen v = dx, (14) och att accelerationen är förstaderivatan till accelerationen a = dv, (15) så dessa två ekvationer tillsammans innehåller samma information som ekvation (13) ovan. Problemet som ska lösas är alltså { dx(t) dv(t) = v(t) = a(t) (16) där initialvärden x(0) = x 0 och v(0) = v 0 är kända, och a(t) är en känd funktion. Nästa steg är att skriva om derivatorna på en form som är lättare att hantera numeriskt. En derivata till exempel dx(t) beskriver hur snabbt en funktion (i det här fallet x(t)) förändras per tidsenhet, vilket är samma sak som att beräkna lutningen på kurvan x(t) vid tiden t. När vi löser problem numeriskt med dator är det ofta svårt att jobba direkt med exakta derivator, istället inför man olika typer av approximationer som gör probelmet lättare att hantera. Beroende på hur man approximerar derivatorna får man olika algoritmer med olika egenskaper. I det här fallet utgår vi från denitionen av derivatan och approximerar förändingen i x(t) genom att beräkna lutningen mellan två punkter på kurvan dx(t) x(t + ) x(t) 8 (17)

där är ett kort tidsintervall, ju mindre är desto bättre blir approximationen. Vi kan använda den här approximationen för at skriva om den första ekvationen, dx(t) x(t + ) x(t) = v(t) = v(t) (18) Vi vet att om 0 så stämmer ekvationen exakt, så om vi väljer tillräckligt litet kommer felet också att bli litet. Vi löser alltså inte längre den ursprungliga ekvationen, men genom att välja ett tillräckligt litet värde på kan vi komma väldigt nära den riktiga lösningen. Nu kan vi ytta om termerna i ekvationen och få x(t + ) x(t) = v(t) x(t + ) = x(t) + v(t) (19) Vi ser att vi har en formel som låter oss räkna ut x(t + ) om vi vet x(t) och v(t), dvs om vi vet var vi är vid t = 0 kan vi räkna fram var vi kommer vara längre fram i tiden. För att det här ska fungera måste vi göra samma trick med att skriva om derivatan även för den andra ekvationen dv(t) = a(t) v(t + ) v(t) = a(t) (20) v(t + ) v(t) = a(t) v(t + ) = v(t) + a(t) (21) Vi har nu två uppdateringsrelationer; en för positionen och en för hastigheten { x(t + ) = x(t) + v(t) (22) v(t + ) = v(t) + a(t) Dessa två relationer kan användas för att stega fram i tiden. Varje gång de används hoppar man ett framåt i tiden. Så om man känner till x(0) men vill veta x(10) så måste man alltså iterera de ovanstående relationerna 10/ gånger. Det vi har gjort är att vi har diskretiserat problemet; vi har inte längre en kontinuerlig funktion x(t) utan en serie punkter x 0, x 1, x 2,..., x i som approximerar funktionen x(t). Uppdateringsrelationer som ovan skrivs därför ofta utan tidsvariabeln och istället använder man i (t = i) för att markera vilket tidsteg man är på. Där i är det nuvarande tidsteget och i + 1 är nästa tidssteg. { xi+1 = x i + v i (23) v i+1 = v i + a i Dessa relationer beskriver rörelsen för ett föremål i en dimension, ofta har man föremål som kan röra sig i två eller tre dimensioner. Om vi har en tvådimensionell rörelse beskrivs positionen av två koordinater (x, y), vi får då också två hastighetskomponenter (v x, v y ) och två accelerationskomponenter (a x, a y ). Eftersom x och y riktningen är vinkelrät mot varandra så blir rörelsen i x och y led oberoende, och vi kan behandla y och v y på samma sätt som vi tidigare gjort med x och v x, vilket ger totalt fyra uppdateringsrelationer: x i+1 = x i + v xi y i+1 = y i + v yi v xi+1 = v xi + a xi v yi+1 = v yi + a yi (24) 9