Rumlige figurer - Main Page - rtgkom.dk

Rumlige figurer

Matematik A og Programmering C - projekt

Projektopgave bearbejdet af:
Navn: Rami Kaddoura og Safa Sarac
Fag: Matematik og Programmering
Vejledere: Karl Bjarnason og Jørn Bendtsen
Skole: HTX, Roskilde Tekniske Gymnasium

Klasse: 3.4
Udleveringsdato: 12. september.2011

Afleveringsdato: 10. oktober.2011

Indhold

1. Abstract ............................................................................................................................................3
2. Indledning ........................................................................................................................................4
3. Den rumlige figur .............................................................................................................................5

3.1 Valg af figur ................................................................................................................................5
3.2 Krav til figuren............................................................................................................................5
3.3 Funktionsudtryk .........................................................................................................................6

3.3.1 Løsningsmodeller ................................................................................................................6
3.3.2 Sinus-funktionsudtryk f(x)...................................................................................................7
3.3.3 Andengradsfunktionsudtryk g(x) ........................................................................................8
3.3.4 Cirkel-funktionsudtryk c(x) (foreløbigt) ............................................................................11
3.3.5 Lineær-funktionsudtryk h(x) .............................................................................................12
3.3.6 Cirkel-funktionsudtryk c(x) (endelig) ................................................................................14
3.3.7 Opsummering af funktionsudtrykkene.............................................................................16
3.4 Længdesnit og rumfang af omdrejningslegemet.....................................................................17
3.4.1 Bestemmelse af længdesnit..............................................................................................17
3.4.2 Bestemmelse af rumfang ..................................................................................................17
4. Programmeringsdelen....................................................................................................................19
4.1 Kravspecifikation (generel) ......................................................................................................19
4.2 Info om Python.........................................................................................................................20
4.2.1 Design................................................................................................................................20
4.2.2 Implementering i vPython ................................................................................................20
4.2.3 Test....................................................................................................................................21
4.3 Info om Lazarus ........................................................................................................................22
4.3.1 Design................................................................................................................................22
4.3.2 Implementering i Lazarus..................................................................................................23
4.4 Endelige test.............................................................................................................................25
4.5 User Stories ..............................................................................................................................26
5. Konklusion......................................................................................................................................27
Bilag 1- Introduktion til systemudviklingsmetoden ...........................................................................28
Bilag 2 – Python kildekoder ...............................................................................................................29
Bilag 3 – Lazarus kildekoder...............................................................................................................30

2

1. Abstract

The point of this project was to select an object which can be described using mathematical
function expressions. The mathematical function expressions that were set should reflect the
academic level at 3rd year. The project also went out on calculating the length and volume of the
object, to give a clear impression of its physical size. The empirical data that we had in the
calculation of volume and length were processed by the help of differential calculus and integral
calculus. An important part of the project was the programming part, which was to visualize the
object in 3D format. The graphical interface was created in Lazarus and also in Python with the
visual module for this purpose. The point of using Lazarus is to be able to enter different variables
in our expressions, and in that way the program is able to visualize it using vPython.

3

2. Indledning

Denne tværfaglige projektopgave er lavet i samarbejde med fagene Programmering C og
Matematik A.
Rapporten er bearbejdet af to 3. års elever studerende på det tekniske gymnasium, HTX, i
Roskilde. I forbindelse med fagene Programmering og Matematik, har vi fået til opgave at designe
en rumlig figur, lave matematiske beregninger på denne, samt lave en grafisk brugerflade som
visualiserer vores figur i 3D. En nærmere analyse dokumentation af matematikdelen og
programmeringsdelen oplyses i de kommende afsnit.
Vi har i gruppen valgt at være beskæftigende med en el-pære. Vi skal lave matematiske
beregninger og programmere en 3D figur af el-pæren i programmeringssproget Python. Den
grafiske brugerflade laver vi i et andet programmeringssprog, nemlig Lazarus. Programmet i
Lazarus skal sørge for en ændring af en variabel i selve koden i Python, og samt vise et billede af
figuren med den variabel der er blevet ændret.
Rapportstrukturen er lavet ud fra de generelle krav for projektopgaver i matematik samt
systemudviklingsmetoden i programmering. På den måde kan vi sørge for en rød tråd gennem
både matematikken og programmeringen.

4

3. Den rumlige figur

I dette afsnit kommer vi ind på vores valg af figur, og begrundelse af valget. Vi kommer også ind på
de forskellige krav vi har fået stillet til vores figur. Yderligere kommer vi ind på vores
løsningsstrategi, opstilling af funktioner og udregning af volumen.

3.1 Valg af figur
Det vi startede med at gøre, var at vi i gruppen satte os ned og begyndte at kigge på forskellige
genstande i lokalet, som vi kunne bruge i forbindelse med dette tværfaglige projekt.
Da vi havde gjort det, gav det os et overblik over hvor mange ting man kunne arbejde med i
forbindelse med projektet. Men for ligesom at skelne os ud fra de andre grupper, tog vi os en lille
rundtur til de forskellige grupper for at se hvad de beskæftiget sig med.
Det endte så med at vi valgte at arbejde med en el-pære, som den rumlige figur. Det er ikke hele
pæren vi vil arbejde med, men kun glasset på pæren.
Grunden til at el-pæren lå blandt vores ”valgte figurer”, var netop fordi el-pæren har et
symmetrisk snit, og så har den forskellige former, som man kan man manipulere lidt med.

3.2 Krav til figuren
For netop at have helt styr på vores figur, blev vi nødt til at stille nogle krav som figuren skulle
overholde. Vi fik målt længdesnittet på forskellige el-pærer, og det gav gennemsnitligt en længde
på ca. 8 cm (glasset) og en maksimumradius på ca. 3 cm. Vores krav som vi har fået stillet til vores
figur bliver nævnt i punktform forneden:

