2013InfB24

From rtgkomArkiv
Jump to: navigation, search

Contents

Hello World med C++, Gkb 09:31, 24 April 2014 (CEST)[edit]

C++ blev lavet/opfundet af Bjarne Stroustrup, og derfor er det naturligt at søge information om C++ på hans website, se her: http://www.stroustrup.com/

Han har lavet en vejledning til nye brugere af C++ som han kalder A Tour of C++, og her er en link til et sted hvor man kan læse den: http://isocpp.org/tour. Den er bygget op af fire dele

  • Part 1: The Basics
  • Part 2: Abstraction Mechanisms
  • Part 3: Containers and Algorithms
  • Part 4: Concurrency and Utilities

Her er en link til den første del, en PDF fil på ca. 22 sider. I den finder vi et eksempel på et Hello World program som ser sådan ud.

#include <iostream>

int main()
{
        std::cout << "Hello, World!\n";
}

I Linux/Unix har vi normalt GCC installeret og så kan man i en terminal kompilere dette program sådan.

g++ test.cpp

Det giver en object fil med navnet 'a.out', som kan eksekveres sådan.

./a.out

Hvilket gerne skulle resultere i at teksten "Hello, World!" skrives i terminalen.

learner@learner-HP-Compaq-dc7100-SFF-DX878AV:~$ ./a.out 
Hello, World!

Hvis du er på Windows, så installer f.eks. CodeBlocks, og vælg MingW/GCC varianten, så får du GCC installeret og så kan du åbne en kommandoprompt (windows terminal) og på lignende måde kompilere og eksekvere dette eksempel.


QtCreator og Visual C++ Gkb 08:23, 3 April 2014 (CEST)[edit]

I går fortsatte vi arbejdet med C++. Det er store værktøjer som vi forsøger at få i gang. Flere af os har oplevet problemer med at installere Visual C++, for eksempel så skal Service Pack 1 være installeret i Windows 7, jeg kunne ikke få lov til at installere den.

Andre har haft problemer med at installere QtCreator under Windows, for eksempel på den måde at de først har installeret en version uden compiler. Det blev vistnok løst ved afinstallering og installering af den version som har MinGW inkluderet, http://download.qt-project.org/official_releases/qt/5.2/5.2.1/qt-opensource-windows-x86-mingw48_opengl-5.2.1.exe.

På nogle Linux distroer, f.eks. Ubuntu 12.04, har vi observeret at eksemplerne ikke er installeret når man bruger atp-get installe, Hos mig resultrede det i version 5.0.1 (eller 5.1.0?) af QtCreator. Problemet blev løst ved at afinstallere med apt-get remove qtcreator og downloade online installeren for 32 bit Linux fra http://qt-project.org/downloads, den første i listen. Her er adressen: http://download.qt-project.org/official_releases/online_installers/qt-opensource-linux-x86-1.5.0-2-online.run. Den skal man så installere manuelt. Jeg brugte chmod a+x http://download.qt-project.org/official_releases/online_installers/qt-opensource-linux-x86-1.5.0-2-online.run, og så ./http://download.qt-project.org/official_releases/online_installers/qt-opensource-linux-x86-1.5.0-2-online.run til at starte installationen.

Nu var eksemplerne med og jeg kunne vælge dem og kompilere, -testede nogle stykker. Men der var vistnok to ting som jeg først skulle lave:

  • Først skulle jeg i Tools - Options - Builde & Run - Compilers vælge GCC som compiler (den var autodetecteret som GCC (x86 32bit in /usr/bin) men ikke aktiveret) og trykke Apply.
  • Så skulle jeg ændre lidt indstillingerne som man har tilgang til via det fjerde ikon/knap/billed fra bunden i venstre side i QtCreators brugerflade. Det ligner et billed af en lille computer. Når man klikker på den, så kan man vælge Project, Kit og Build. Hos mig på Ubuntu 12.04 var det nok at vælge Kit til Desktop Qt 5.2.1 GCC 32bit, og så kunne jeg compilere og køre flere af eksemplerne som f.eks. Chip Example og emitters. Jeg fink indtryk af at kompileringen gik lidt hurtigere hvis Build sat til Release, men Debug virked også.

Der var mange som var begyndt at følge tutorials om hvordan man bruger disse værktøjer til at lave grafisk applikationer til Windows og Linux. Nogle har også valgt at bruge andre tools, som f.eks. CodeBlocks, og det er helt ok. Hvis man gør det, så kommer man måske lidt hurtigre i gang med at lære selve C++.

Måling af HCI parametre, en Spike Solution med C++, Gkb 08:23, 3 April 2014 (CEST)[edit]

I dag laver vi to ting:

  • En øvelse, leg, en Spiek Solution med C++, til at måle en HCI parameter i relation til anvendelse af musen.
  • Evaluering og feedback på rapporter fra Mini-SRP projektet.

Mens jeg snakker med grupperne om deres rapporter, så leger klassen med at lave et program med grafisk brugerflade vha. C++ som skal måle et eller andet aspekt ved hvordan brugeren af programmet anvender musen. For eksempel kan den helt enkle verion være at måle antal kliks med venstre tast i løbet af 10 sekunder.

