RayGay blog http://jesper.kalliope.org/blog/ da <![CDATA[Fontrendering]]> Raytraceren kan nu rendere truetype fonte. Disse bliver renderet ved at udregne skæringerne mellem rays og de extrudede kvadratiske Bézier splines som tegnene er bygget op af. Da tegnene ikke bliver omregnet til trekanter, er objekterne perfekte uanset hvor langt man zoomer ind.

]]> <![CDATA[Legetøjsflyver]]> Brugte min første sommerferieformiddag på at kode en importer til Wavefront OBJ meshes. Dette er et af de ældste og mest udbredte 3D-filformater.

Nedenstående billede bruger den geniale Gilles Trans gratis model af en legetøjsflyver.

]]> <![CDATA[Boy surface]]> Inspireret af skulpturen af Boys overflade, har jeg lavet en wireframe udgave af overfladen.

Mirland lavede et nyt sexet skrivebordstapet:

Scenen er baseret på en simpel funktion som kan forvandle enhver 2D-parametrisering til en wireframe model.

;; Stroke a path with cylinders with spheres as joints ;; A path is a function from [0,1] to R^3 (define (stroke-path path radius mat num) (let ((result '())) (dotimes i num (let* ((t1 (/ i num)) (t2 (/ (+ i 1) num)) (p1 (path t1)) (p2 (path t2))) (set! result (cons (make-sphere p1 radius mat) result)) (set! result (cons (make-cylinder p1 p2 radius mat) result)))) result)) ;; Make a wiremesh out of a parametric surface. ;; @param surface-func the parametric description of the surface ;; as a function (u,v) -> R^3. ;; @param u-wires number of wires in the u-dimension. ;; @param v-wires number of wires in the v-dimension. ;; @param u-num number of cylinders to build each u-wire with. ;; @param v-num number of cylinders to build each v-wire with. ;; @param radius radius of the wires. ;; @param mat material of the wires. (define (make-parametric-surface-as-wireframe surface-func u-wires v-wires u-num v-num radius mat) (define result '()) (do ((u 0 (+ u 1))) ((= u u-wires)) (set! result (append result (stroke-path (lambda (t) (surface-func (/ u u-wires) t)) radius mat v-num)))) (do ((v 0 (+ v 1))) ((= v v-wires)) (set! result (append result (stroke-path (lambda (t) (surface-func t (/ v v-wires))) radius mat u-num)))) result)
]]> <![CDATA[Project Euler - R6RS - Blandede billeder]]> Har brugt en del tid på at løse opgaver i Project Euler. Dermed har jeg fået luget ud i en del bugs i min Scheme-implementation.

R6RS

Dette har også været motivationen til at implementere store dele af standardbiblioteket som den nye Scheme-standard kræver. Det har bla. medført at alle source-filer forventes at være i UTF-8, hvormed man nu kan bruge symboler som π, λ eller vector→list istedet for PI, lambda og vector->list.

Blandede billeder

Nogle billeder som jeg har brugt til at debugge fejl i traceren med.

Orthocircles i 16:10 format, dvs. kan bruges som baggrundstapet på widescreen-skærme. Orthocircles er en isosurface (her renderet via marchingcubes) med formlen:

((x2 + y2 - 1)2 + z2) ((y2 + z2 - 1)2 + x2) ((z2 + x2 - 1)2 + y2) - 0.03752 (1 + 3 (x2 + y2 + z2)) = 0

Den klassiske tepotte i 16:9 format.

Venii fra Milo i forskellige farver.

]]> <![CDATA[Benchmarks]]> Under udviklingen af min Scheme, har målet hele tiden været at slå GNUs Scheme Guile, hvilket jeg endnu ikke gør. Guile er stadig over dobbelt så hurtig som min implementation.

Men hvor hurtig er Guile og min Scheme i forhold til at andre fortolkede sprog? Er Perl og Python og Ruby to eller ti gange hurtigere end Guile? I hvert sprog kodede jeg en lille benchmark test, som udregner de første 36 Fibonacci tal.

Nedenstående er benchmarken i hhv. Ruby, Perl, Python og Scheme.

def fib(n) if n < 2 n else fib(n-1) + fib(n-2) end end 36.times do |i| puts "#{i} : #{fib(i)}" end

sub fib { my $n = shift; if ($n < 2) { return $n } else { return fib($n-1) + fib($n-2); } } foreach my $i (0..35) { print "$i : ".fib($i)."\n"; }

def fib(n): if n < 2: return n else: return fib(n-1) + fib(n-2) for i in range(36): print "%d : %d" % (i, fib(i))

(define (fib n) (if (< n 2) n (+ (fib (- n 1)) (fib (- n 2))))) (do ((i 0 (+ i 1))) ((= i 36)) (display i) (display " : ") (display (fib i)) (newline))

Algorithen er meget dum og genererer en masse funktions-kald og garbage. En af Scheme's forcer er tail-call optimering, hvilket dog ikke er muligt i denne algoritme (da plus-operatoren venter på resultaterne), så sammenligningen er, omend ikke særlig videnskabelig, så ihvertfald fair i den sammenhæng. Algoritmen er ikke den smarteste måde at udregne Fibonacci tal på. En simpel iteration over n ville være meget meget hurtigere, men jeg gik efter noget langsomt til denne test. Udførselstiderne er som følger. Lavest tid er bedst.
SprogVersionTid
Guile1.8.130.73s
Python2.5.136.45s
Raygay0.5.072.50s
Perl5.8.874.30s
Ruby1.8.6183.87s