1. Længdesnittet til figuren skal være 8 cm, alt afhængigt om noget SKAL ændres undervejs.
2. Den store radius på figuren skal være 3 cm.
3. Vores opstillede funktioner skal tangere i et bestemt punkt eller være forbundet. Dvs. at dette
skal gælde: f ' ( x ) g' ( x ) før at det er opfyldt.
4. Der må ikke være en form for et knæk i funktionerne, den skal være ’glat’.
5. Funktionerne må ikke være for simple, men heller ikke alt for trivielle.

Forneden ses en skitse af hvordan vi havde forstillet os at vores figur skulle se ud:

5

3.3 Funktionsudtryk
Eftersom vi har fået stillet krav til vores figur, kan vi nu gå i gang med at kigge på hvor mange
funktionsudtryk vi skal have med at gøre.
Efter nogle overvejelser og skitseringer og mm. kom vi frem til at vi vil arbejde med fire
funktionsudtryk, som skulle være rigeligt til udformning af figuren.
Vores funktioner skulle dels være: en sinusfunktion, en parabel, en lineærfunktion og en
cirkelfunktion. Dette har vi prøvet at illustrer på billedet forneden, hvor vi har valgt at lade vores
figur være vandret med x-aksen. Dette er blot et eksempel på hvordan vores forskellige udtryk
nogenlunde ville se ud.

3.3.1 Løsningsmodeller
Løsningsmodel 1
Vores første løsningsmodel var, at vi først ville opstille sinusfunktionen og dernæst
cirkelfunktionen. Så ville vi bestemme en tangent til cirkelfunktionen der havde en hældning på ca.
0,5. Til sidst ville vi bestemme et udtryk for parablen, som både skulle tangerer sinusfunktionen og
den rette linje. Dette er vist til højre.

Her prøvede vi at finde et udtryk til parablen, som havde
grenene vendt opad og som tangerede de to funktioner.
Dette blev alt for trivielt og var alt for tidskrævende.
Derfor besluttede vi os for at ændre strategi, angående
bestemmelse af funktioner.

6

Løsningsmodel 2
Vores nye løsningsmodel går ud på at vi først bestemmer vores sinusfunktion, og dernæst
bestemmer parablen der tangerer sinusfunktionen. Når dette så er gjort, vil vi bestemme et udtryk
for cirkelfunktionen (foreløbigt). Så vil vi bestemme en ret linje, som skal tangerer parablen og på
samme tid skal den komme ret tæt på cirkelperiferien. Derfra kan vi ændre på cirklens radius og
sørge for at den rette linje vil tangere cirkelfunktionen. Dermed vil vi have opstillet fire forskellige
funktioner, hvori alle tangere hinanden.

3.3.2 Sinus-funktionsudtryk f(x)
Vores første funktionsudtryk er en sinusfunktion. En normal sinusfunktion ses forneden:

Vi skal så have tilpasset vores funktion, så den passer med vores figur.
I vores tilfælde vil vi meget gerne have at funktionen bliver forskudt op ad y-aksen og skærer i
punktet (0,0.5). Så vil vi også have at funktionen skal have en højde på 0,5. Dvs. at funktionen skal
have et ekstremumspunkt i punktet (0.5,1).

For at opfylde vores krav til funktionen, har vi undersøgt hvad de forskellige variabler gør ved

funktionen, og forneden er disse oplyst:

Forskellige variabler Hvad de gør ved funktionen

sin( x ) Den går fra origo til π og har en højde på 1.

sin( x ) k | sin( x ) - Højden bliver lig med k.
k - Højden bliver lig med 1 .

k

sin( x ) k | sin( x ) k - Forskydning op ad y-aksen med k.
- Forskydning ned ad y-aksen med k.

sin( x k ) | sin( x ) - Længden forkortes med .
k k

- længden forlænges med k .

7

Så for at opstille vores ønskede funktion, bliver vi nødt til at bruge at bruge alle reglerne. Dvs. at vi
vil forkorte vores buelængde til at være lig med 1, (1) derfor ganger vi med ’π’ i sinus-parentesen
Så vil vi halvere højden, (2) derfor dividerer vi sinusfunktionen med 2. Til sidst vil vi forskyde
funktionen 0,5 op ad y-aksen, (3) derfor lægger vi 0,5 til funktionen. Således:

(1) sin( x )

(2) sin( x )
2

(3) sin( x ) 0,5
2

Så vores endelige udtryk kommer til at hedde: f ( x ) sin( x ) 0,5
2

Vi skal også huske på at funktionen kun skal gå fra (0,0.5) til (0.5,1). Dette er illustreret forneden:

3.3.3 Andengradsfunktionsudtryk g(x)

Vi skal nu have opstillet et funktionsudtryk for parablen der har grenene vendt opad og som skal

tangerer sinusfunktionen i punktet (0.5,1), det svarer til sinus-funktionens lokale maksimum og

parablen lokale minimum.

Vi anvender en formel, som vi fandt frem til. Den kan ses til højre. a( x c )2 b
Formlen er let-anvendeligt, da man kan indtaste sine ønskede værdier i den, og

med det samme, får man det ønskede udtryk.

- a = størrelsen på parablen

- (c,b) = Ekstremumspunkt (x,y)

Vi fastsætter at koordinater til vores ekstremumspunkt skal ligge i punktet (0.5,1), dvs. at c = 0,5
og b = 1. Yderligere fastsætter vi også vores størrelse på parablen til at være 0,5 dvs. at hver gang
man tager et skridt hen ad x-aksen, går man 0.5, 1.5, 2.5 osv. op ad y-aksen. Dette ses forneden.

x012345
f(x) 1 1,5 3 5.5 9 13,5

8

Nu kan vi blot skrives vores værdier ind i formlen, og vi får vores funktionsudtryk:
g( x ) 0,5( x 0,5 )2 1

Nu ligner vores udtryk ikke en hel almindelig 2.gradspolynomie, men formlen er bare blevet
omskrevet fra den originale skrivemåde, nemlig ax2 bx c .