En lidt mere avanceret tilgang kunne være at registrere tiden ved alle klik i 10 sekunder og lave en visualisering og en statistisk analyse af tidsintervallerne mellem klikkene. Er deres længde fordelt efter en possion fordeleing (http://no.wikipedia.org/wiki/Poissonfordeling)?

Vælg selv platform, dvs. operativsystem, og udviklingsværktøjer. Oplagt kan være at anvende Microsofts Visual C++ eller QT Creator, http://qt-project.org/, oprindelig fra Trolltech i Norge, og senere ejet af Nokia, og nu frit???

Se gerne min egen spike solution som jeg lavede i går med Python, den er her: http://www.rtgkom.dk/~gkb/

Lagring af måledata i en tekstfil med Processing, Gkb 09:45, 13 March 2014 (CET)[edit]

Vi kan bruge createWriter() til at lave en tekstfil som vi kan skrive målingerne til. Se et eksempel her http://www.processing.org/reference/createWriter_.html

Dataopsamling og modellering, Gkb 10:48, 4 March 2014 (CET)[edit]

I dag starter vi arbejdet med Dataopsamling og modellering. Vi skal lave vores eget måleinstrument til måling af temperatur i området fra ca. -20 grader Celsius til ca. +100 grader. Til det bruger vi Arduino og temperaturføleren (sensoren) LM335, som vi bruger til at lave vores egen temperaturprobe. Vi laver først en prøveopstilling på et breadboard. Når vi har fået den til at virke, så laver vi en probe ved at lodde ledninger til sensoren og ved at krympe ca. 25 cm krympeflex (speciel plastik som krymper når den varmes op) rundt om sensoren og ledningerne.

Inden vi går i gang med at lave prøveopstillingen er det vigtigt at studere sensoren og det kredsløb som vi skal bruge den i, -og der er databladet fra producenten en rigtig god kilde.

Det er også en god ideé at se hvordan andre har løst opgaven før, -og der er fotografier fra tidligere projekter en rigtig god kilde.

Begynd derfor med at studere følgende kilder.

  1. Databladet for LM335, http://www.ti.com/lit/ds/symlink/lm335.pdf. (Vi har denne gang fået leveret komponenter som er produceret af ST og her er en link til deres version af databladet for LM335, http://www.st.com/web/catalog/sense_power/FM89/SC294/PF63712. Layoutet af ST's datablad er lidt anderledes, men indholdet skal være det samme i alle væsentlige henseende.) Bemærk specielt følgende sektioner og/eller data og/eller diagrammer:
    1. DESCRIPTION, som indeholder en generel beskrivelse af hvad denne transducer (sensor) kan bruges til.
    2. Schematic Diagram, som viser den interne elektroniske opbygning af sensoren. Der kan vi se at det handler om et integreret kredsløb (IC) med flere transistorer, kondensatorer og modstande.
    3. Absolute Maximum Ratings, som indeholder information om hvilke strømme, spændinge og temperaturer vi kan tillade os at udsætte sensoren for.
    4. Temperatur Accuracy, som indeholder tabeller som viser hvor præcist vi kan forvente at måle temperaturen med denne censor.
    5. asdf
  2. Vores billedgalleri fra 2011, som viser klasse 1.6 (den gang) i gang med lignende arbejde, http://www.rtgkom.dk/gallery.php?gallery=2011_11_22__Klasse_1.6_maaler_temperatur_med_Arduino_og_LM335. Bemærk hvordan de fremstiller proben!

Arduino, Lego Mindstorms og iRobot Create, Gkb 13:39, 4 February 2014 (CET)[edit]

I modulet i dag

  • fortsatte ca halvdelen af klassen med Arduino. Nogle skulle lige få det sidste på plads for at få eksemplet Graph til at virke og andre arbejdede med egen modifikationer af opstillingen. Andre afprøvede nogen af de shields vi har til Arduino, eller noget andet.
  • begyndte tre grupper, med to i hver, at afprøve vores iRobot Create roboter. De skulle først lære at sende kommandoer, i form af talkoder, til roboten via serial interfacet ved hjælp af programmet RealTerm. De skulle bruge information om kommandoerne fra PDF dokument med titlen Open Interface. Til sin støtte havde de også en artikel fra Linux Journal, Having fun with iRobot Create. De skulle finde hvordan de kunne sætte roboten til at køre det demoprogram som får den til at køre i en 8-tals-formet bane og stoppe ved første sammenstød.
  • resten af klassen byggede to selvkørende roboter af vores gamle Lego Mindstorms byggesæt.

Husk at poste en lille note på jeres StudieWeb, billeder og lidt tekst.

Læseøvelse for en tekst om Arduino, Gkb 15:59, 10 January 2014 (CET)[edit]

I denne øvelse skal vi læse en kort tekst på engelsk om den smarte mikrokontroller Arduino. Denne øvelse er en prototype på en online læsevejledning, så I hjælper mig altså med afprøvning af denne prototype hvis I vil være så venlige at gennemføre øvelsen nu i dag eller i løbet af weekenden.

Teksten er her: http://arduino.cc/en/Guide/Introduction

Brug læsevejledningen nedenfor og når du har gjort det, så log ind i wiki'en og skriv en kort kommentar om hvordan det virkede for dig at bruge sådan en vejledning til at læse denne type af tekst.

Læsevejledning for What is Arduino?[edit]

  • Brows frem til oplægget til teksten, http://arduino.cc/en/Guide/Introduction
  • Skim teksten (ca. 30 sek) for at se hvor mange afsnit den består af og læs overskrifterne for alle afsnit.
  • For hvert afsnit i teksten gør følgende:
  1. Læs afsnittet.
  2. Noter ned på papir/editor op til tre begreber (navnord) fra afsnittet som er nye for dig.
  3. Søg efter deres definition f.eks. via Google, Metacrawler, Britanica, emu.dk eller andre opslagsværker.
  4. Skriv en kort definition af begrebets betydning på dit papir/editor.
  5. Kontroller følgende læsespørgsmål, læs dem og tænk dig om, og svar dig selv i dine tanker. Skriv intet ned!
    1. Har jeg forstået alle begreberne i afsnittet?
    2. Har jeg forstået teksten i afsnittet?
  • Reflektion over hele tekstens mening og kontekst. Skim hele teksten over på ca. 30 sekunder og stil dig selv spørgsmålet: Har jeg fårstået det vigtigste i denne tekst? Hvis du kan svare med et ja, så er det fint. Ellers skal du evt. gentage læseøvelsen, -hvis der er tid. Kontroller specielt at du har forstået de nye begereber.

Husk at logge ind i wiki'en og skrive lidt om hvordan det virkede for dig at lave øvelsen.

Feedback på øvelsen[edit]

Log ind i wiki'en og skriv en kort kommentar, i den sektion som forberedt for dig, om hvordan det virkede for dig at lave øvelsen. For eksemple kan du skrive hvad var let eller svært, og hvad kunne forbedres i læsevejledningen?

Adam Poul Kjærum[edit]

Anders Møllnitz[edit]

Casper Lykke Larsen[edit]

Christopher Snedker Simonsen[edit]

Dan Henrik Sørensen[edit]

Frederik Bagger[edit]

Frederik Franklin Eriksen[edit]

Frederik Zeilberger Thulstrup[edit]

Hussein Al-Saidi[edit]

Jacob Balle Ruager[edit]

Jacob Ditlev Sørensen[edit]

Jacob Elmkjær[edit]

Jacob Pihlkjær Hjortshøj[edit]

Jakob Jelstad[edit]

Jonatan Geysner Hvidberg[edit]

Kevin Høst Husted[edit]

Lars-Emil Jakobsen[edit]

Teksten var let forståelig, så jeg havde ingen problemer med at forstå de enkelte afsnit. Siden teksten var så let, som den var for mig, havde jeg ingen problemer i at forstå de begreber der blev brugt. Der var dog enkelte ord som jeg ikke forstod, men ved at læse længere hen, fandt jeg også svar på det.

Lige til den her tekst var læseguiden måske unødvendig, men konceptet med at notere begreber, jeg ikke forstår, for derefter at finde forklaring på dem, hjælper mig altid med forståelsen af teksten.

Man kunne godt måske i forbindelse med guiden, lave en kort opsamling i klassen, hvor man diskuterede meningen af de begreber, man hver i sær havde fundet.

Mads Gundberg Poulsen[edit]

Mads Hougaard[edit]

Mathias Wissing-Thornberg[edit]

Philip Elbek[edit]

Rune Kofoed-Nissen[edit]

Thomas Denckert Hernes[edit]

Thomas Gram[edit]

Toshiki Mimura[edit]

Reflektion over arbejdet med Python i efteråret og blik fremad, en plenumdiskussion, Gkb 17:48, 7 January 2014 (CET)[edit]

Vi diskuterede i plenum vores arbejde med Python i efteråret. Diskussionen tog afsæt i den øvelse/forløb om lysbrydning, som klassen snart stareter i fysik. Vi diskuterede hvordan de nu kan bruge vores kendskab til Python og modulet Visual til at programmere modeller af en laserstråles vej i gennem et prism. Der var både positive og negative kommentarer til at vi faktisk har brugt så megen tid på Python, men den afsluttende kommentar summerede nok ret godt op, men den gik ud på at syntaxen i Python var lettere at lære end i de fleste andre sprog, og at det derfor nok var en fordel for nybegyndere at bruge Python.

Vi vendte nu blikket fremad og diskuterede med afsæt i mikrokontrolleren Arduino hvordan vi kan arbejde med dataopsamling og lave vores egen måleinstrumenter. Vi prøvede at finde frem PDF filen med specifikationen for ATMEGA328P, men det er mikrokontrolleren i Arduino'en. Vi skimmede dokumentet og stoppede lidt ved afsnittet om Analog Digital Converter kredsløbet i den. Vi lagde mærke til at metoden som bruges til at konvertere det analoge spændingssignal til digital format kaldes successive approximation. Jeg forsøgte at tegne en skites på tavlen som skulle vise hvordan et analog signal fra en spændingsdeler kobles til analog indgang nr. 0 på Arduino'en. Vi satte forsyningsspændingen Ucc til 10 Volt, og så diskuterede vi lidt hvordan spændingen varierer når vi ændrer den nederste modstand og hvordan vi får forskellige binære representationer for spændingsværdierne 0 V, 5 V og 2,5 V.

      • Foto af tavlen?***

Vi aftalte at lave en øvelse med Arduino, hvor vi måler spændingen over en transducer (sensor) som f.eks. en LDR (Light Dependent Resistor). Det tager nok to moduler.

Vi sluttede med at prøve at få gang i en Arduino, men modulet var slut og USB driveren drillede.

Stavekontrol - en spike solution, --Gkb 17:03, 19 December 2013 (CET)[edit]

Vi diskuterede lidt hvordan vi skulle bruge dette sidste modul inden juleferien. For at vise hvordan faget Informationsteknologi B kan bidrage med noget positivt i flerfaglig sammenhægn, så bestemte vi os at hjælpe lidt til med arbejdet i faget Engelsk. Det ville vi gøre ved at prøve at lave et program med Python til at kontrollere stavning på vores engelske stile og andre tekster.

Først skrev vi en definition af kærneproblemet i ren prosa (almindelig tekst) og med pseudokode.

Dernæst begyndet en iterativ implementering i kode af pseudokoden. Her følger kildekoden sådan som den så ud ved slutningen af modulet.

#Stavekontrol, en spike solution for.
#Udviklet i dialog med klasse 2.4, i 3. modul, i lokale C311, torsdag 2013-12-19
#ordbog = ["He", "was", "big"]
ordbog = []
f=file("ordbog.txt", "r")
for ord in f:
    print ord, type(ord)
    ordbog.append(ord.rstrip())

print ordbog

tekst = "He wws big"
for ord in tekst.split():
    if ord not in ordbog:
        print ord
        print "Fejl!"
        
#stavekontrol_gkb_v04.py Her vil jeg forsoege at hente ordbogen
#  fra en teksfil. Jeg kalder filen ordbog.txt.
#stavekontrol_gkb_v05.py Her loeser jeg problemet med \n i enden paa ordene.

Juleprodukt - en fri øvelse med lidt animation, --Gkb XX:XX, 17 December 2013 (CET)[edit]

Vi lavede et juleprodukt som blev publiseret på vores StudieWebb's.

Karavene var at produktet skulle være lovligt at lave og det skulle være anstændigt at publisere. Det skulle indeholde en animation, og så skulle det gerne, men ikke nødvendigvis, have lidt forbindelse med julen. Værktøjer kunne vælges frit. Produktet skulle gøres færdigt og uploades og præsenteres med en kort kommentar om værktøjerne, deres licens og pris, samt hvordan de blev anvendt til at fremstille produktet.

Eksponentielle modeller, registrering af arbejdsgrupper til brug ved oprettelse af projektbrugere, --Gkb 12:58, 3 December 2013 (CET)[edit]

Vi kan bruge specielle projektbrugere til at aflevere projekter som flere elever har arbejdet sammen på. Til at oprette projektbrugere i vores system, så behøver vi brugernavnene på de brugere som er med i arbejdsgrupperne. Tilføj derfor jeres brugernavne i listen nedenfor. Kontroller at brugernavnet er korrekt, kopier det gerne fra URL'en til jeres StudieWeb. Brugernavnene kopierer vi så ind i vores OEP program (et Perl script, lavet af Nicholas Mossor Rathmann, tidligere elev på RTG) når vi opretter projektbrugeren for jeres projekt. Hvis der er fejl i brugernavnet, så mislykkes oprettelsen af projektbrugeren.

  1. Adam, Casper: adampk12, casperll12
  2. Anders Mads P: andersm12, madsgp12
  3. Christopher Philip: christopherss12, philipe12
  4. Dan Jacob E: danhs12, jacobe12
  5. Frederik B. Rune: frederikb12, runekn12
  6. Frederik T. Jacob S. Toshiki: frederikzt12, jacobs12, toshikim12
  7. Hussein Jakob:husseinas12, jakobj12
  8. Jacob H. Jonatan, jacobph12, jonatangh12
  9. Kevin Mads H. kevinhh12, Madsh12
  10. larsej12 jacobbr12
  11. Mathias Thomas H. mathiaswt12 thomasdh12
  12. Thomas G. Frederik E: thomasg12, frederikfe12

Generering af store data set. Philiph10 16:33, 26 November 2013 (CET)[edit]

Lange lister af data kan være meget brugbare, især til tester af programmer kan det være nødvendigt at sikre sig at det fungere ikke kun med en eller to inputs, men med millioner. Forstil dig for eksempel googles stemmegenkendelse, den skal kunne forstå en amerikansk, engelsk, skottisk, tysk, svensk og enda dansk accent. Der skal altså tusindevis hvis ikke millioner lyd samples til for at checke at systemet kan forstå et ord, selv hvis det bliver sagt af folk fra hele verdenen.

Det er dog ikke altid nemt at for fat i prøver, det kan tage tonsvis af arbejde, og flere år. Heldigvis er det muligt at lave sine egne samples, lidt afhængigt af hvad man har brug for kan det gøres med nogle simple linjer kode.

Nedenfor er et kort python script jeg har skrevet til at generere et 8 cifret falsk person nummer, og et navn. Scriptet er meget simpelt og kunne godt bruge noget kærlighed, især til at skrive personnumre der følger den standard rigtige numre har (En dato der giver mening for eksempel). Det giver dog en ide om hvor nemt det kan være at generere store data set, hvis man ikke har adgang til nogle fra den virkelige verden.

print_names.py[edit]

import random

f = open("person_list.txt", "w")

first_names = ["Adam", "Bodil", "Christian", "Daniel", "Erik", "Frederik"]
last_names = ["Hansen", "Jensen", "Petersen", "Clausen", "Fransen", "Larsen"]

print "Writing to file..."
for i in range(10000000):
    f.write(str(random.randint(12345678, 98765432)) + " " + \
              first_names[random.randint(0, len(first_names) - 1)] + " " + \
              last_names[random.randint(0, len(last_names) - 1)] + "\n")
f.close()
print "Write done!"

Scriptet resultere i en meget meget lang tekst fil, der ser ud som denne, men fortsætter i 10.000.000 linjer

person_list.txt[edit]

84723441 Bodil Hansen
77335912 Daniel Clausen
54585757 Bodil Petersen
94217210 Bodil Jensen
20545372 Daniel Larsen
76982763 Adam Larsen
78121055 Bodil Petersen
27356129 Erik Larsen
47707392 Adam Larsen
94172810 Frederik Clausen
26369579 Bodil Jensen
48817558 Adam Hansen
32112096 Daniel Clausen
72828323 Daniel Fransen
35490090 Bodil Fransen
64738057 Frederik Petersen
50422540 Frederik Clausen
17616082 Frederik Clausen
31796297 Christian Hansen
17544226 Frederik Hansen
97265934 Daniel Hansen
35151363 Daniel Petersen
39468567 Frederik Larsen
16073929 Erik Clausen
68646789 Adam Hansen
24180227 Frederik Fransen
24069938 Erik Clausen
44827913 Adam Petersen
15287336 Erik Petersen
76141309 Christian Petersen
79734504 Adam Larsen
38454069 Christian Jensen
92008992 Erik Hansen
85829984 Bodil Hansen
53353173 Bodil Hansen
57147519 Adam Hansen
87228413 Bodil Fransen
37118447 Frederik Petersen
40659477 Bodil Jensen
22478342 Adam Petersen
40560797 Bodil Hansen
62247491 Bodil Clausen
38080475 Christian Fransen
91475156 Adam Hansen
22698526 Christian Jensen
70008550 Bodil Petersen
39550704 Bodil Jensen
46651630 Frederik Petersen
17955558 Daniel Jensen
58983372 Erik Clausen

To eller flere grafer og grafer med flere plots, igen med visual.graph, --Gkb 15:05, 21 November 2013 (CET)[edit]

Når jeg lavede den nedenfor beskrevne spike solution om hvordan man laver grafer i almindelighed og hvordan man laver semilogaritmiske grafer med visual.graph modulet, så så jeg også hvordan vi kan lave flere grafer på en gang, og her er en spike solution som viser det.

spike_for_flere_grafer_med_visual_graph_gkb_v01.py[edit]

# -*- coding: cp1252 -*-
#spike_for_flere_grafer_med_visual_graph_gkb_v01.py
#Lavet med afsæt i http://www.vpython.org/contents/docs/graph.html

from visual import * # must import visual or vis first
from visual.graph import *	 # import graphing features 

#Først laver vi et graphics display, altså vi laver en objektvariabel,
#også kaldt instans, af klassen gdisplay(). 
gd1 = gdisplay(logy=False, logx=False, x=0, y=0, width=600, height=350, 
      title='y = 2**x', xtitle='x', ytitle='y=2**x', 
      foreground=color.black, background=color.white, 
      xmax=10, xmin=1, ymax=1000, ymin=1)
f1 = gcurve(gdisplay=gd1, color=color.cyan) # Vi vælger at bruge et gcurve objekt til at plotte kurven.
for x in arange(1, 11, 1):
    f1.plot(pos=(x, 2**x))    # Her tilføjer vi datapunkterne, en efter en.
    print(x, 2**x)            # Her udskriver vi x og y værdierne i shell'en til lettere
                              # at kunne kontrollere at grafen korrekt viser vores datapunkter.

#Her laver vi så graf nr 2, og vi sætter to plots i denne graf.
gd2 =gdisplay(x=0, y=350, width=600, height=350, foreground=color.black, background=color.yellow)
f2 = gcurve(gdisplay=gd2)
for x in arange(1, 11, 1):
    f2.plot(pos=(x, x**3))
    
f3 = gcurve(gdisplay=gd2)
for x in arange(1, 11, 1):
    f3.plot(pos=(x, x**4))

#Og her kunne vi fortsætte med graf nr. 3, osv.

Når vi eksekverer denne kode, så laver den to grafer. Den ene har to plots. Her er et skærmbilled som viser resultatet.

http://rtgkom.dk/~gkb/billeder/spike_for_flere_grafer_med_visual_graph_gkb_v01_screen_dump_640x480.png

Semilogaritmisk graf med visual.graph, --Gkb 15:05, 21 November 2013 (CET)[edit]

En af projektgrupperne ønskede i dag at anvende Python modulet 'visual.graph' til at lave semilogaritmiske grafer. Med afsæt i dokumentationen på http://www.vpython.org/contents/docs/graph.html lavede vi nogle eksperimenter.

Motivering[edit]

En anledning til at lave en graf med logaritmen af funktionsværdierne eller måledata på andenaksen (y-aksen) kan være ønsket visuelt at vurdere om datapunkterne tilnærmelsesvis ligger på en ret linje, -det indikerer nemlig rent matematisk at funktionen som beskriver sammenhængen mellem den uafhængige variabel (ofte x) og den afhængige variabel (ofte y) sandsynligvis er en exponentiel funktion på formen

f(x) = b*a**x (med Python syntax)

Konstanten b kaldes begyndelsesværdien og a kaldes fremskrivningsfaktoren.

Se gerne følgende kilder for nærmere definition af de matematiske begreber.

Spike solution[edit]

Først ser vi på hvordan vi kan lave en graf med tre plots. Dernæst ændrer vi andenaksen (y-aksen) således at den bliver logaritmisk. Ved at vælge en exponentiel funktion og to polynomier af 3. og 4. grad, så kan vi bruge dette program til at observere effekten af det at ændre inddelingen på y-aksen.

spike_solution_for_graf_med_flere_kurver_med_visual_graph_gkb_v01.py[edit]

# -*- coding: cp1252 -*-
#spike_solution_for_graf_med_flere_kurver_med_visual_graph_gkb_v01.py
#Lavet med afsæt i http://www.vpython.org/contents/docs/graph.html

from visual import * # must import visual or vis first
from visual.graph import *	 # import graphing features 

#Først laver et graphics display, altså vi laver en objektvariabel,
#også kaldt instans, af klassen gdisplay(). Bemærk at hvis vi ikke ønsker
#at ændre på egenskaber som forgrundsfarve, position osv, og hvis vi ikke
#ønsker at lave mere end en graf, så behøver vi ikke lave denne variabel.
#Bemærk også at den gdisplay instans som vi laver, bliver default. Således
#at alle plots som vi laver derefter vil vises i den graf som den representerer.
gd = gdisplay(logy=False, logx=False, x=0, y=0, width=600, height=350, 
      title='En graf med tre plots, y1=2**x, y2=x**3 og y3=x**4', xtitle='x', ytitle='y', 
      foreground=color.black, background=color.white, 
      xmax=10, xmin=1, ymax=1000, ymin=1)

f1 = gcurve(color=color.red) # Vi vælger at bruge et gcurve objekt til at plotte kurven.
label(display=gd.display, color=color.red, pos=(2,2), text="y1=2**x")
for x in arange(1, 11, 1):
    f1.plot(pos=(x, 2**x))    # Her tilføjer vi datapunkterne, en efter en.
    print(x, 2**x)            # Her udskriver vi x og y værdierne i shell'en til lettere
                              # at kunne kontrollere at grafen korrekt viser vores datapunkter.
               
f2 = gcurve(color=color.green)  # Her tilføjer vi et nyt plot til grafen.
label(display=gd.display, color=color.green, pos=(4,2), text="y2=x**3")
for x in arange(1, 11, 1):
    f2.plot(pos=(x, x**3))
    print(x, x**3)        

f3 = gcurve(color=color.blue)  # Her tilføjer vi et nyt plot til grafen.
f3.plot(pos=[(1,1),(2,2**4),(3,3**4),(4,4**4),(5,5**4)])
label(display=gd.display, color=color.blue, pos=(6,2), text="y3=x**4")

Bemærk at både x-aksen og y-aksen har "normal" inddeling, altså er ikke logaritmiske. Dette kontrolleres med egenskaberne 'logy' og 'logx', som begge sættes til 'False' når vi laver displayet 'gd'. Denne kode resulterer i følgende graf. Tik mærkerne i grafen har labels af typen 1E1, 1E2 osv. Dette skal læses som 1*10**1 og 1*10**2 osv. http://rtgkom.dk/~gkb/billeder/en_graf_med_tre_plots_lavet_med_normal_y_akse_lavet_med_visual_graph.png

Hvis vi nu gør inddelingen af y-aksen logaritmisk ved at ændre 'logy=False' til 'logy=True' i koden ovenfor, så får vi følgende graf.

http://rtgkom.dk/~gkb/billeder/en_graf_med_tre_plots_lavet_med_logaritmisk_y_akse_lavet_med_visual_graph.png

Vi bemærker at den røde kurve som representerer den exponentielle funktion y=2**x nu afbildes med et plot som virker ret tæt på at være en del af en ret linje.

Nu når vi har lavet programmet så kan vi ikke lade være at undersøge hvordan kurverne vil se ud hvis vi også sætter inddelingen af x-aksen til at være logaritmisk. Det resulterer i følgende graf.

http://rtgkom.dk/~gkb/billeder/en_graf_med_tre_plots_lavet_med_logaritmisk_y_akse_og_logaritmisk_x_akse_lavet_med_visual_graph.png

Vi bemærker at nu er det polynomierne som virker være plottet med rette linjer. Kan vi driste os til at drage den konklusion at alle polynomier afbildes med rette linjer i dobbelt logaritmiske grafer?

Indlæsning af data fra en tekstfil, --Gkb 12:26, 21 November 2013 (CET)[edit]

Her er et eksempel på hvordan vi kan indlæse data fra en tekstfil.

f=file('datafil.txt',mode='r')
for line in f:
    print line

Hvis vores datafil indeholder følgende data.

1, 10
2, 19
3, 33
4, 37
5, 50

Så bliver resultate af kørsel af programmet som vist her.

>>> 
1, 10

2, 19

3, 33

4, 37

5, 50

>>> 

Det er selvfølgelig et uløst problem at vi har de to talværdier samlet i string variablen 'line', og vi således ikke direkte kan bruge dem i udregning i vores program. Vi har altså behov for at hente disse to talværdier fra strængen og konvertere dem til 'int' eller 'float' og lagre dem i variabler som vi kan bruge i vores udregninge. En måde at opnå dette er følgende.

spike_for_inlaesning_af_data_fra_en_tekstfil_gkb_v03.py[edit]

# -*- coding: cp1252 -*-
f=file('datafil.txt',mode='r')
for line in f:
#    print line
    x , y = (item.strip() for item in line.split(','))
    #print item.strip()
    print x, y, x+y  #Bemærk at vi fortsat arbejder med strings
    x = float(x)
    y = float(y)     #Bemærk at vi nu arbejder med variabler af typen float
    print x, y, x+y   
f.close()

Når vi kører dette script, så får vi følgende output i shell'en.

>>> 
1 10 110
1.0 10.0 11.0
2 19 219
2.0 19.0 21.0
3 33 333
3.0 33.0 36.0
4 37 437
4.0 37.0 41.0
5 50 550
5.0 50.0 55.0
>>> 

Bemærk det forskellige resultat af af addere henholdsvis strænge og floats!

2013-11-12, tirsdag: Dataanalyse fortsat, Gkb[edit]

Arbejdet med dataanalysen fortsatte. Vi ville blandt andet afbilde datasættet ved hjælp af modulet Matplotlib, men det lykkedes kun for nogle få af dem som arbejder på Windows. Efter installering af Matplotlib, viste det sig at der var flere andre moduler som skulle installeres før Matplotlib (eller var det Matplotlib.pylab?) kunne bruges. På Ubuntu 13.04 var der ingen problemer.

2013-11-07, torsdag: Dataanalyse Gkb[edit]

Vi udviklede i fælleskab, i C3104, en spike solution i Python til at udregne middelværdien af den afhængige variable i et test-datasæt.

Vi tilføjede også kode til at finde mindste og største værdi i datasættet.

data_analyse_spike01_gkb_v08.py[edit]

Vi resonerede os i fælleskab på projektoren fram til følgende spike solution.

Data=[(273.15,  1.00),   \
      (540,     -2.00),   \
      (1000,    4.00)]

print Data
SumVolumen = 0

#Vi proever foerst at udregne middelvaerdien
for i in range(len(Data)):
    #print Data[i][0]
    SumVolumen = SumVolumen + Data[i][1]
    print SumVolumen

print "Middelvaerdien for volumen er :", SumVolumen/len(Data), "m3"

#Nu proever vi at finde den mindste vaerdi
MindsteVaerdi=9999
for peter in range(len(Data)):
    print peter
    if MindsteVaerdi > Data[peter][1]:
        MindsteVaerdi = Data[peter][1]
print "MindsteVaerdi'en er: ", MindsteVaerdi

2013-11-05, tirsdag: Nyt projekt, Gkb[edit]

Vi startede arbejdet med det nye projekt. Vi diskuterede forskellige værktøjer til at analysere data, og laved lidt spike solutions i Python.

2013-10-29, tirsdag: Dokumentation af arbejdet med IT-delen af Kulturelle observationer i London-bydele, Gkb[edit]

Her er et forslag til hvordan arbejdet med GPS-delen af studietursprojektet kan dokumenteres.

Skriv en logbog (journal). Følgende emner kan indgå i den:

  • Hvad I lavede, uge for uge, og dag for dag.
  • Kort overblik over hvad GPS er, og hvordan det virker.
  • Hvordan I afprøvede GPS tracking inden studieturen.
  • Hvilke programmer (applikationer) I brugte til selve tracking-opgaven.
  • Eksempel på GPS-tracking data (f.eks. som et skærmbilled fra en editor når I har åbnet en GPX (GPS eXchange Format) fil.
  • Hvilke programmer I evt. har anvendt til at komvertere fra et GPS filformat til et andet.
  • Hvilken online kort-tjenester I har uploadet jeres track (eller tracks) til og hvordan I gjorde det.
  • Hvordan I har redigeret i jeres GPS data, evt. både før og efter upload.
  • Reflektion over hvordan publisering af GPS tracks kan krænke vores egen eller andres personlige integritet, og hvordan editering af tracks kan bruges til at værne om vores privatliv.

Til genopriskning, så er her en kopi af de afsnit i oplægget som direkte vedrører IT delen:

Herudover skal grupperne registrere den vej, de går i bydelen ved hjælp af en eller flere GPS-modtagere. Ruten skal indføres i et kort over bydelene og indgå i gruppens præsentation (brug gerne nogen af gruppemedlemmernes mobiltelefoner). Brug gerne flere end en telefon, da kontakten til satellitterne kan afbrydes, og det kan være godt at have komplementerende datasæt, når ruten senere skal redigeres og publiceres).

Teknikken og GPS-systemets virkemåde (funktion) skal undersøges, og der skal gøres rede for den, samt de mest almindelige formater for lagring af GPS-data. Gør rede for hvordan anvendelse af GPS kan påvirke vores personlige integritet. Grupperne skal søge og finde egnet software til at løse opgaven.

Når I beskriver hvad I gjorde og hvordan, så prøv at skælne til de fire mål fra IT faget som vi har fremhævet i dette projekt. Prøv at tænke over hvilke af jeres aktiviteter bidrager til opfyldelese af målene. Her er en kopi af målene fra oplægget:

  • Redegøre for grundlæggende funktioner af it-komponenter (hardware og software) og samspillet mellem dem
  • Analysere og beskrive sikkerhedsbehov og risikofaktorer ved brug at et givent it-system
  • Vælge og bruge it-komponenter som værktøj til løsning af et problem med relation til elevens, uddannelsens, virksomheders og samfundets brug
  • Anvende it som interaktivt medie til dokumentation og kommunikation

Logbogen (journalen) afleveres på en projekt-user som er fælles for hele gruppen. Den enkelte gruppemedlem præsentere kort en link til denne på sit eget StudieWeb.

2013-09-26, torsdag modul 3: Animation ved hjælp af bevægelsesligningerne, fortsat, Gkb[edit]

Vi så lidt nærmere på bevægelsesligningen

s(t) = s0 + v0*t + (1/2)*a0*t**2

og hvordan den kan udtrykkes vha. vektorer. Vi aftalte en notation til brug ved definition af startbetingelserne og så lavede vi en prototype til et program som viser en animation hvor en boks og en kegel ses flytte sig fra to forskellige startpositioner med samme starthastighed men forskellig acceleration. Koden, sådan som den var når vi sluttede modulet, følger her.

animation_med_bevaegelsesligningerne_gkb_v02.py[edit]

from visual import *
cylinder(pos=(0,0,0), axis=(10,0,0), radius= 0.05, color=color.red)
cylinder(pos=(0,0,0), axis=(0,10,0), radius= 0.05, color=color.green)
cylinder(pos=(0,0,0), axis=(0,0,10), radius= 0.05, color=color.blue)

Boks01=box()
Kegel01=cone()

s0xB01=0 #m
s0yB01=0 #m
s0zB01=0 #m

v0xB01=2 #m/s
v0yB01=10 #m/s
v0zB01=0 #m/s

a0xB01=0 #m/s**2
a0yB01=-1 #m/s**2
a0zB01=0 #m/s**2

s0xK01=4 #m
s0yK01=0 #m
s0zK01=0 #m

v0xK01=2 #m/s
v0yK01=10 #m/s
v0zK01=0 #m/s

a0xK01=0 #m/s**2
a0yK01=-2 #m/s**2
a0zK01=0 #m/s**2

for t in arange(0, 10, 0.2):
    rate(5)
    Boks01.pos=(s0xB01+ v0xB01*t + 0.5*a0xB01*t**2, \
                s0yB01+ v0yB01*t + 0.5*a0yB01*t**2, \
                s0zB01+ v0zB01*t + 0.5*a0zB01*t**2)
    Kegel01.pos=(s0xK01+ v0xK01*t + 0.5*a0xK01*t**2, \
                s0yK01+ v0yK01*t + 0.5*a0yK01*t**2, \
                s0zK01+ v0zK01*t + 0.5*a0zK01*t**2)

animation_med_bevaegelsesligningerne_gkb_v06.py[edit]

Efter lidt efterbearbejdning, i dag, fredag d. 27. sept, hvor jeg har tilføjet både nogle lodrette hjælpelinjer (cylinder's) og kurver (curve's) for at vise de to objekters baner, så så modellen sådan ud efter at animationen stoppede.

http://rtgkom.dk/~gkb/billeder/box_og_kegel_skraat_kast_fra_origo_med_forskellig_acceleration_320x256.png

NB at jeg har ændret startpositionen for keglen, således at begge objekter nu starter i origo, de har samme begyndelseshastighed, men forskellig acceleration, nemlig henholdsvis -1 og -2 (m/(s**2)), altså nedad! Vi forventer derfor at de flytter sig lige langt ud ad x-aksen, men at de stopper i forskellige højder. Kopier koden og eksperimenter med at ændre startbetingelserne for position, hastighed og acceleration.

from visual import *

cylinder(pos=(0,0,0), axis=(50,0,0), radius= 0.5, color=color.red)

cylinder(pos=(0,0,0), axis=(0,50,0), radius= 0.5, color=color.green)
for x in range(0,51,10):
    cylinder(pos=(x,0,0), axis=(0,50,0), radius= .25, color=color.red)
    
cylinder(pos=(0,0,0), axis=(0,0,50), radius= 0.5, color=color.blue)

Boks01=box(size=(4,4,4))
Kegel01=cone(radius=4, axis=(4,0,0))

KurveForBoks01 = curve()
KurveForBoks01.append(Boks01.pos)
KurveForKegel01 = curve()
KurveForKegel01.append(Kegel01.pos)

s0xB01=0 #m
s0yB01=0 #m
s0zB01=0 #m

v0xB01=2 #m/s
v0yB01=10 #m/s
v0zB01=0#10 #m/s

a0xB01=0 #m/s**2
a0yB01=-1 #m/s**2
a0zB01=0 #m/s**2

s0xK01=0#4 #m
s0yK01=0 #m
s0zK01=0 #m

v0xK01=2 #m/s
v0yK01=10 #m/s
v0zK01=0 #m/s

a0xK01=0 #m/s**2
a0yK01=-2 #m/s**2
a0zK01=0 #m/s**2

for t in arange(0, 10, 0.2):
    rate(30)
    Boks01.pos=(s0xB01+ v0xB01*t + 0.5*a0xB01*t**2, \
                s0yB01+ v0yB01*t + 0.5*a0yB01*t**2, \
                s0zB01+ v0zB01*t + 0.5*a0zB01*t**2)
    KurveForBoks01.append(Boks01.pos)
    Kegel01.pos=(s0xK01+ v0xK01*t + 0.5*a0xK01*t**2, \
                s0yK01+ v0yK01*t + 0.5*a0yK01*t**2, \
                s0zK01+ v0zK01*t + 0.5*a0zK01*t**2)
    KurveForKegel01.append(Kegel01.pos)

2013-09-19, torsdag modul 3: Animation ved hjælp af bevægelsesligningerne, Gkb[edit]

På grund af et spørgsmål fra Lars om hvordan vi kan bruge Visual til at animere flere objekters bevægelser individuelt, altså således at de ikke alle translateres eller roteres på samme måde, så har jeg forsøgt at give et kort overblik over hvordan man kan bruge bevægelsesligningerne fra fysiken til at implementere en løsning på dette problem.

Det korte og lidt generelle svar er[edit]

Brug en løkke og brug den variabel som du ændrer for hver gennemgang af løkken (kaldes lidt varierende f.eks. loop-variabel, kontrolvariabel, index variabel, iterationsvariabel) til at ændre positionen for dine objekter. Du kan ændre flere objekters position inde i løkken. Noget i stil med:

for x in range(0, 10):
    boks01.pos=(x, 0, 0)
    kegel01.pos=(x, x*x, 0)

Mere generelt med bevægelsesligningerne[edit]

Det kan være at du synes det være lidt begrænsende hvis du laver en løkke og lader f.eks. x være din loop-variable, så kan du evtentuelt tro at du kun kan ændre x-positionen for dine objekter, -men det passer jo ikke, -og det har jeg demonstreret i det forudgående eksempel hvor jeg har brugt værdien af x til både at ændre x og y koordinaten for kegel01.

Dette kan bruges mere generelt ved at forestille sig at vores loop-variabel representerer tiden, altså at måden vi ændrer den simulerer hvordan tiden går for vores animation. Og så kan vi bruge de fra fysiken velkendte bevægelsesligninger til at udregne x, y og z koordinaterne for vores objekter i animationen. Dette kan evt. visualiseres bedre med et eksempel.

from visual import *

boks01=box()
kegel01=cone()

s0b01=2 #m
v0b01=1 #m/s
ab01=9.8 #m/s**2

s0k01=-2 #m
v0k01=-1 #m/s
ak01=5.0 #m/s**2

for t in range(0, 10):
    rate(2)
    boks01.pos=(s0b01 + v0b01*t + 0.5*ab01*t**2, 0, 0)
    kegel01.pos=(s0k01 + v0k01*t + 0.5*ak01*t**2, 0, 0)

2013-09-10, tirsdag modul 3: 3D modellering med Visual, Gkb[edit]

Der blev arbejdet individuelt med opgaven som skal afleveres d. 16. september. Oplægget til opgaven er her: http://rtgkom.dk/wiki/2013InfB24:_3D_modellering_med_Visual

Vi atalte at afleveringen på StudieWebbet skal ske i en mappe med et bestemt navn, og at jeg opretter mapperne for alle. Det giver et bedre overblik over filerne som hører til afleveringen.

Jeg oprettede mapper hos alle i klassen. De fik navnet 3d_modellering_med_visual.

2013-09-05, torsdag modul 3: POV-Ray demo og styring med tastaturtaster og mus af programmer lavet med Visual, Gkb[edit]

I dag havde vi to punkter på programmet:

  1. POV-Ray demo
  2. Styring med tastaturtaster og mus af programmer lavet med Visual

POV-Ray demo[edit]

Animation med POV-Ray, hvordan?[edit]

Vi så først hvordan man kan lave flere stilbilleder (frames) af en scene med en .ini fil. Og vi så at det kan tage ret lang tid at rendere de enkelte billeder. Man kan ikke lave en egentlig animation med POV-Ray, man laver bare en sekvens med mange billeder hvor objekterne flyttes lidt for hvert billed. Selve 3D modellen er i .pov filen og .ini filen brugs til at definere hvor mange frames der skal laves og hvilken .pov fil skal rendereres. Her er indholdet i den .ini fil som vi brugte til demonstrationen.

; Persistence Of Vision raytracer version 3.5 sample file.

Antialias=Off

Antialias_Threshold=0.1
Antialias_Depth=2
Input_File_Name=bounce.pov

Initial_Frame=1
Final_Frame=500
Initial_Clock=0
Final_Clock=1

Cyclic_Animation=on
Pause_when_Done=off

Filen bounce.pov indeholder definitionen af scenen, altså af de 3D objekter og himmel, lys og kamera, som udgør vores 3D model. Filen ligger på min Windows XP i mappen C:\Documents and Settings\learner\My Documents\POV-Ray\v3.6\scenes\animations\boing hvor alle billedfilerne også er blevet lagret, -det bliver med de instillinger som vi har i denne ini-fil ret mange filer, nemlig 500 stykker.

Når alle billederne er lavet, så bruger vi et andet program til at føje dem sammen til en video. Det kan f.eks. være Smacker eller Bink fra http:\\radgametools.com.

En ny 3D model, hvordan[edit]

Vi demonstrerede på projektoren hvordan man kan lave en ny .POV fil og indsætte et kodeeksempel med funktionen Insert - Scene templates - Checkered floor Her er det grafiske resultat, sådan som det var ved afslutningen af vores eksperiment med POV-Ray, undtagen at jeg har tilføjet de tre cylindre for at markere hvor enhedsvektorerne ligger. Jeg har også flyttet lidt på kuglen og kameraet for at komponere et billed som viser både kuglen og enhedsvektorerne og kuglens skygger.

http://rtgkom.dk/~gkb/billeder/pov_demo_gkib_v02.png Programmet som vi brugte til at lave dette billed kommer her:

// Baseret på "Checkered Floor" examplet i hjælpesystemet.

#include "colors.inc"

camera {
  location  <4, 2, 4>
  look_at   <0.0, 0.0,  0.0>
}

sky_sphere {
  pigment {
    gradient y
    color_map {
      [0.0 rgb <0.6,0.7,1.0>]
      [0.7 rgb <0.0,0.1,0.8>]
    }
  }
}

light_source {
  <30, 30, 30>            
  color rgb <1, 1, 1>  
  //translate <-30, 30, -30>
}
light_source {
  <0, 30, 30>            
  color rgb <1, 1, 1>  
  //translate <-30, 30, -30>
}// light_source

plane {               // checkered floor
  y, -1
  texture
  {
    pigment {
      checker
      color rgb 1
      color blue 1
      scale 0.5
    }
    finish{
      diffuse 0.8
      ambient 0.1
    }
  }
}

sphere{
    <2,2,2>, .5 
    pigment{color rgb <1, 0, 0>  }
}        

//Enhedsvektorerne
cylinder{
    <0,0,0,>, <1,0,0>, 0.05
    pigment{color rgb <1, 0, 0>  }
}
cylinder{
    <0,0,0,>, <0,1,0>, 0.05
    pigment{color rgb <0, 1, 0>  }
}
cylinder{
    <0,0,0,>, <0,0,1>, 0.05
    pigment{color rgb <0, 0, 1>  }
}

Hjælpesystemet i POV-Ray[edit]

Vi så hvordan vi kan bruge hjælpesystemet til at finde information om betydningen af parametrene for de forskellige objekter som f.eks. camera, box og plan.

Right Handed or Left Handed?[edit]

Vi diskuterede hvordan z-aksen i Visual og POV-Ray peger henholdsvis ud mod os og fra os, når x-aksen peger mod højre. Det viste sig efter lidt undersøgelser, blandt andet i hjælpesystemet i POV-Ray, at koordinatsystemet som anvendes i POV-Ray er Left Handed, fordi man uden helt at brække sine fingere kan med venstre hånd pege ud (op) ad y-aksen med tommelfingeren, ud (ind i billedfladen) ad z-aksen med pegefinger og ud (til højre) ad x-aksen med langfinger. Man kan læse mere her i artiklen 1.2.1.1 Understanding POV-Ray's Coordinate System i online versionen af hjælpesystemet for POV-Ray, se her http://www.povray.org/documentation/view/3.7.0/15/.

Sammenhængen mellem antallet af pixels i billedet og rendereringstiden[edit]

Vi afprøvede flere forskellige opløsninger (resolutions) for det renderede 2D billed af vores 3D model, f.eks. 160x120 pixel, 1024x768 pixel med og uden anti-aliasing, og vi så at renderingstiden er kraftigt afhængig af antallet af pixels i billedet. Vi testede også at rendere et billed på 10000x5000 pixel, og så blev det rigtigt langsamt. Man kan selv tilføje opløsninger (resolutions) i drop-down boksen i POW-Ray, -så du kan lave meget større billeder hvis du vil og din computer kan.

Spike Solution for styring med tastaturtaster af programmer lavet med Visual[edit]

Efter en pause så vi på hvordan vi kan bruge et kode-eksempel fra online-dokumentationen for Visual,http://vpython.org/contents/docs/keyboard.html, til at ændre positionen af en boks ved at trykke på tasten for "b" eller "B". Koden for denne spike solution følger her. Vi tilføjede vistnok kun tre linjer.

#Inspireret af http://vpython.org/contents/docs/keyboard.html
from visual import *
box1=box() #Tilføjet af gkb
prose = label() # initially blank text
while True:
    rate(30)
    if scene.kb.keys: # event waiting to be processed?
        s = scene.kb.getkey() # get keyboard info
        if len(s) == 1:
            if s=="b" or s=="B":   #Tilføjet af gkb
                box1.pos=(10,0,0)  #Tilføjet af gkb
            prose.text = prose.text + s # append new character
        elif (((s == 'backspace' or s == 'delete') and len(prose.text)) > 0): 
            prose.text = prose.text[:-1] # erase letter
        elif s == 'shift+delete': 
            prose.text = 'det virker' # erase all text #Modificeret lidt af gkb

Nu kan vi integrere denne teknik i vores egen Visual programmer, f.eks. til at tænde og slukke for visning af enhedsvektorer, grid eller labels for akserne, osv.

2013-09-03, tirsdag: 3D modellering med Visual: IDE's, loops og flere, Gkb[edit]

2013-09-03, tirsdag, InfB24, 3. modul

Plenumdiskussion[edit]

Vi startede modulet med lidt reflektion over det arbejde vi har lavet indtil nu med 3D animation i Visual Python, altså med programmeringssproget Python ved hjælp af modulet Visual, hvor vi nu kan animere translation, rotation og resizing af de grundlæggende geometriske objekter som findes i Visual, som f.eks. box, sphere, cone, osv. I diskutionen kom blandt andet følgende emner op:

  • Klassens oplevelse af forløbet med Python og modulet Visual.
    • Syntax-fejl. Der var flere kommentarer om hvor irriterende det kan være når Python interpreteren finder fejl i kildekoden som vi skriver og stopper med en rød fejlmeddelelse i Python shell'en (Python terminalen). Ja, det kan være irriterende, men der er ikke andre muligheder når vi vil lære at styre en computer programmering, -selv de mindste syntax-fejl gør at programmet ikke bliver fortolket/interpreteret.
    • Semantiske fejl. Der var også kommentarer om at det ligeledes var frustrerende når programmet blev inteerpreteret uden fejl men ikke lavede det man havde tænkt sig at det skulle. Når dette sker, så kalder vi det en semantisk fejl, -altså en meningsfejl. Det er en fejl som vi selv gør når vi tænker og planlægger hvad vi ønsker at programmet skal gøre. Et program kan altså være helt uden syntax-fejl, men have en eller flere semantsike fejl, som gør at det ikke kan bruges til det tænkte formål. Det er helt normalt når vi lærer et nyt programmeringssprog at lave mange semantiske fejl. Når vi har lavet en lille ændring i kildekoden, så prøver vi at køre programmet igen og se om resultatet bliver det vi forventer eller håber på. Hvis vi er hældige og ikke har indført regulære syntaxfejl, så bliver vi ofte lidt skuffet, fordi programmet laver noget helt andet end det vi havde tænkt os at det skulle. Når vi betragter programmets output, så ser vi ofte straks hvilken fejl (meningsfejl) vi har begået, og så retter vi lidt i koden og prøver igen, og igen og igen ... Disse mikro-iterationer (gentagelser) kalder jeg for den generiske udviklingscyklus, og de representerer sandsynligvis en af de aktiviteter som vi lærer mest af, når vi skal lære at programmere. Den generiske udviklingscyklus er en model som forklarer noget helt centralt om hvordan vi arbejder i fagene i MediaLab. Ved at stille modellen op, så bliver det lettere for os at tale om hvordan vi arbejder, -og det er vigtigt! Jeg forsøger nu at illustrere modellen med lidt fancy wiki-formatting:
Her er modellen for den Generiske UdviklingsCyklus, GUC (har du et bedre navn?)
Editere lidt i koden → køre programmetundersøge output fra programmet → tænke/søge info og planlægge forbedringer af koden → editere igen, osv.
  • Udviklingsmiljøer for Python. IDLE, Eclipse og Eric IDE blev diskuteret.
  • Ophavsmanden til Python, Guido van Rossum. Det var i forbindelse med IDLE som vi syntes det var på sin plads at se hvem det er som vi kan takke for Python og IDLE.
  • En god bog for at lære at programmere med Python er "How to Think Like a Computer Scientist, Learning with Python", fra http://www.openbookproject.net/thinkcs/python/english2e/. Den er både fri at bruge og gratis.

Opgave om visualisering og animation af matematiske funktioner[edit]

Vi diskuterede at den opgave som klassen skal lave om 2 til 3 uger, kan handle om enkel visualisering og animation af matematiske funktioner, således at vi kan bruge det vi har lært om 3D modellering og animation med Visual.

Individuelt arbejde[edit]

Under resten af modeulet arbejdede vi og diskuterede blandt andet følgende:

  • Koordinatsystemet, left/right handed. Se evt. her for en forklaring: http://en.wikipedia.org/wiki/Right-hand_rule. Og her er en link til artiklen 1.2.1.1 Understanding POV-Ray's Coordinate System i online hjælpesystemet for renderingsprogrammet POV-Ray som vi har brugt i mange år i MediaLab, http://www.povray.org/documentation/view/3.6.1/15/. Det er selvfølgelig både frit at bruge og gratis, se gerne http://povray.org og deres Hall of Famehttp://hof.povray.org
  • Enhedsvektorer og grid. Vi diskuterede muligheden at bruge flere cylindre til at "tegne" et net af hjælpelinjer på hvert af de tre plan. I første omgang evt. alene fra 0 til 10 på hver af akserne. Flere havde faktisk allerede lavet noget i denne retning, men vi diskuterede nu hvordan vi kan bruge løkker til at undgå at lave mange nærmest identiske cylindre i koden.
  • Curve-objektet og hvordan vi kan bruge det til at "tegne" kurver, f.eks. parabler og vinkelfunktioner. Kode-eksemplet som vi udviklede sammen på projektoren er nedenfor.
  • Der var lidt spørgsmål om grundlæggende vejledning til Python, og i den forbindelse kan bogen How to Think Like a Computer Scientist, Learning wiht Python af Jeffrey Elkner, Allen B. Downey, and Chris Meyers, anbefales, men den er helt fri og findes på nettet. Brug versionen fra http://www.openbookproject.net. En direkte link er her: http://www.openbookproject.net/thinkcs/python/english2e/. Bemærk at der findes en opdateret version af bogen som passer til Python 3, men vi bruger indtil vider version 2.7.5 fra http://vpython.org, her er en direkte link til download-siden for Windows: http://www.vpython.org/contents/download_windows.html. Det er nemlig mange af de moduler vi kan få lyst til at anvende, som ikke er tilpasset til version 3 af Python, og Visual er en af dem. Desuden kører Visual dårligt med den IDLE (det integrerede udviklingsmiljø som følger med Python) som følger med med den 2.7 version af Python som vi kan hente fra http://python.org. Der er derfor lavet en særlig version af IDLE, VIDLE, som kører bedre med Visual. Denne installeres automatisk hvis vi installere Python fra http://vpython.org.
  • Løkker, loops, altså gentagelse. Vi så på eksempler på hvordan vi kan bruge en for-sætning og en while-sætning til at gentage en blok af sætninge. Kode-eksemplet som vi udviklede sammen på projektoren er nedenfor.
  • Editering med tastaturet. Når vi arbejder i en programeditor, så skal vi prøve at lære os helst ikke at bruge musen. Det behøves ikke hvis vi bruger en god programeditor, som f.eks. den i IDLE eller Notpad++ eller jEdit.

loops_with_python_gkb_v??.py, for og while[edit]

#loops_with_python_gkb_v??.py
#Loops with Pythonb

#There are two ways to create a loop, with a for-statement
#or with the while-statement.

print "En loop/løkke med en for-sætning:"
for i in [1,2,3]:
    print i, i*i

print "Og med en while-sætning:"
i=0
while i < 4:
    print i, i*i
    i = i + 1

curve_test_gkb_v??.py, test af curve-objektet[edit]

#curve_test_gkb_v??.py
#Example showing how to use the curve object to "draw" a curve in 3D.
from visual import *
kugle1=sphere()
c1=curve(pos=(0,0,0))
for i in range(4):
    kugle1.pos=(i,i*i,0)
    c1.append(kugle1.pos)
    print i

cylinder(pos=(0,0,0), axis=(1,0,0), color=color.red,   radius=0.05)    
cylinder(pos=(0,0,0), axis=(0,1,0), color=color.green, radius=0.05)    
cylinder(pos=(0,0,0), axis=(0,0,1), color=color.blue,  radius=0.05)    

n=0    
while n < 11:
    rate(2)
    cylinder(pos=(n,0,0), axis=(0,10,0), color=color.green,   radius=0.02)    
    n = n + 1

2013-08-29, torsdag: 3D modellering med Visual: Translation, Rotation and Resize, Gkb[edit]

Vi fortsatte arbejdet fra i tirsdags hvor vi kom godt i gang med translation og rotation. Vi startede forfra og hovedaktøren, kuglen, udskiftedes med en boks, -det er lettere at se om en boks roteres end en kugle.

Animationen skulle indeholde følgende dele eller scener. Dette er egentlig et udkast til en kravspecifikation:

  1. Boksen kommer til syne, laves, i koordinatsystemets centrum.
  2. Boksen glider elegant ud ad x-aksen til (10, 0, 0).
  3. Boksen roterer 360 grader rundt om sit eget centrum. (Hvilken akse?)
  4. Boksen roterer 360 grader rundt om origo, altså (0, 0, 0).
  5. Boksens sidelængder fordobles.

Følgende kodeeksempel blev præsentere som løsning på disse krav.

from visual import *

xakse = cylinder(pos=(0,0,0), color=color.red,   axis=(10,0,0), radius=.05)
yakse = cylinder(pos=(0,0,0), color=color.green, axis=(0,10,0), radius=.05)
zakse = cylinder(pos=(0,0,0), color=color.blue,  axis=(0,0,10), radius=.05)


box1 = box(color=color.yellow, radius=0.5)

#Translation
for x in range(11):
    box1.pos= (x,0,0)
    rate(2)

#Rotation om boksens eget centrum
for i in range(36):
    #obj.rotate(angle=pi/4, axis=axis, origin=pos
    #print x
    box1.rotate(angle=(2*pi)/36)
    rate(200)

#Rotation om origo
for i in range(36):
    #obj.rotate(angle=pi/4, axis=axis, origin=pos
    box1.rotate(angle=(2*pi)/36, axis=(0,1,0), origin=(0,0,0))
    print box1.pos
    rate(20)

#Resize med faktor 2
for k in range(11):
    #obj.rotate(angle=pi/4, axis=axis, origin=pos
    box1.size=(1+k/10.0,1+k/10.0,1+k/10.0)
    print box1.size
    rate(20)

For bedre at kunne følge boksens bevægelse tilføjede vi så et Curve-objekt, således at boksen efterlader en kurve når den roterer rundt origo. Efter den tilføjelse så det grafiske slutresultat (efter animationens afslutning) sådan ud. http://rtgkom.dk/~gkb/billeder/box_curve_and_axis.png
Og koden kommer her.

from visual import *

xakse = cylinder(pos=(0,0,0), color=color.red,   axis=(10,0,0), radius=.05)
yakse = cylinder(pos=(0,0,0), color=color.green, axis=(0,10,0), radius=.05)
zakse = cylinder(pos=(0,0,0), color=color.blue,  axis=(0,0,10), radius=.05)


box1 = box(color=color.yellow, radius=0.5)

#Translation
for x in range(11):
    box1.pos= (x,0,0)
    rate(2)

#Rotation om boksens eget centrum
for i in range(36):
    #obj.rotate(angle=pi/4, axis=axis, origin=pos
    #print x
    box1.rotate(angle=(2*pi)/36)
    rate(200)

#Rotation om origo
curve1=curve(pos=[(10,0,0)], radius=0.06)

for i in range(36):
    #obj.rotate(angle=pi/4, axis=axis, origin=pos
    box1.rotate(angle=(2*pi)/36, axis=(0,1,0), origin=(0,0,0))
    curve1.append(box1.pos)
    print box1.pos
    rate(20)

#Resize med faktor 2
for k in range(11):
    #obj.rotate(angle=pi/4, axis=axis, origin=pos
    box1.size=(1+k/10.0,1+k/10.0,1+k/10.0)
    print box1.size
    rate(20)

2013-08-27, tirsdag: 3D modellering med Visual: Translation, Rotation and Resize, Gkb[edit]

Vi gennemgik hvordan vi kan flytte et objekt (boks) ud ad x-aksen (translation), og hvordan vi kan dreje det rundt om eget centrum og rundt om koordinatsystemets centrum, altså origo (rotation). Vi udviklede følgende program linje for linje. Der var mange problemer undervejs, men sådan så koden på projektoren ud når modulet sluttede.

Vi havde ikke mulighed for at køre (tolke/interpretere og eksekvere) programmet på den maskine som det blev skrevet på. (Intet netværk og derfor ikke let at installere Visual). Jeg tastede koden derfor ind i gEdit og det blev klassens opgave at taste ind og teste og rette.

Prøv selv at tilføje en løkke som ændrer størrelsen på boksen (resize). Det ser vi nærmere på næste gang.

from visual import *

xakse=cylinder(pos=(0,0,0), axis=(10,0,0), color=(255,0,0), radius=0.05)
yakse=cylinder(pos=(0,0,0), axis=(0,10,0), color=(0,255,0), radius=0.05)
zakse=cylinder(pos=(0,0,0), axis=(0,0,10), color=(0,0,255), radius=0.05)

box1 = box()

for x in range(11):
  box1.x=x 
  rate(2)

#for a in arange(2*pi,0.1):
for a in arange(0, 2*pi, 0.1):
#  box1.rotate(angle=a)
  box1.rotate(angle=0.1)
  print a
  rate(10)

for a in arange(0, 2*pi, 0.1):
  box1.rotate(angle=0.1, origin=(0,0,0), axis=(0,1,0))
  print a
  rate(10)

2013-08-22, torsdag: 3D modellering og simpel animation med translation vha. Visual Gkb[edit]

Visual er et modul som kan bruges med Python.

  • Vi downloadede og installerede Python og Visual fra http://vpython.org.
  • Vi gennemgik med regneeksempler hvordan vi kan bruge Python shell'en til at regne nogle opgaver hvor svaret indeholdt rigtig mange cifre, f.eks. 2 ** 500.
  • Vi gennemgik hvordan vi kan bruge det indbyggede hjælpesystem i Python til at få information om installerede moduler (modules), keywords i programmeringssproget (keywords) og forskellige opgavetyper (topics).
  • Vi gennemgik hvordan vi kan bruge dokumentatione på http://vpython.org/contents/docs/index.html til at finde information om hvordan vi kan bruge objekterne i Visual i vores programmer.
  • Vi gennemgik hvordan man laver et program som viser tre smalle cylindre, en for hver akse i koordinatsystemet, for at vi bedre kan orientere os.
  • Vi gennemgik hvordan man flytter en kugle fra et sted til et andet sted på x-aksen.
  • Vi gennemgik hvordan man lader kuglen "glidende" flytte sig fra et sted ude på x-aksen til origo.

Vi lavede flere eksperimenter, lidt i Python shell'en, men mest editoren i IDLE, og her kan slutresultatet ses.

from visual import *

xakse = cylinder(pos=(0,0,0), color=color.red,   axis=(10,0,0), radius=.05)
yakse = cylinder(pos=(0,0,0), color=color.green, axis=(0,10,0), radius=.05)
zakse = cylinder(pos=(0,0,0), color=color.blue,  axis=(0,0,10), radius=.05)


kugle1= visual.sphere(color=color.yellow, radius=0.5)
kugle1.pos = (10, 0, 0)

for x in range(11):
    kugle1.pos= (10-x,0,0)
    rate(2)

2013-08-20: Usability[edit]

NN/g Nielsen Norman Group:
http://www.nngroup.com/topic/web-usability/
http://www.nngroup.com/articles/usability-101-introduction-to-usability/

2013-08-15: Første møde i dette skoleår: Velkomst og Usability[edit]

Velkomst[edit]

Vi startede med en kort velkomst i C3104, hvor vi lige konstaterede at vi var kommet godt i gennme sommeren, og så gik vi over i C3101.

Usability, fælles oplæg med InfB336[edit]

Vi samledes i C3101 med InfB336 og deres lærer, Christoffer Soya (cso), holdt et oplæg om begrebet brugbarhed, som på engelsk kaldes usability. Der blev inden oplægget uddelt en kopi fra bogen XXX. I foredraget diskuterede Christoffer flere aspekter ved brugbarhed og præsenterede en såkaldt komponentmodel (Component Model) for brugbarhed. Han støttede sig til denne her præsentation, http://www.eng.auburn.edu/ise/courses/insy3020/Lectures/HumanComputerInteraction-3slides.pdf, i sit oplæg. Efter oplægget blev der uddelt en øvelse.

Usability, øvelse[edit]

Efter oplægget gik vi over i C3103 og C3104 og arbejdede med øvelsen.