Min upræcise benchmark giver følgende upræcise konklusioner: min Scheme, Raygay, er hurtigere end Perl! Python er dobbelt så hurtigt som Perl - interessant. Så det passer at Ruby er sløvt. Guile er hurtigst af alle, så det giver heldigvis mening at have den som mål.

]]> <![CDATA[Mandelbrot]]> Scheme er et fantastisk sprog til at lege med algoritmer. Her er et program som plotter Mandelbrot-mængden:

(define max-iterations 100) (define (mandelbrot c) (define (mandelbrot-inner z i) (cond ((> (magnitude z) 4.0) 'escaped) ((= i max-iterations) 'did-not-escape) (else (mandelbrot-inner (+ c (* z z)) (+ 1 i))))) (mandelbrot-inner c 0)) (do ((y -1 (+ y 0.1))) ((>= y 1)) (do ((x -2 (+ x 0.05))) ((>= x 1) (newline)) (case (mandelbrot (make-rectangular x y)) ((escaped) (display ".")) ((did-not-escape) (display "#")))))

............................................................ ............................................................ ....................................####.................... ....................................####.................... ..............................#..##########................. ..............................#################............. ............................###################............. ...........................#####################............ .................#######..######################............ ................#########.######################............ .....#....####################################.............. ................#########.######################............ .................#######..######################............ ...........................#####################............ ............................###################............. ..............................#################............. ..............................#..##########................. ....................................####.................... ....................................####.................... ............................................................ ............................................................
]]> <![CDATA[Uniformt fordelt kugleoverflade]]> I Monte-Carlo pathtracing har man brug for punkter som er uniformt fordelte på enhedskuglen S2.

Jeg har kode som finder perfekt uniformt fordelte punkter i [0,1]×[0,1] og har nu fundet en uniform mapning derfra til S2.

Den beror på, at hver af de tre koordinater for uniformt fordelte punkter på S2 faktisk er uniformt fordelte på [0,1]. De tre koordinater er selvfølgelig ikke uafhængige.

Man kan derfor vælge een akse (her z-aksen) og finde en uniformt fordelt værdi på den akse. Dermed skal de resterende to koordinater findes på en cirkel parallelt til XY-planet med almindeligt trigonometri.

Lad (s,t) tilhøre [0,1]×[0,1]. Fastlæg z med det samme som 2s-1. Lad radius r = sqrt(1-z2). Lad placeringen på cirklen være φ = 2 t π. Så kan (x,y,z) udtrykkes som (r cos φ, r sin φ, z).

Sådan ser det ud i Scheme:

(define (plane->sphere p) (let* ((z (- (* 2 (car p)) 1)) (t (* 2 PI (cadr p))) (r (sqrt (- 1 (* z z))))) (vector (* r (cos t)) (* r (sin t)) z)))

Nedenstående viser omkr. 1000 Poisson-disk fordelte punkter mappet til en kugle.

Bemærk især, hvordan punkterne ikke klumper sammen omkring z-aksen.

]]> <![CDATA[π]]> Jeg har længe ville prøve at udregne π i et eller andet antal mange decimaler. Kiggede på det i dag og fandt den ret nye Bailey-Borwein-Plouffe formel fra 1995. På utrolig vis lader den een udtrække decimaler een ad gangen. Den udregner decimaler i base 16, dvs. hexadecimal, hvilket er helt fint. Det interessante er også at formlen er fundet af et computerprogram som kan manipulere symbolsk algebra.

Der er endnu ikke fundet en tilsvarende formel til at udtrække decimaler i base 10. Nu vi alligevel springer rundt mellem baser, kan det gøres endnu simplere. Her en noget simplere formel som giver alle decimaler til π - denne gang i base π:

π = 10

]]> <![CDATA[Peter de Jong - Masser af kasser]]> Skrev for snart længe siden en Peter de Jong attractor. Her er resultatet.

Masser af kasser

Et nyt baggrundstapet.

]]> <![CDATA[Seam Carving - Fyldte tegn]]> Har på under 100 linier Scheme kodet en simpel udgave af seam carving som opfundet af Shai Avidan og Ariel Shamir i deres artikel "Seam Carving for Content-Aware Image Resizing" fra SIGGRAPH 2007.

blev skaleret til

Fyldte tegn

Min truetype font plotter kan nu også fylde tegn ud.

Er snart klar med koden som renderer glyffer som extrudede 3D-objekter.

]]> <![CDATA[Halftone - GZIP]]> Konvertede en af mine animationer til halftone. Jeg gjorde det på 5 minutter med en Photoshop macro, men effekten er så fed, at jeg måske ender med at kode et postprocessing filter til traceren, som kan gøre det samme.

GZIP

Har kodet en GZIP decompressor efter RFC 1951 og RFC 1952. Planen er lave et C++ ifstream-interface ovenpå og så lade traceren automatisk pakke .gz filer ud. Det er f.eks. smart til store objekter, både PLY-format eller mit Scheme-format.

]]>