Vi vælger at omskrive vores udtryk, til den mere almindelige skrivemåde. Vi gør følgende:

g( x ) 0,5( x 0,5 )2 1

  Vi ganger potensen ind i parentesen. Her bruger vi reglen for
g( x ) 0,5( x2 0,25 x ) 1 kvadratet på en toleddet størrelse.


g( x ) 0,5x2 0,5x 1,125  Vi ganger 0,5 ind i parentesen og lægger 1-tallet til det reelle

tal.

Så fik vi omskrevet udtrykket til den klassiske måde.

Vi sammenligner lige udtrykkene, for at sikre os at de er ens:

g( x ) 0,5( x 0,5 )2 1 g( x ) 0,5x2 0,5x 1,125

Undersøgelserne viser at funktionerne er ens, da de begge går gennem samme punkter.
Nu skal vi sikre os at sinusfunktionen f(x) og parablen g(x) tangerer hinanden i punktet (0.5,1).
Vi kan med det samme resonere os frem til at det gør de, da de begge har ekstremum i det punkt.
For at vise det analytisk, skal vi først differentiere udtrykkene, for at vise at de har en vandret
tangent i samme punkt.

9

Vi differentierer først f(x). For at gøre det, skal vi bruge regnereglen for en sammensat funktion,

samt reglen for differentiation en sinus.

f(x) f’(x)

' f ' g fg'

f
g g2

(sin kx)' k cos kx

f ' ( x ) sin( x ) cos( x )  Vi differentierer først nævneren.

' cos( x )  Så differentierer vi hele brøken
2 og forkorter.
f ( cos( x )) 2 (sin( x )) 0
g 22

Dokumentation

Så differentierer vi g(x) som er ret simpel.
g' ( x ) x 0,5

Dokumentation

Nu når vi har fået differentieret begge funktioner, kan vi indsætte x = 0,5 i begge udtryk, og se om
de har en vandret tangent i det punkt:
f ' ( 0,5 ) cos( 0,5 ) 0

2
g' ( 0,5 ) 0,5 0,5 0
Dette viser at de har en vandret tangent i samme punkt. Så det vil sige at de tangerer hinanden,
som vi resonerede os frem til.

10

3.3.4 Cirkel-funktionsudtryk c(x) (foreløbigt)
Vi vil nu bestemme et udtryk for cirkelfunktionen, men dette udtryk vil være foreløbigt, da vi
kommer til at ændre på radiussen en smule, for at få det hele til at passe sammen.
For at opstille et udtryk for cirklen, skal vi først og fremmest tage udgangspunkt i cirklens ligning,
som ser således ud: ( x x0 )2 ( y y0 )2 r 2

- x0 og y0 er centrumskoordinater (x,y) for cirklen.
- r er lig med radius.

Nu vil vi indsætte vores værdier i ligningen og omskrive den for at det kommer til at ligne et
normalt funktionsudtryk, derfor skal vi i princippet have isoleret y. Vi gør følgende:

( x 5 )2 ( y 0 )2 32  Vi ganger ind potensen ind i parentesen i y.
  Vi trækker 32 fra på begge sider.
( x 5 )2 y2 32  Vi lægger y2 til på begge sider.
  Vi fjerner potensen, ved at tage kvadratroden
32 ( x 5 )2 y2 0

32 ( x 5 )2 y2


y 32 ( x 5 )2

Nu ved vi at vores funktionsudtryk for cirkelfunktion ser således ud c( x ) 32 ( x 5 )2 , og den
kan ses forneden:

På figuren foroven kan man se hvordan funktionen danner en cirkel der har centrum i (5,0) og har
en radius på 3.

11

3.3.5 Lineær-funktionsudtryk h(x)
Nu har vi så fået opstillet tre forskellige funktionsudtryk, og mangler den sidste.
Den sidste funktion vi skal opstille er en lineærfunktion som forbinder parablen g(x) og cirklen c(x).
Billedet forneden viser hvordan den lineærfunktion nogenlunde tangerer g(x) og c(x).

Det vi nu vil gøre, er at vi vil undersøge i hvilket punkt på parablen, kan vi lave en tangent der
”nogenlunde” rører cirklen. Vi skal altså komme meget tæt på, nemlig fordi vores strategi er at vi
blot ændre på cirklens radius, således at den passer med at de tangerer hinanden.
Efter nogle undersøgelser på programmel ”Graph”, kom vi frem til at vi gerne vil lave en tangent i
til parablen i g(1,1) = 1,18; dette er markeret på billedet forneden.

Vi ved at hvis vi skal opstille et udtryk for en ret linje, skal vi tage udgangspunkt i linjens ligning
som ses til højre.

Linjens ligning
y y0 f ' ( x ) ( x x0 )
- x0 og y0 er punktets koordinater til tangenten (x,y)
- f’(x) er hældningen i punktet f(x).

12

Vi kender koordinaterne til tangenten, og mangler blot hældningen i punktet. Det problem løser vi
ved at vi bruger det differentierede udtryk fra afsnit (3.3.3 Andengradsfunktionsudtryk g(x)) og
indsætter x = 1,1 for at finde hældningen i punktet.
g( x ) 0,5x 2 0,5x 1,125

g' ( x ) x 0,5

g' ( 1,1 ) 1,1 0,5 3
5

Nu når vi har fundet hældningen i punktet, har vi stort set alt hvad vi skal bruge til at kunne
opstille en tangent der tangerer parablen.
y y0 f ' ( x ) ( x x0 )

y 1,18 3 ( x 1,1 ) Vi indsætter vores værdier.
5 Vi ganger ind i parentesen.
Vi lægger 1,18 på begge sider for at isolerer y.


y 1,18 3 x 33
5 50



y 3 x 13
5 25

Dokumentation

Nu har vi så fået bestemt vores lineær-funktionsudtryk, som er: h( x ) 3 x 13
5 25

Men nu har vi et problem, billedet forneden viser at den lineærfunktion ikke tangerer cirklen, og
derfor bliver vi nødt til at ændre på cirklens radius for at få den til at passe. (Dette udfører vi i
næste afsnit).

13

3.3.6 Cirkel-funktionsudtryk c(x) (endelig)

Nu skal vi så have tilpasset vores radius, således at den vil tangerer med linjen h(x).

Vi ved at tangenten i et punkt på cirklen altid er vinkelret på linjen, som går
gennem centrum af cirklen og punktet, og derfor kan vi finde den vinkelrette
afstand fra centrum af cirklen til linjen h(x). Den afstand vi så kommer frem til vil
være den nye radius. Dette har vi prøvet at illustrer til højre.

For at finde den korteste afstand mellem et punkt og en linje, bruger vi dist- Dist-formlen
formlen, som ses til højre. dist( C,l ) | ad be c |
For at gøre det lidt nemmere for os, når vi skal udregne afstanden, kan vi
omskrive linjens ligning til denne form: ax by c 0 . a2 b2
For at gøre det, skal vi blot trække y fra på begge sider.

y 3 x 13
5 25



3 x y 13 0
5 25
Nu har vi så omskrevet udtrykket til linjens ligning, og kan nu kigge på hvilke værdier vi skal
indsætte i formlen for at finde den korteste afstand:

- d og e er lig med centrumskoordinaterne (5,0)
- a, b og c er lig med variabler fra ligningen.

Så indsætter vi blot vores værdier ind i formlen, og vi får:

dist( C ,l ) | 3 5 ( 1 0 ) 13 | 44 34
5 25 85
3 2 12
5

Dokumentation

Den nye radius er så 44 34 3,0183
85

Det er en forskel på 0,0183.

Det nye funktionsudtryk er så: c( x ) 2

44 34 ( x 5 )2
85

14

Nu skal vi blot sikre os at det vi har udregnet er korrekt, netop ved at vi sætter de to ligninger lig
med hinanden. Dermed vil vi komme frem til koordinaterne til det punkt, hvori tangenten og
cirklen tangerer hinanden. Vi gør følgende:

c( x ) h( x ) 3 x 13  Vi sætter ligningerne lig med hinanden
 5 25  Vi isolerer x

2

44 34 ( x 5 )2
85

x 293
85

Dokumentation

Nu indsætter vi x-værdien ind i begge ligninger, og ser om vi får det samme. Hvis de giver samme
resultat, betyder det at de tangerer hinanden i netop det punkt:

c 293 2 293 2 44
85 5
44 34
85 17
85

g 293 3 293 13 44
85 5 85 25 17

Dokumentation

Så fik vi bekræftet at de to funktionerne tangerer hinanden.
Nu er vi så færdige med opstilling af funktionsudtryk. For et bedre overblik over det, se venligst
næste afsnit.

15

3.3.7 Opsummering af funktionsudtrykkene
Her kommer en lille opsummering over de fire funktionsudtryk, som vi har fået opstillet undervejs.

Sinusfunktionen f(x) – Intervalgrænsen = [0;0.5]
f ( x ) sin( x ) 0,5

2

Andengradsfunktionen g(x) – Intervalgrænsen = [0.5;1.1]
g( x ) 0,5x2 0,5x 1,125

Lineærfunktionen h(x) – Intervalgrænsen = [1.1; 293 ]
85

h( x ) 3 x 13
5 25

Cirkelfunktionen c(x) – Intervalgrænsen = [ 293 ; 44 34 5]
85 85

c( x ) 2

44 34 ( x 5 )2
85

Forneden ses vores funktionsudtryk sat sammen.
Det burde give et indtryk af, at dette er en el-pære.

På billedet foroven kan man se hvordan vores funktioner er blevet sat sammen
og danner nu en figur der har formen af en el-pære.

16

3.4 Længdesnit og rumfang af omdrejningslegemet
Vi skal have bestemt både længdesnittet og volumenet af figuren, og det gør vi vha.
integralregning. Længdesnittet er ret simpel at bestemme, hvorimod volumenet bliver lidt for
trivielt, da vi har at gøre med funktionsudtryk der er ret barske at integrerer.

3.4.1 Bestemmelse af længdesnit
Vi skal nu have bestemt længdesnittet til vores figur.
Det gør vi ved at vi skal kende start- og slutpunktet på x-aksen.
Vi ved at vores figur starter i (0,0.5), så skal vi bare have fundet ud af hvor på x-aksen den slutter
præcis. Den måde vi gør det på, er at vi kender den nye radius og centrumskoordinaterne til den
store cirkel. Så skal vi bare lægge radiussen til centrum, og vi får vores længde:

Centrum = (5,0)
Radius = 44 34

85
Længdesnittet = 44 34 5 8,0183cm

85

Nu når vi har fået beregnet vore længdesnit, kan vi gå videre til integrering af udtrykkene for at
bestemme volumenet af figuren.

3.4.2 Bestemmelse af rumfang

For at bestemme rumfanget for figuren, skal vi have integreret hvert eneste funktionsudtryk, for

nemlig at kunne beregne deres rumfang ud. Når man skal integrer skal man i princippet findes

stamfunktionen til sine funktionsudtryk. I vores tilfælde skal vi have beregnet volumen ud fra et

omdrejningslegeme om x-aksen, og derfor benytter vi formlen til højre.

Hvis vi kigger i afsnittet (3.3.7 Opsummering af funktionsudtrykkene), kan vi se at vi har at gøre

med meget barske udtryk. Dvs. at de er svære at integrere vha. normal V b x 2 dx
integration. Det første udtryk f(x) er f.eks. svær at integrere, og det der
karakterisere at den er svære at integrere, er at den består af en sammensat f
a

trigonometriskfunktion i en sammensat funktion. I de her tilfælde bliver man

nødt til at bearbejde integralet vha. partiel integration.

Partiel integration bliver brugt ved produktet af to funktioner, og det handler om at opdele

integralet i to led, der gør det nemmere at bearbejde.

- Da vi ikke rigtigt har haft om partiel integration, kan vi i vores tilfælde ikke løse integralerne

analytisk, og bliver derfor nødt til at anvende programmel. Der er dog en undtagelse i funktionen

h(x), da den er forholdsvis enkel at integrere.

Det første vi gør, er at vi integrere h(x) analytisk og vurdere med programmel, og dernæst

udregner vi de tre andre vha. programmel.

17

h( x ) 3 x 13  Vi ganger potens ind.
5 25



F( x ) 293 9 x2 169 2
85
0,624x dx
1,1 25 625



293 293  Vi integrerer.
85
F( x ) 9 x3 169 x 0,312x2 dx 9 x3 169 x 0,312x2 85
1,1 75 625 75 625 1,1

Vh( x ) 27 ,3937cm3

________________________________________________________________________________

f ( x ) sin( x ) 0,5
2



0,5 sin( x ) 2

F( x ) 02 0,5 dx

V f ( x ) 1,089cm 3

________________________________________________________________________________
g( x ) 0,5x2 0,5x 1,125


F( x ) 1,1 0,5 x 2 0 ,5 x 2
0 ,5
1,125 dx

V f ( x ) 2,123cm 3

________________________________________________________________________________

c( x ) 2

44 34 ( x 5 )2
85

 8 ,01838 2
F( x ) 293 2
85
44 34 ( x 5 )2 dx
85

V f ( x ) 98,120cm 3

Den endelige volumen er: 1,089 2,123 27,393 98,120 128,725cm3

18

4. Programmeringsdelen

I dette afsnit vil vi analyserer og beskrive vores fremstillede prototype i både Python og Lazarus.
Systemudviklingsmetoden1 spiller igen en særlig rolle, vi har dog sorteret planlægningsfasen fra,
da vi synes at det ikke var helt så relevant i dette projekt. Vi kommer ind på User Stories og
forklarer den med hensyn til vores produkt.

4.1 Kravspecifikation (generel)
Vi skal udvikle et IT-produkt, som skal visualisere vores valgte figur i 3D format. I gruppen har vi
valgt at visualisere figuren ved brug af Python. Derudover skal vi udvikle en brugerflade i
programmeringssproget Lazarus, som skal variere mindst én variabel, altså en parameter.
Brugerfladen skal kunne vise det beregnede volumen af figuren. Her kommer en opsummering af
alle de krav:

- Der skal udvikles et IT-produkt, som skal visualisere figuren i 3D og længdesnit i 2D.
- Brugerfladen udviklet i Lazarus skal kunne variere en eller flere parametre og vise det
- Arbejdsformen pair programming skal anvendes til væsentlige dele af

programmeringsarbejdet, og i konklusionen skal der reflekteres over erfaringerne med
denne arbejdsform.
- Programmeringsforløbet skal dokumenteres, - herunder kravspecifikation, design,
implementering og test.

Derudover har vi i klassen bemærket yderligere 6 kerneproblemer som er værd at tænke over:
1. Fremstille 3D modellen som en tekstfil eller som en kompileret objektkode, et
programmeringsværktøj.
2. Integration, implementering af, i Lazarus, dvs. i Object Pascal.
3. Jævn overgang mellem to af delobjekterne.
4. Ændring af en eller flere variabler.
5. Starte eksterne programmer fra et Object Pascal program lavet med Lazarus.
6. Vide hvornår rendering af 2D billedet af vores matematiske 3D model er færdig og opdatere
billedet i brugerfladen på vores Lazarus-program.

1 Bilag 1- Introduktion til systemudviklingsmetoden

19

4.2 Info om Python
Python er et meget specielt programmeringssprog, som adskiller sig fra de fleste
programmeringssprog. Programmet er oprindeligt udviklet af den hollandske Guido van Rossum.
Det der gøre programmet så speciel er at dens grammatik adskiller sig fra de fleste andre
programmeringssprog ved at de logiske programdele i Python opdeles ved hjælp af indrykning
(eng. indentation), frem for at bruge parenteser, som de fleste programmeringsprogrammer gør.
Opdelingen af programdelene i Python sørger for at man hele tiden har struktur på sine koder.
Programmet hjælper hermed også med at integrere vores systemer mere effektivt.
Programmeringsprogrammet er en freeware og derfor kan man hente den helt gratis, men
selvfølgelig er der nogle licenskrave. Python er tilgængeligt under en, OSl-godkendt, Open Source-
licens, og selve licenskravene kan blot ses på Wikipedia.org
(http://en.wikipedia.org/wiki/Python_Software_Foundation_License)

4.2.1 Design
Designet for vores visuelle produkt i Python har ikke
været svært at bestemme. Da vi havde nogle funktioner
at gå ud fra, altså når vi skulle tegne dem ind, har der
ikke rigtigt været nogen problemer med at bestemme
designet. Det eneste vi synes kunne være en god ide, var
at vise vores funktioner med forskellige farver, så vi let
kan se hvor mange forskellige funktioner figuren består
af. Vores første funktion er gul, den næste er hvid, den
efterfølgende er blå og den allersidste er rød. Akserne er
tegnet på en måde at hver akse har sin egen farve.

4.2.2 Implementering i vPython
I Visual Python er det lykkedes os at visualisere vores
figur i 3D. I gruppen havde vi arbejdet med Python i flere
forskellige projekter, derfor var vi på hjemmebane med programmeringssproget. Vi vil nu beskrive
hvordan vi har kodet vores figurer i Python. Vores pointe er at tegne en masse cylinder mellem
vores intervalgrænser.

Vores input skal i tilfældet her være en ændring af et variabel/parameter, og det skal ske ved at
man skal skrive et tal i inputfeltet. Ved hjælp af funktionen File Handling2 i Lazarus, skal det givne
data (den man har skrevet i inputfeltet) overføres til vores dokument med vPython koderne,
derefter skal den så vise et billede.
Da vi ikke har nogle ”grimme” funktioner som f.eks. logaritmefunktioner, kan vi nøjes med at
importere fra ’visuel import’. Der kræves yderligere ikke at importerer fra matematikken,
programmet kan læse vores funktioner korrekt.

2 http://wiki.lazarus.freepascal.org/File_Handling_In_Pascal

20

Vi skal hermed definere et funktionsudtryk med hensyn til x, og det gør man ved at sige ” def
navnet for funktionen (x); ”. Men hvordan skriver vi så selve funktionerne ind? I Python kan
funktionsudtrykke læses ved at skrive return ind foran selve funktionen, altså ” return f(x) ”. Et lille
problem kan være at programmet ikke kan læse gangetegnet foran x, i f.eks. tilfældet f(x)=5x+b,
man skal huske at adskille 5 fra x netop ved at sætte gangetegn foran, altså f(x)=5*x+b.

Vi skal fortælle programmet at vores funktion skal have en intervalgrænse, og at der skal tegnes
nogle cylindere mellem det givne interval. Det gør vi ved at sige ” for x in arange (a, b, antal
cylindere for hver gang man går x hen på x-aksen) ”. Hvis vi har intervalgrænsen *a;b+, og vi vil
have en cylinder for hver gang man går 0,1 hen ad x-aksen, skriver vi blot: for x in arange (a, b,
0,1).

Vi vil også have vores funktion for grafen til at resonerer en y-værdi, for hver gang man sætter en
x-værdi. Vi siger at vores y-værdi er lig med vores definerede funktion. For at fortælle vores
cylinder hvilke arbejde den skal fortage, vi angiver dets startsposition, hvilket akse den skal gå ud
af, hvilke radius den skal have og evt. hvilken farve den skal tegne i. Til sidst kan vi så indstille
kameraet (scene.center = (x,y,z))

Dette gøres med alle de funktioner man har brugt til at lave selve figuren (se bilag 1).
For at tegne nogle akser som passer til figuren, som i grafen på matematikdelen, skal man bruge
følgende kode:

Her fortæller man hvordan man vil placere akserne, hvilken farve den skal have og hvor tyk og
tydelig den skal være.
4.2.3 Test
Afprøvning af programmet skete ved at køre vores program. Det gøres ved at taste F5 tasten.
Derudover har vi spurgt nogle fra klassen om de kunne se hvad figuren skulle forestille, de sagde
uden tvivl at det var en el-pære.

21

4.3 Info om Lazarus
Lazarus (IDE, Integrated development environment, Integreret udviklingsmiljø) er et freeware
mulit-platform (vil sige at den fungerer på flere platforme, f.eks. Linux og Microsoft Windows).
Programmet er god til at lave en brugerflade på en meget let måde. Man har muligheder for at
placere sine knapper og skrivefelter blot ved at klikke på ikonerne der findes i menuen, så man på
denne måde kan tegne knapperne med ønskede størrelse og placering. Man kan kode hver eneste
knap med nogle funktioner på overskuelig måde. Lazarus er udviklet til formål af nogle frivillige i
sammenhænge med Free Pascal, som er en compiler. Programmet har flere licenser, hvor den ene
er GNU General Public License.
4.3.1 Design
Ud fra logikken bag Gestaltloven, beslutter vi os for at grupperer knapperne efter funktion, samt
gøre det mere brugervenligt og overskueligt.
Vi startede med at tegne nogle skitser for hvordan brugerfladen skulle se ud. Til sidst sorteret vi
den skitse vi synes var bedst. Og derefter tegnede vi vores endelige skitse for hvordan vi vil have
vores brugerflade i Lazarus til at se ud.

På de to øverste skitser kan vi se vores ønskede brugerflade. Vi starter med at indsætte en
variabel, derefter klikker vi på knappen ”change variable”. Når vi så klikker ”Show picture”, så
kommer billedet frem med de ændrede indstillinger. Til sidst kan vi klikke på ”calculate
volume” knappen for at beregne volumen.

Vores endelige brugerflade kommer til
at se således ud:

22

4.3.2 Implementering i Lazarus
For at få vores variabel/parameter ændret i vores vPython (som ovennævnt sker ved File
Handling), skal vi først fortælle vores program i Lazarus at den skal overføre data fra inputfeltet
videre til vPython, som nu skal ændre det variabel man ønsker. Det gør vi ved at fortælle
programmet at hver gang vi skriver et tal i inputfeltet, skal den overføres til vPython og ændre
parameteren/variablen :

Var
Edit1: integer;

Vi ønsker i gruppen at lægge det tal der bliver skrevet í inputfeltet til vores funktion i vPython. På
den måde bliver vores 3D figur justeret op eller ned ad y-aksen.
I Python havde vi allerede defineret en funktion:

def lillesinus(x):
return sin(x*pi)/2+0.5+0

Og i Lazarus skriver vi hermed:

Bemærk at vi har sagt at der skal lægges Edit1.Text (altså et tal) til vores funktion.

Derudover vil vi gerne gemme et 2D billede af figuren i Python, det skal nemlig vises i brugerfladen
i Lazarus. Vi gør det ved at udnytte en funktion i Python, nemlig PIL (Picture Image Libary)3.
Funktionen tager et screenshot af figuren i Python, når man lukker vinduet.
Så skal vi gå tilbage til vores Python kode og importere yderligere fra PIL:

Derudover skal vi definerer et start og slut punkt på hvordan vores screenshot skal tages og
gemmes. Vi siger fortæller programmet at screenshottet skal gemmes i bmp. format:

Nu skal vi så åbne billedet i brugerfladen. Det gør vi ved hjælp af koden som findes i Lazarus
websiden:

3 http://www.pythonware.com/products/pil/

23

Men en ting vi havde problemer med, var at åbne programmet. Vi fandt ud af at vi havde glemt at
angive en variabel (under var) og en type.
Det gjorde vi ved at tilføje:
Var
Bitmap: TBitmap;
og
Type
Image1: TImage;
I AProcess skulle vi blot angive en ’fil’ som funktionen skulle finde. Vi angiver selvfølgelig vores Py.

fil.
Bemærk at vores fil ikke er en exe fil. Derfor adskiller vi vores exe fil med et mellemrum, så vi
dernæst kan angive vores filplacering:

.
De vigtigste begreber i Lazarus:

Nu vil vi kort introducere til de forskellige begreber, så vi senere hen får det lettere ved at forstå
fremgangsmåden.
Producere: denne funktion fortæller programmet at der skal programmeres i det element man
skriver, f.eks. kan det være en button1.

24

Begin: alt det der kommer efter begin knappen er koden til selve knappen.
End: Når der ikke skal være koder længere, slutter man det af med end.
Unit: begrebet fortæller hvilke unit der kodes i.
Uses: hvilke funktioner skal anvendes?
Var: Dette er en variabel i programmet. Det kan være et tal.
4.4 Endelige test
Vi tester programmet ved at køre den. Vi taster en variabel ind, og ser om en ændring sker. Vi vil
desuden prøve at hente billedet og vise det i brugerfladen.
Vi prøver at taste 2 ind i inputfeltet:

Vi prøver at indtaste 5 ind i inputfeltet:

Vi kan se at figurens form bliver anderledes for hver gang man ændrer variablen. Det viser at vores
program er lavet succesfuldt.

25

Hvis vi kigger ind på Python dokumentet, så kan vi se om der er lagt det tal vi har skrevet ind på
inputfeltet til vores funktionsudtryk:

Vi kan se at der er lagt 5 til på funktionen.
Da dette kun er en prototype, fik vi lov af vores lære, at vi bare kunne lave et felt til beregning af
volumenet. I oplæget havde vi misforstået det var programmet der skulle kunne beregne
volumenet, eller om det bare skulle gøres i hånden, på papir. Dette er vi yderst utilfredse med.
4.5 User Stories 4
Efter en snak med vores programmeringslære Karl, har vi valgt at lave en User Stories.
På billedet forneden ses vi (brugeren) gerne vil fremstille et program, som han gerne vil teste.
Brugeren (vi) vil se om der er fejl i programmet, er der en eller flere fejl, skal man gå igennem
iterationsfasen, og hvis ikke vi kan løse fejlene, skal vi lave et nyt projekt, men hvis vi godt kan løse
problemet, så burde vores formål med at få vist et 3D figur af pæren være løst. Hvis ikke, så går
man iterationsfasen igennem igen. Sådan bliver man ved. Denne behandling af processen er lavet
ud fra brugerens ønsker til det program som skal fremstilles og testes.

4 http://www.extremeprogramming.org/map/project.html

26

5. Konklusion

Først og fremmest valgte vi at arbejde med en el-pære, som skulle være den rumlige figur. Vi fik
opstillet fire forskellige funktionsudtryk, som udformede el-pærens struktur. Heriblandt en
sinusfunktion, linærfunktion, cirkelfunktion og en andengradsfunktion, som nogenlunde ville
afspejle vores niveau på 3.år. Vi fik yderligere udregnet rumfanget og længdesnittet på figuren,
hvor rumfanget var 128,725cm3 og længdesnittet 8,0183cm. Vores længdesnit endte ikke som vi
havde stillet i vores krav, nemlig 8 cm, men dette skyldes en ændring på et af
funktionsudtrykkene.
Vi fik også programmeret en grafisk brugerflade i Lazarus, som skulle visualisere figuren. I
forbindelse med programmeringen, spillede vores to programmer meget godt sammen, nemlig
(Python og Lazarus). Dette var med til at man kunne ændre på forskellige variabler i Lazarus, og
dernæst få den vist i Python.
Dog skulle vi også få programmet Lazarus til at udregne rumfanget ud på figuren ved forskellige
størrelser, som vi aldrig fik udført. Dette er dog en prototype, og man kan altid forbedre den.

27

Bilag 1- Introduktion til systemudviklingsmetoden

I systemudviklingsmetoden er der fem hovedbegreber. De fem hovedbegreber er hermed:
- Planlægning - Krav- og testspecifikation - Design - Implementering - Afprøvning
Begreberne hjælper til med at (i tilfældet
her) gennemføre en projektopgave med ’en
rød tråd’. Med de to øvrige begreber
’indledende aktiviteter’ og ’afsluttende
aktiviteter’ danner man nærmest et hoved
og hale i rapportens struktur, hvor man også
skyder projektforløbet i gang med de
indledede aktiviteter, mens man runder den
af med de afsluttende aktiviteter. Med de to
aktiviteter kan man lave op til flere
iterationer (gentagelser).

28

Bilag 2 – Python kildekoder

from visual import *
from PIL import Image, ImageGrab
scene.center = (8, -6, 5)

def lillesinus(x):
return sin(x*pi)/2+0.5+5

for x in arange(0, 0.5,0.1):
y=lillesinus(x)
cylinder(pos=(x,0,0), axis=(0.1,0,0), radius=y, color=color.yellow)

def eftersin(x):
return ((x-0.5)**2)/2+1+5

for x in arange(0.5, 1.1,0.1):
y=eftersin(x)
cylinder(pos=(x,0,0), axis=(0.1,0,0), radius=y, color=color.white)

def rettelinje(x):
return 0.6*x+0.52+5

for x in arange(1.1,293/85,0.1):
y=rettelinje(x)
cylinder(pos=(x,0,0), axis=(0.1,0,0), radius=y, color=color.blue)

def cirkelfunktion(x):
return sqrt(((44*sqrt(34))/85)**2-(x-5)**2)+5

for x in arange(293/85, (44*sqrt(34))/85+5,0.1):
y=cirkelfunktion(x)
cylinder(pos=(x,0,0), axis=(0.1,0,0), radius=y, color=color.red)

im = ImageGrab.grab((6,30,1000,1000))
im.save("C:\\Users\\Sefa dos Keita\\Desktop\\Matprogramering\\TestFred\\billede.bmp")

aX = arrow(axis=(12,0,0), pos=(-2,0,0), color=color.red, shaftwidth=0.08, fixedwidth = 0)
aY = arrow(axis=(0,12,0), pos=(0,-6,0), color=color.white, shaftwidth=0.08, fixedwidth = 0)

29

Bilag 3 – Lazarus kildekoder

unit Unit1;

{$mode objfpc}{$H+}

interface

uses
Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
ExtCtrls, Menus, Process;

type

{ TForm1 }

TForm1 = class(TForm)
Button1: TButton;
Button2: TButton;
Button3: TButton;
Edit1: TEdit;
Image1: TImage;
StaticText1: TStaticText;
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button3Click(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure Image1Click(Sender: TObject);
procedure StaticText1Click(Sender: TObject);
private
{ private declarations }
public
{ public declarations }
end;

var
Form1: TForm1;
FileVar: TextFile;
Edit1: integer;
AProcess: TProcess;

30

Bitmap: TBitmap;

implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.FormCreate(Sender: TObject);
begin

end;

procedure TForm1.Image1Click(Sender: TObject);
begin

end;

procedure TForm1.StaticText1Click(Sender: TObject);
begin

end;

procedure TForm1.Button1Click(Sender: TObject);
begin

//WriteLn('File Test');
AssignFile(FileVar, 'denendeligefigur.py'); // You do not have to put .txt but this is just for now
{$I-}

Rewrite(FileVar); // creating the file
Writeln(FileVar,'from visual import *');
Writeln(FileVar,'from PIL import Image, ImageGrab');
Writeln(FileVar,'scene.center = (8, -6, 5)' );
Writeln(FileVar,'' );
Writeln(FileVar,'' );
Writeln(FileVar,'def lillesinus(x):' );
Writeln(FileVar,' return sin(x*pi)/2+0.5+' + Edit1.Text );
Writeln(FileVar,'' );
Writeln(FileVar,'' );
Writeln(FileVar,'for x in arange(0, 0.5,0.1):' );

31

Writeln(FileVar,' y=lillesinus(x)' );
Writeln(FileVar,' cylinder(pos=(x,0,0), axis=(0.1,0,0), radius=y, color=color.yellow)' );
Writeln(FileVar,'' );
Writeln(FileVar,'' );
Writeln(FileVar,'' );
Writeln(FileVar,'def eftersin(x):' );
Writeln(FileVar,' return ((x-0.5)**2)/2+1+' + Edit1.Text );
Writeln(FileVar,'' );
Writeln(FileVar,'' );
Writeln(FileVar,'for x in arange(0.5, 1.1,0.1):' );
Writeln(FileVar,' y=eftersin(x)' );
Writeln(FileVar,' cylinder(pos=(x,0,0), axis=(0.1,0,0), radius=y, color=color.white)' );
Writeln(FileVar,'' );
Writeln(FileVar,'' );
Writeln(FileVar,'' );
Writeln(FileVar,'def rettelinje(x):' );
Writeln(FileVar,' return 0.6*x+0.52+' + Edit1.Text );
Writeln(FileVar,'' );
Writeln(FileVar,'' );
Writeln(FileVar,'for x in arange(1.1,293/85,0.1):' );
Writeln(FileVar,' y=rettelinje(x)' );
Writeln(FileVar,' cylinder(pos=(x,0,0), axis=(0.1,0,0), radius=y, color=color.blue)' );
Writeln(FileVar,'' );
Writeln(FileVar,'' );
Writeln(FileVar,'' );
Writeln(FileVar,'def cirkelfunktion(x):' );
Writeln(FileVar,' return sqrt(((44*sqrt(34))/85)**2-(x-5)**2)+' + Edit1.Text );
Writeln(FileVar,'' );
Writeln(FileVar,'' );
Writeln(FileVar,'for x in arange(293/85, (44*sqrt(34))/85+5,0.1):' );
Writeln(FileVar,' y=cirkelfunktion(x)' );
Writeln(FileVar,' cylinder(pos=(x,0,0), axis=(0.1,0,0), radius=y, color=color.red)' );
Writeln(FileVar,'' );
Writeln(FileVar,'' );
Writeln(FileVar,' im = ImageGrab.grab((6,30,1000,1000))' );
Writeln(FileVar,' im.save("C:\\Users\\Sefa dos
Keita\\Desktop\\Matprogramering\\TestFred\\billede.bmp")' );
Writeln(FileVar,'' );
Writeln(FileVar,'aX = arrow(axis=(12,0,0), pos=(-2,0,0), color=color.red, shaftwidth=0.08,
fixedwidth = 0)' );

32

Writeln(FileVar,'aY = arrow(axis=(0,12,0), pos=(0,-6,0), color=color.white, shaftwidth=0.08,
fixedwidth = 0)' );

Writeln(FileVar,'' );
CloseFile(FileVar);
//ReadLn;
end;
procedure TForm1.Button2Click(Sender: TObject);
begin
AProcess := TProcess.Create(nil);
AProcess.CommandLine :='C:\Python26\python.exe "C:\Users\Sefa dos
Keita\Desktop\Matprogramering\TestFred\denendeligefigur.py"';
AProcess.Options := AProcess.Options + [poWaitOnExit];
AProcess.Execute;
AProcess.Free;

Bitmap := TBitmap.Create ;
Bitmap.LoadFromFile('C:\Users\Sefa dos
Keita\Desktop\Matprogramering\TestFred\billede.bmp');
Image1.Canvas.Draw(0,0,Bitmap);
end;
procedure TForm1.Button3Click(Sender: TObject);
begin
end;
end.

33