gluas examples

• bayer
• bcontrast
• blend
• blur
• check
• chroma_scope
• convolve
• half
• halftone
• hsl
• jitter
• jitterblur
• kuwahara
• lab-noise
• lab
• mandelbrot
• pixelate
• raytrace
• raytrace_old
• rotozoom
• sierpsinsky
• threshold

original image

The sample image used for the examples on this page, the code is placed in textareas for easy copying.

bayer

-- RGB bayer pattern simulation for y=0, height-1 do for x=0, width-1 do r,g,b = get_rgb (x,y) if (math.mod(y,2)==0) then if (math.mod(x,2)==0) then r,g,b = 0,g,0 else r,g,b = r,0,0 end else if (math.mod(x,2)==0) then r,g,b = 0,0,b else r,g,b = 0,g,0 end end set_rgb (x,y, r,g,b) end progress (y/height) end

bcontrast

brightness = 0.2 contrast = 1.5 for y=0, height-1 do for x=0, width-1 do r,g,b = get_rgb(x,y) r=(r-0.5)*contrast+0.5+brightness g=(g-0.5)*contrast+0.5+brightness b=(b-0.5)*contrast+0.5+brightness set_rgb (x,y,r,g,b) end progress(y/height) end

blend

-- gradient blend in lua -- -- and a quite strange blend,. but this was what I -- ended up coding here x1=0.25*width y1=0.25*height x2=0.75*width y2=0.75*height function dist(x1,y1,x2,y2) local dist= math.sqrt( (x2-x1)^2+(y2-y1)^2 ) return dist end function blend_radial(x1,y1,x2,y2) local length=dist(x1,y1,x2,y2) local x,y print(x1,y1,x2,y2) for y = 0, height-1 do for x = 0, width-1 do local v=dist(x,y,x2,y2)/length set_value(x,y, v) end progress(y/height) end end function blend_strange(x1,y1,x2,y2) local length=dist(x1,y1,x2,y2) local x,y for y = 0, height-1 do for x = 0, width-1 do local tostart=dist(x,y,x1,y1) local toend=dist(x,y,x2,y2) local sum=tostart+toend local v=tostart/sum set_value(x,y, v) end progress(y/height) end end -- pippin didn't bother sitting down with pen paper -- and think about the right math for this,.. thus ended up -- without a real linear blend blend_strange(x1,y1,x2,y2)

blur

-- a box blur filter implemented in lua -- -- seperation into two passes will greatly increase the -- speed of this filter edge_duplicate = 1 radius = 4 local x,y for y = 0, height-1 do for x = 0, width-1 do local count=0 local rsum,gsum,bsum,asum=0,0,0,0 for nx=x-radius, x+radius do for ny=y-radius, y+radius do local r,g,b,a= get_rgba (nx,ny) rsum,gsum,bsum,asum=rsum+r,gsum+g,bsum+b,asum+a count=count+1 end end set_rgba (x,y, rsum/count,gsum/count,bsum/count,asum/count) end progress(y/height) end

check

-- a checkerboard filter implemented in lua horizontal = 8 -- number of horizontal squares vertical = 8 -- number of vertical squares local x,y local hpix=width/horizontal local vpix=height/vertical for y = 0, height-1 do for x = 0, width-1 do local r,g,b,a local nx,ny nx=math.floor(x/hpix) ny=math.floor(y/vpix) if(math.mod(nx,2)==0) then if(math.mod(ny,2)==0) then set_value (x,y,1) else set_value (x,y,0) end else if(math.mod(ny,2)==0) then set_value (x,y,0) else set_value (x,y,1) end end end progress(y/height) end

chroma_scope

-- CIE Lab chromacity diagram for input image if width > height then scale = height else scale = width end scale = 220 / scale for y=0, height-1 do for x=0, width-1 do set_value (x,y, 0) end end x = width/2 for y=0, height-1 do set_value (x,y, 1) end y = height/2 for x=0, width-1 do set_value (x,y, 1) end for y=0, height-1 do for x=0, width-1 do l,a,b = get_lab (x,y) set_lab ( (a * scale) + width/2, (b * scale) + height/2, l, a,b) end progress (y/height) end

convolve

-- 3x3 convolution filter for grayscale -- emboss kernel = { { -2, -1, 0}, { -1, 1, 1}, { 0, 1, 2}} divisor = 1 offset = 0 -- see http://docs.gimp.org/en/ch06s07s02.html for -- more matrix examples function filter (x,y) local i, j, sum sum = 0 for i=-1,1 do for j=-1,1 do sum = sum + kernel[j+2][i+2] * get_value (x+i, y+j) end end return sum / divisor + offset end for y=0, height-1 do for x=0, width-1 do v = filter (x,y) set_value (x,y, v) end progress (y/height) end

half

-- simple halving filter in lua for y = 0, height*0.5-1 do for x = 0, width*0.5-1 do rsum,gsum,bsum,asum=get_rgba(x*2,y*2) r,g,b,a=get_rgba(x*2+1,y*2) rsum,gsum,bsum,asum=rsum+r,gsum+g,bsum+b,asum+a r,g,b,a=get_rgba(x*2,y*2+1) rsum,gsum,bsum,asum=rsum+r,gsum+g,bsum+b,asum+a r,g,b,a=get_rgba(x*2+1,y*2+1) rsum,gsum,bsum,asum=rsum+r,gsum+g,bsum+b,asum+a r,g,b,a=rsum/4,gsum/4,bsum/4,asum/4 set_rgba(x+width*0.25,y+height*0.25, r,g,b,a) end progress(y/height*0.5) end

halftone

-- haltoning by Vincent "MooZ" Cruz -- vcruz@free.fr -- "A Simple and Efficient Error-Diffusion Algorithm" (SIGGRAPH'01) -- Author: Victor Ostromoukhov -- University of Montreal, http://www.iro.umontreal.ca/~ostrom/ -- Distribution coefficients local coefficient = { { 13, 0, 5, 18, }, -- 0 { 13, 0, 5, 18, }, -- 1 { 21, 0, 10, 31, }, -- 2 { 7, 0, 4, 11, }, -- 3 { 8, 0, 5, 13, }, -- 4 { 47, 3, 28, 78, }, -- 5 { 23, 3, 13, 39, }, -- 6 { 15, 3, 8, 26, }, -- 7 { 22, 6, 11, 39, }, -- 8 { 43, 15, 20, 78, }, -- 9 { 7, 3, 3, 13, }, -- 10 { 501, 224, 211, 936, }, -- 11 { 249, 116, 103, 468, }, -- 12 { 165, 80, 67, 312, }, -- 13 { 123, 62, 49, 234, }, -- 14 { 489, 256, 191, 936, }, -- 15 { 81, 44, 31, 156, }, -- 16 { 483, 272, 181, 936, }, -- 17 { 60, 35, 22, 117, }, -- 18 { 53, 32, 19, 104, }, -- 19 { 237, 148, 83, 468, }, -- 20 { 471, 304, 161, 936, }, -- 21 { 3, 2, 1, 6, }, -- 22 { 459, 304, 161, 924, }, -- 23 { 38, 25, 14, 77, }, -- 24 { 453, 296, 175, 924, }, -- 25 { 225, 146, 91, 462, }, -- 26 { 149, 96, 63, 308, }, -- 27 { 111, 71, 49, 231, }, -- 28 { 63, 40, 29, 132, }, -- 29 { 73, 46, 35, 154, }, -- 30 { 435, 272, 217, 924, }, -- 31 { 108, 67, 56, 231, }, -- 32 { 13, 8, 7, 28, }, -- 33 { 213, 130, 119, 462, }, -- 34 { 423, 256, 245, 924, }, -- 35 { 5, 3, 3, 11, }, -- 36 { 281, 173, 162, 616, }, -- 37 { 141, 89, 78, 308, }, -- 38 { 283, 183, 150, 616, }, -- 39 { 71, 47, 36, 154, }, -- 40 { 285, 193, 138, 616, }, -- 41 { 13, 9, 6, 28, }, -- 42 { 41, 29, 18, 88, }, -- 43 { 36, 26, 15, 77, }, -- 44 { 289, 213, 114, 616, }, -- 45 { 145, 109, 54, 308, }, -- 46 { 291, 223, 102, 616, }, -- 47 { 73, 57, 24, 154, }, -- 48 { 293, 233, 90, 616, }, -- 49 { 21, 17, 6, 44, }, -- 50 { 295, 243, 78, 616, }, -- 51 { 37, 31, 9, 77, }, -- 52 { 27, 23, 6, 56, }, -- 53 { 149, 129, 30, 308, }, -- 54 { 299, 263, 54, 616, }, -- 55 { 75, 67, 12, 154, }, -- 56 { 43, 39, 6, 88, }, -- 57 { 151, 139, 18, 308, }, -- 58 { 303, 283, 30, 616, }, -- 59 { 38, 36, 3, 77, }, -- 60 { 305, 293, 18, 616, }, -- 61 { 153, 149, 6, 308, }, -- 62 { 307, 303, 6, 616, }, -- 63 { 1, 1, 0, 2, }, -- 64 { 101, 105, 2, 208, }, -- 65 { 49, 53, 2, 104, }, -- 66 { 95, 107, 6, 208, }, -- 67 { 23, 27, 2, 52, }, -- 68 { 89, 109, 10, 208, }, -- 69 { 43, 55, 6, 104, }, -- 70 { 83, 111, 14, 208, }, -- 71 { 5, 7, 1, 13, }, -- 72 { 172, 181, 37, 390, }, -- 73 { 97, 76, 22, 195, }, -- 74 { 72, 41, 17, 130, }, -- 75 { 119, 47, 29, 195, }, -- 76 { 4, 1, 1, 6, }, -- 77 { 4, 1, 1, 6, }, -- 78 { 4, 1, 1, 6, }, -- 79 { 4, 1, 1, 6, }, -- 80 { 4, 1, 1, 6, }, -- 81 { 4, 1, 1, 6, }, -- 82 { 4, 1, 1, 6, }, -- 83 { 4, 1, 1, 6, }, -- 84 { 4, 1, 1, 6, }, -- 85 { 65, 18, 17, 100, }, -- 86 { 95, 29, 26, 150, }, -- 87 { 185, 62, 53, 300, }, -- 88 { 30, 11, 9, 50, }, -- 89 { 35, 14, 11, 60, }, -- 90 { 85, 37, 28, 150, }, -- 91 { 55, 26, 19, 100, }, -- 92 { 80, 41, 29, 150, }, -- 93 { 155, 86, 59, 300, }, -- 94 { 5, 3, 2, 10, }, -- 95 { 5, 3, 2, 10, }, -- 96 { 5, 3, 2, 10, }, -- 97 { 5, 3, 2, 10, }, -- 98 { 5, 3, 2, 10, }, -- 99 { 5, 3, 2, 10, }, -- 100 { 5, 3, 2, 10, }, -- 101 { 5, 3, 2, 10, }, -- 102 { 5, 3, 2, 10, }, -- 103 { 5, 3, 2, 10, }, -- 104 { 5, 3, 2, 10, }, -- 105 { 5, 3, 2, 10, }, -- 106 { 5, 3, 2, 10, }, -- 107 { 305, 176, 119, 600, }, -- 108 { 155, 86, 59, 300, }, -- 109 { 105, 56, 39, 200, }, -- 110 { 80, 41, 29, 150, }, -- 111 { 65, 32, 23, 120, }, -- 112 { 55, 26, 19, 100, }, -- 113 { 335, 152, 113, 600, }, -- 114 { 85, 37, 28, 150, }, -- 115 { 115, 48, 37, 200, }, -- 116 { 35, 14, 11, 60, }, -- 117 { 355, 136, 109, 600, }, -- 118 { 30, 11, 9, 50, }, -- 119 { 365, 128, 107, 600, }, -- 120 { 185, 62, 53, 300, }, -- 121 { 25, 8, 7, 40, }, -- 122 { 95, 29, 26, 150, }, -- 123 { 385, 112, 103, 600, }, -- 124 { 65, 18, 17, 100, }, -- 125 { 395, 104, 101, 600, }, -- 126 { 4, 1, 1, 6, }, -- 127 { 4, 1, 1, 6, }, -- 128 { 395, 104, 101, 600, }, -- 129 { 65, 18, 17, 100, }, -- 130 { 385, 112, 103, 600, }, -- 131 { 95, 29, 26, 150, }, -- 132 { 25, 8, 7, 40, }, -- 133 { 185, 62, 53, 300, }, -- 134 { 365, 128, 107, 600, }, -- 135 { 30, 11, 9, 50, }, -- 136 { 355, 136, 109, 600, }, -- 137 { 35, 14, 11, 60, }, -- 138 { 115, 48, 37, 200, }, -- 139 { 85, 37, 28, 150, }, -- 140 { 335, 152, 113, 600, }, -- 141 { 55, 26, 19, 100, }, -- 142 { 65, 32, 23, 120, }, -- 143 { 80, 41, 29, 150, }, -- 144 { 105, 56, 39, 200, }, -- 145 { 155, 86, 59, 300, }, -- 146 { 305, 176, 119, 600, }, -- 147 { 5, 3, 2, 10, }, -- 148 { 5, 3, 2, 10, }, -- 149 { 5, 3, 2, 10, }, -- 150 { 5, 3, 2, 10, }, -- 151 { 5, 3, 2, 10, }, -- 152 { 5, 3, 2, 10, }, -- 153 { 5, 3, 2, 10, }, -- 154 { 5, 3, 2, 10, }, -- 155 { 5, 3, 2, 10, }, -- 156 { 5, 3, 2, 10, }, -- 157 { 5, 3, 2, 10, }, -- 158 { 5, 3, 2, 10, }, -- 159 { 5, 3, 2, 10, }, -- 160 { 155, 86, 59, 300, }, -- 161 { 80, 41, 29, 150, }, -- 162 { 55, 26, 19, 100, }, -- 163 { 85, 37, 28, 150, }, -- 164 { 35, 14, 11, 60, }, -- 165 { 30, 11, 9, 50, }, -- 166 { 185, 62, 53, 300, }, -- 167 { 95, 29, 26, 150, }, -- 168 { 65, 18, 17, 100, }, -- 169 { 4, 1, 1, 6, }, -- 170 { 4, 1, 1, 6, }, -- 171 { 4, 1, 1, 6, }, -- 172 { 4, 1, 1, 6, }, -- 173 { 4, 1, 1, 6, }, -- 174 { 4, 1, 1, 6, }, -- 175 { 4, 1, 1, 6, }, -- 176 { 4, 1, 1, 6, }, -- 177 { 4, 1, 1, 6, }, -- 178 { 119, 47, 29, 195, }, -- 179 { 72, 41, 17, 130, }, -- 180 { 97, 76, 22, 195, }, -- 181 { 172, 181, 37, 390, }, -- 182 { 5, 7, 1, 13, }, -- 183 { 83, 111, 14, 208, }, -- 184 { 43, 55, 6, 104, }, -- 185 { 89, 109, 10, 208, }, -- 186 { 23, 27, 2, 52, }, -- 187 { 95, 107, 6, 208, }, -- 188 { 49, 53, 2, 104, }, -- 189 { 101, 105, 2, 208, }, -- 190 { 1, 1, 0, 2, }, -- 191 { 307, 303, 6, 616, }, -- 192 { 153, 149, 6, 308, }, -- 193 { 305, 293, 18, 616, }, -- 194 { 38, 36, 3, 77, }, -- 195 { 303, 283, 30, 616, }, -- 196 { 151, 139, 18, 308, }, -- 197 { 43, 39, 6, 88, }, -- 198 { 75, 67, 12, 154, }, -- 199 { 299, 263, 54, 616, }, -- 200 { 149, 129, 30, 308, }, -- 201 { 27, 23, 6, 56, }, -- 202 { 37, 31, 9, 77, }, -- 203 { 295, 243, 78, 616, }, -- 204 { 21, 17, 6, 44, }, -- 205 { 293, 233, 90, 616, }, -- 206 { 73, 57, 24, 154, }, -- 207 { 291, 223, 102, 616, }, -- 208 { 145, 109, 54, 308, }, -- 209 { 289, 213, 114, 616, }, -- 210 { 36, 26, 15, 77, }, -- 211 { 41, 29, 18, 88, }, -- 212 { 13, 9, 6, 28, }, -- 213 { 285, 193, 138, 616, }, -- 214 { 71, 47, 36, 154, }, -- 215 { 283, 183, 150, 616, }, -- 216 { 141, 89, 78, 308, }, -- 217 { 281, 173, 162, 616, }, -- 218 { 5, 3, 3, 11, }, -- 219 { 423, 256, 245, 924, }, -- 220 { 213, 130, 119, 462, }, -- 221 { 13, 8, 7, 28, }, -- 222 { 108, 67, 56, 231, }, -- 223 { 435, 272, 217, 924, }, -- 224 { 73, 46, 35, 154, }, -- 225 { 63, 40, 29, 132, }, -- 226 { 111, 71, 49, 231, }, -- 227 { 149, 96, 63, 308, }, -- 228 { 225, 146, 91, 462, }, -- 229 { 453, 296, 175, 924, }, -- 230 { 38, 25, 14, 77, }, -- 231 { 459, 304, 161, 924, }, -- 232 { 3, 2, 1, 6, }, -- 233 { 471, 304, 161, 936, }, -- 234 { 237, 148, 83, 468, }, -- 235 { 53, 32, 19, 104, }, -- 236 { 60, 35, 22, 117, }, -- 237 { 483, 272, 181, 936, }, -- 238 { 81, 44, 31, 156, }, -- 239 { 489, 256, 191, 936, }, -- 240 { 123, 62, 49, 234, }, -- 241 { 165, 80, 67, 312, }, -- 242 { 249, 116, 103, 468, }, -- 243 { 501, 224, 211, 936, }, -- 244 { 7, 3, 3, 13, }, -- 245 { 43, 15, 20, 78, }, -- 246 { 22, 6, 11, 39, }, -- 247 { 15, 3, 8, 26, }, -- 248 { 23, 3, 13, 39, }, -- 249 { 47, 3, 28, 78, }, -- 250 { 8, 0, 5, 13, }, -- 251 { 7, 0, 4, 11, }, -- 252 { 21, 0, 10, 31, }, -- 253 { 13, 0, 5, 18, }, -- 254 { 13, 0, 5, 18 } -- 255 } local threshold = 127.5 local carry = {{}, {}} local next = 2 local current = 1 for x=1, width+3 do carry[current][x] = 0.0 carry[next][x] = 0.0 end local input, intensity, correctedLevel, diff, right, downLeft, down for y=1,height do -- left to right for x=1,width do input = math.floor(255*get_value(x-1,y-1)) correctedLevel = input + carry[current][x+1] intensity = (correctedLevel <= threshold) and 0 or 255 diff = correctedLevel - intensity right = (coefficient[input+1][1] * diff) / coefficient[input+1][4] downLeft = (coefficient[input+1][2] * diff) / coefficient[input+1][4] down = diff - (right + downLeft) carry[current][x+2] = carry[current][x+2] + right carry[next][x] = carry[next][x] + downLeft carry[next][x+1] = carry[next][x+1] + down if((input == 0) or (intensity ==0)) then set_value(x-1, y-1, 0) else set_value(x-1, y-1, 1) end end -- swap carry current, next = next, current for x=1,width+3 do carry[next][x] = 0 end y = y + 1 if(y > height) then break end for x=width,1,-1 do input = math.floor(255*get_value(x-1,y-1)) correctedLevel = input + carry[current][x+1] intensity = (correctedLevel <= threshold) and 0 or 255 diff = correctedLevel - intensity right = (coefficient[input+1][1] * diff) / coefficient[input+1][4] downLeft = (coefficient[input+1][2] * diff) / coefficient[input+1][4] down = diff - (right + downLeft) carry[current][x] = carry[current][x] + right carry[next][x+2] = carry[next][x+2] + downLeft carry[next][x+1] = carry[next][x+1] + down if((input == 0) or (intensity ==0)) then set_value(x-1, y-1, 0) else set_value(x-1, y-1, 1) end end -- swap carry current, next = next, current for x=1,width+3 do carry[next][x] = 0 end end

hsl

-- hue / saturation chart for y=0, height-1 do for x=0, width-1 do set_hsl (x,y, x/width, y/height, 0.5) end progress (y/height) end

jitter

-- a jittering filter implemented in lua amount = 18 -- spread amount edge_duplicate=1 local x,y var2=var1 for y = 0, height-1 do for x = 0, width-1 do local nx,ny local r,g,b,a nx=x+(math.random()-0.5)*amount ny=y+(math.random()-0.5)*amount r,g,b,a=get_rgba(nx,ny) set_rgba(x,y, r,g,b,a) end progress(y/height) end

jitterblur

-- a jitter blur filter implemented in lua count = 8 -- number of samplings amount = 32 -- amount of spread edge_duplicate=1 local x,y --math.randomseed(1) for y = 0, height-1 do for x = 0, width-1 do local rsum,gsum,bsum,asum=0,0,0,0 for n=1, count do local nx,ny,r,g,b,a nx=x+(math.random()-0.5)*amount ny=y+(math.random()-0.5)*amount r,g,b,a= get_rgba(nx,ny) rsum,gsum,bsum,asum=rsum+r,gsum+g,bsum+b,asum+a end set_rgba (x,y, rsum/count,gsum/count,bsum/count,asum/count) end progress(y/height) end

kuwahara

-- Kuwahara filter -- -- -- Performs the Kuwahara Filter. This filter is an edge-preserving filter. -- -- -- ( a a ab b b) -- ( a a ab b b) -- (ac ac abcd bd bd) -- ( c c cd d d) -- ( c c cd d d) -- -- In each of the four regions (a, b, c, d), the mean brightness and the variance are calculated. The -- output value of the center pixel (abcd) in the window is the mean value of that region that has the -- smallest variance. -- -- description copied from http://www.incx.nec.co.jp/imap-vision/library/wouter/kuwahara.html -- -- implemented by Øyvind Kolås <oeyvindk@hig.no> 2004 -- the sampling window is: width=size*2+1 height=size*2+1 size = 4 -- local function to get the mean value, and -- variance from the rectangular area specified function mean_and_variance (x0,y0,x1,y1) local variance local mean local min = 1.0 local max = 0.0 local accumulated = 0 local count = 0 local x, y for y=y0,y1 do for x=x0,x1 do local v = get_value(x,y) accumulated = accumulated + v count = count + 1 if v<min then min = v end if v>max then max = v end end end variance = max-min mean = accumulated /count return mean, variance end -- local function to get the mean value, and -- variance from the rectangular area specified function rgb_mean_and_variance (x0,y0,x1,y1) local variance local mean local r_mean local g_mean local b_mean local min = 1.0 local max = 0.0 local accumulated_r = 0 local accumulated_g = 0 local accumulated_b = 0 local count = 0 local x, y for y=y0,y1 do for x=x0,x1 do local v = get_value(x,y) local r,g,b = get_rgb (x,y) accumulated_r = accumulated_r + r accumulated_g = accumulated_g + g accumulated_b = accumulated_b + b count = count + 1 if v<min then min = v end if v>max then max = v end end end variance = max-min mean_r = accumulated_r /count mean_g = accumulated_g /count mean_b = accumulated_b /count return mean_r, mean_g, mean_b, variance end -- return the kuwahara computed value function kuwahara(x, y, size) local best_mean = 1.0 local best_variance = 1.0 local mean, variance mean, variance = mean_and_variance (x-size, y-size, x, y) if variance < best_variance then best_mean = mean best_variance = variance end mean, variance = mean_and_variance (x, y-size, x+size,y) if variance < best_variance then best_mean = mean best_variance = variance end mean, variance = mean_and_variance (x, y, x+size, y+size) if variance < best_variance then best_mean = mean best_variance = variance end mean, variance = mean_and_variance (x-size, y, x,y+size) if variance < best_variance then best_mean = mean best_variance = variance end return best_mean end -- return the kuwahara computed value function rgb_kuwahara(x, y, size) local best_r, best_g, best_b local best_variance = 1.0 local r,g,b, variance r,g,b, variance = rgb_mean_and_variance (x-size, y-size, x, y) if variance < best_variance then best_r, best_g, best_b = r, g, b best_variance = variance end r,g,b, variance = rgb_mean_and_variance (x, y-size, x+size,y) if variance < best_variance then best_r, best_g, best_b = r, g, b best_variance = variance end r,g,b, variance = rgb_mean_and_variance (x, y, x+size, y+size) if variance < best_variance then best_r, best_g, best_b = r, g, b best_variance = variance end r,g,b, variance = rgb_mean_and_variance (x-size, y, x,y+size) if variance < best_variance then best_r, best_g, best_b = r, g, b best_variance = variance end return best_r, best_g, best_b end for y=0, height-1 do for x=0, width-1 do -- set_value (x,y, kuwahara (x,y, size)) r,g,b = rgb_kuwahara (x,y, size) set_rgb (x,y, r,g,b) end progress (y/height) end

lab-noise

-- noise addition in CIE Lab color space amount = 40 -- amount of noise for y = 0, height-1 do for x = 0, width-1 do l,a,b = get_lab (x,y) random=(math.random()-0.5)*amount l=l+random a=a+random b=b+random set_lab (x,y, l, a, b) end progress(y/height) end

lab

-- CIE Lab chromacity diagram if width > height then scale = height else scale = width end scale = 220 / scale for y=0, height-1 do for x=0, width-1 do set_lab (x,y, 60, (x-width/2)/scale, (y-height/2)/scale) end end x = width/2 for y=0, height-1 do set_value (x,y, 1) end y = height/2 for x=0, width-1 do set_value (x,y, 1) end

mandelbrot

-- mandelbrot fractal renderer for gluas by Øyvind Kolås 2004, adapted -- from other source found on the net, the original probably has similar -- naming of the variables, -- these variables control which rectangle in 'mandelbrot space' is rendered local fViewRectReal = -1.77 local fViewRectImg = 0 local fMagLevel = 3.5 local maxiter = 128 function color(x,y) local fCReal = fViewRectReal + x * fMagLevel local fCImg = fViewRectImg + y * fMagLevel local fZReal = fCReal local fZImg = fCImg local inside = 1 local n for n=0,maxiter do local fZRealSquared = fZReal * fZReal local fZImgSquared = fZImg * fZImg if (fZRealSquared + fZImgSquared > 4) then return n/(maxiter) end -- z = z^2 + c fZImg = 2 * fZReal * fZImg + fCImg fZReal = fZRealSquared - fZImgSquared + fCReal end return 1 end local x,y local scale = width/height for y=0, height-1 do for x=0, width-1 do set_value (x,y,color((x/width-0.5)*scale,(y/height-0.5))) end progress (y/height) end

pixelate

-- a pixelation filter implemented in lua -- hlines = 16 vlines = 16 local x,y local hpix=width/hlines local vpix=height/vlines for y = 0, height-1 do for x = 0, width-1 do local r,g,b,a local nx,ny nx=math.floor(x/hpix)*hpix ny=math.floor(y/vpix)*vpix r,g,b,a=get_rgba(nx,ny) set_rgba(x,y,r,g,b,a) end progress(y/height) end

raytrace

-- Raytraced sphere and triangle (Cook-Torrance Brdf) -- Vincent 'MooZ' Cruz (vcruz@free.fr) ---- Primes array local primes = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613 } -- -------------------------------- -- <Class> -- -------------------------------- function Class(members) members = members or {} local mt = { __metatable = members; __index = members; } local function new(_, init) return setmetatable(init or {}, mt) end local function copy(obj, ...) local newobj = obj:new(unpack(arg)) for n,v in pairs(obj) do newobj[n] = v end return newobj end members.new = members.new or new members.copy = members.copy or copy return mt end -- </Class> -- -------------------------------- -- <Vector> -- -------------------------------- Vector = {} local Vector_mt = Class(Vector) ---- CTOR function Vector:new(x, y, z) return setmetatable( {x=x, y=y, z=z}, Vector_mt) end ---- function Vector_mt.__add(u, v) return Vector:new(u.x + v.x, u.y + v.y, u.z + v.z) end ---- function Vector_mt.__sub(u, v) return Vector:new(u.x - v.x, u.y - v.y, u.z - v.z) end ---- function Vector_mt.__unm(u) return Vector:new(-u.x, -u.y, -u.z) end ---- function Vector_mt.__mul(u, v) if(type(u) == "number") then return Vector:new(u * v.x, u * v.y, u * v.z) else return Vector:new(u.x * v, u.y * v, u.z * v) end end ---- function Vector_mt.__div(u, s) return Vector:new(u.x / s, u.y / s, u.z / s) end ---- function dot(u, v) return (u.x * v.x) + (u.y * v.y) + (u.z * v.z) end ---- function cross(u,v) return Vector:new((u.y*v.z) - (u.z*v.y), (u.z*v.x) - (u.x*v.z), (u.x*v.y) - (u.y*v.x)) end ---- function Vector:magnitude() return ((self.x * self.x) + (self.y * self.y) + (self.z * self.z)) end ---- function Vector:norm() return math.sqrt(self:magnitude()) end ---- function Vector:normalize() local n = self:norm(); if(n ~= 0) then self.x = self.x / n; self.y = self.y / n; self.z = self.z / n; end end -- </Vector> -- -------------------------------- -- <RGB> -- -------------------------------- RGB = {} local RGB_mt = Class(RGB) -- CTOR function RGB:new(red, green, blue) return setmetatable( {r=red, g=green, b=blue}, RGB_mt) end ---- function RGB_mt.__add(c0, c1) return RGB:new(c0.r + c1.r, c0.g + c1.g, c0.b + c1.b) end ---- function RGB_mt.__sub(c0, c1) return RGB:new(c0.r - c1.r, c0.g - c1.g, c0.b - c1.b) end ---- function RGB_mt.__unm(c) return RGB:new(-c.r, -c.g, -c.b) end ---- function RGB_mt.__mul(c, d) if(type(c) == "number") then return RGB:new(c * d.r, c * d.g, c * d.b) elseif(type(d) == "number") then return RGB:new(c.r * d, c.g * d, c.b * d) else return RGB:new(c.r * d.r, c.g * d.g, c.b * d.b) end end ---- function RGB_mt.__div(c, s) return RGB:new(c.r / s, c.g / s, c.b / s) end ---- -- more to come -- </Color> -- -------------------------------- -- <Ray> -- -------------------------------- Ray = {} local Ray_mt = Class(Ray) ---- CTOR function Ray:new(o, d, t) return setmetatable( {origin=o, direction=d, distance=t}, Ray_mt) end -- </Ray> -- -------------------------------- -- <Sphere> -- -------------------------------- Sphere = {} local Sphere_mt = Class(Sphere) ---- CTOR function Sphere:new(c, r) return setmetatable( {center=c, radius=r}, Sphere_mt) end ---- Intersection test function Sphere:intersect(ray) local tmp = ray.origin - self.center local a = ray.direction:magnitude() local b = 2.0 * dot(tmp, ray.direction) local c = tmp:magnitude() - (self.radius * self.radius) -- quadric solver (whee) local d = (b*b) - (4.0*a*c) if(d < 0.0) then -- no intersection found -- intersection=0, t=0 return 0, 0 else -- 2 intersection points local t0 = (- b - math.sqrt(d)) / (2.0 * a) local t1 = (- b + math.sqrt(d)) / (2.0 * a) if(t0 < 0) then if(t1 < 0) then return 0, 0 else return 1, t1 end elseif(t1 < 0) then return 1, t0 elseif(t0 < t1) then return 1, t0 else return 1, t1 end end end -- Get local information such as normal, etc... function Sphere:getLocalInformations(ray, t) -- point local p = ray.origin + (t * ray.direction) -- normal local n = p - self.center n:normalize() return p,n end -- </Sphere> -- -------------------------------- -- <Triangle> -- -------------------------------- Triangle = {} local Triangle_mt = Class(Triangle) ---- CTOR function Triangle:new(a, b, c) local n = cross(b - a, c - a); n:normalize(); return setmetatable( {a=a, b=b, c=c, normal=n}, Triangle_mt) end ---- Intersection test function Triangle:intersect(ray) -- Fast, Minimum Storage Ray-Triangle Intersection -- Tomas Moller - Ben Trumbore -- Find vectors for two edges sharing a local uEdge = self.b - self.a local vEdge = self.c - self.a -- Begin calculating determinant - also used to calculate U parameter local pvec = cross(ray.direction, vEdge) -- If determinant is near zero, ray lies in plane of triangle local det = dot(uEdge, pvec) -- No culling if(math.abs(det) == 0) then return 0,0 end local invDet = 1.0 / det -- Calculate distance from vert0 to ray origin local tvec = ray.origin - self.a -- Calculate U parameter and test bounds local u = dot(tvec, pvec) * invDet; if ((u < 0.0) or (u > 1.0)) then return 0,0 end -- Prepare to test V parameter local qvec = cross(tvec, uEdge); -- Calculate V parameter and test bounds local v = dot(ray.direction, qvec) * invDet; if ((v < 0.0) or ((u + v) > 1.0)) then return 0,0 end -- Calculate t, ray intersects triangle local t = dot(vEdge, qvec) * invDet; return 1, t end -- Get local information such as normal, etc... function Triangle:getLocalInformations(ray, t) -- point local p = ray.origin + (t * ray.direction) if(dot(self.normal, ray.direction) > 0) then return p,-self.normal else return p,self.normal end end -- </Triangle> -- -------------------------------- -- <Camera> -- -------------------------------- Camera = {} local Camera_mt = Class(Camera) ---- CTOR function Camera:new(origin, target, up, fov, near, far, aspect) -- direction vector local d = target - origin d:normalize() local l = cross(up, d) l:normalize() up = cross(d, l) up:normalize() -- Let's save some computation local screen = near * math.tan(fov * 0.5) return setmetatable({eye=origin, left=l, up=up, direction=d, fov=fov, near=near, far=far, aspect=aspect, screen=screen} , Camera_mt) end ---- get ray function Camera:getRay(px, py) local dx = ((px / width) - 0.5) * self.screen * self.aspect local dy = ((py / height) - 0.5) * self.screen local direction = (self.near * self.direction) + (dx * self.left) - (dy * self.up) direction:normalize() return Ray:new(self.eye, direction, 0) end -- </Camera> -- ------------------------------------------------ -- <Sampler> -- Scrambled hammersley with faure permutation -- ------------------------------------------------ Sampler = {} local Sampler_mt = Class(Sampler) ---- CTOR function Sampler:new(sampleCount, dimensions) local permutation = {} permutation[1] = {0} permutation[2] = {0, 1} for i=3, primes[dimensions] do permutation[i] = {} -- even if(math.mod(i, 2) == 0) then for j=0, (i/2)-1 do permutation[i][j+1] = 2 * permutation[(i/2)][j+1] end for j=i/2, i-1 do permutation[i][j+1] = permutation[i][j-(i/2)+1]+1 end -- odd else for j=0, ((i-1)/2)-1 do if((2*permutation[i-1][j+1]) >= (i-1)) then permutation[i][j+1] = permutation[i-1][j+1]+1 else permutation[i][j+1] = permutation[i-1][j+1] end end permutation[i][((i-1)/2)+1] = (i-1)/2 for j=(i+1)/2, i-1 do if((2*permutation[i-1][j]) >= (i-1)) then permutation[i][j+1] = permutation[i-1][j]+1 else permutation[i][j+1] = permutation[i-1][j] end end end end return setmetatable( {sampleCount=sampleCount, dimensions=dimensions, samples={}, samplePos=sampleCount, permutation=permutation}, Sampler_mt) end ---- Van Der Corput + Faure permutation function Sampler:Vdc(i, base) local u, f, factor, digit u = 0.0 factor = 1.0 / base f = factor while i>0 do digit = math.mod(i, base) u = u + (self.permutation[base][digit+1] * factor) i = math.floor(i / base) factor = factor * f end return u end ---- sample function function Sampler:computeSamples() local k=1 for j=1, self.sampleCount do for i=1, self.dimensions do local val = self:Vdc(j-1, primes[i]) self.samples[k] = val k = k+1 end end end ---- get next sample function Sampler:next() if(self.samplePos == self.sampleCount) then self:computeSamples() self.samplePos = 0 end local x = self.samples[(self.dimensions*self.samplePos)+1] local y = self.samples[(self.dimensions*self.samplePos)+2] self.samplePos = self.samplePos+1 return (self.sampleCount-self.samplePos), x, y end -- </Sampler> -- ------------------------------------------------ -- <Brdf> -- Cook Torrance -- ------------------------------------------------ Brdf = {} local Brdf_mt = Class(Brdf) ---- CTOR function Brdf:new(Rd, Rs, n, m) return setmetatable( {Rd=Rd, Rs=Rs, n=n, m=m}, Brdf_mt) end ---- Fresnel helper function fresnelHelper(c,n) local g = math.sqrt((n*n) + (c*c) - 1) local f1 = 0.5 * (math.pow(g-c,2) / math.pow(g+c,2)) local f2 = 1 + (math.pow(c*(g+c)-1, 2) / math.pow(c*(g-c)+1, 2)) return (f1*f2) end ---- Fresnel function fresnel(c, n) if(n < 0) then return 1 end return (fresnelHelper(1,n) + (((1-fresnelHelper(1,n)) * math.max(0,fresnelHelper(c,n)-fresnelHelper(1,n))) / (fresnelHelper(0,n)-fresnelHelper(1,n)))) end ---- Compute Brdf at a give point function Brdf:evaluate(n,k1,k2) local nk1 = dot(n,k1) local nk2 = dot(n,k2) if(nk2 < 0) then nk2 = 0 end -- diffuse term local diffuse = (self.Rd * nk2) / math.pi -- specular term local h = k1 + k2 h:normalize() local nh = dot(n,h) local hk1 = dot(n,k1) local hk2 = dot(n,k2) local F = fresnel(hk1,self.n) local D = math.exp(-math.pow(math.tan(math.acos(nh))/self.m,2)) / (4*self.m*self.m*math.pow(nh,4)) local G = math.min(1.0, (2.0*nh*nk1)/hk2, (2.0*nh*nk2)/hk2) local specular = (self.Rs * D * G) / (math.pi * nk1 * nk2) return diffuse, specular end -- </Brdf> -- ------------------------------------------------ -- <Light> -- Point lightsource (atm) -- ------------------------------------------------ Light = {} local Light_mt = Class(Light) ---- CTOR function Light:new(pos,i,pow) return setmetatable( {position=pos,intensity=i, power=pow}, Light_mt) end ---- get light vector function Light:getVector(p) local d local l = self.position - p d = l:magnitude() l:normalize() return l, d end -- </Light> -- -------------------------------- -- <Material> -- -------------------------------- Material = {} local Material_mt = Class(Material) ---- CTOR function Material:new(color, brdf) return setmetatable( {color=color,brdf=brdf}, Material_mt) end ---- Compute material color at a given point function Material:evaluate(n, k1, k2) local kd, ks kd, ks = self.brdf:evaluate(n,k1,k2) kd = math.min(kd, 1) ks = math.min(ks, 1) return (self.color * (kd + ks)) end -- </Material> -- -------------------------------- -- <Scene> -- -------------------------------- -- </Scene> -- -------------------------------- -- <Wee> -- -------------------------------- local obj = Triangle:new(Vector:new(0,-1,0), Vector:new(-1,1,0), Vector:new(1,1,0)) --local obj = Sphere:new(Vector:new(0,0,0), 1.0) local camera = Camera:new(Vector:new(0,0,-5), Vector:new(0,0,0), Vector:new(0,1,0), math.rad(45.0), 0.1, 1000, width/height) local sampler = Sampler:new(1, 2) local mat = Material:new(RGB:new(1,1,1), Brdf:new(0.5,0.52,1,0.65)) local angle = 2.0 * math.pi * time local cs = math.cos(angle) local sn = math.sin(angle) local pos = Vector:new(2,5,-2) local lux = {} lux[1] = Light:new(Vector:new(pos.x, cs*pos.y + sn*pos.z, -sn*pos.y + cs*pos.z), RGB:new(1,0,0), 100) lux[2] = Light:new(Vector:new(cs*pos.x + sn*pos.z, pos.y, -sn*pos.x + cs*pos.z), RGB:new(0,1,0), 100) for y=0, height-1 do for x=0, width-1 do local hasSample local sample = 0 local alpha = 0 local i = RGB:new(0,0,0) repeat local dx, dy hasSample, dx, dy = sampler:next() local ray = camera:getRay(x+0.5-dx,y+0.5-dy) local intersect, t intersect,t = obj:intersect(ray) if((intersect == 1) and (t >= camera.near)) then local p, n p, n = obj:getLocalInformations(ray, t) for key, light in lux do local l = light.position - p local d = l:magnitude() l = l / math.sqrt(d) local nl = dot(n,l) if(nl >= 0) then i = i + ((mat:evaluate(n,l,-ray.direction) * nl * light.power * light.intensity) / d) end end alpha = alpha + 1 end until hasSample <= 0 i.r = math.min(i.r / sampler.sampleCount, 1) i.g = math.min(i.g / sampler.sampleCount, 1) i.b = math.min(i.b / sampler.sampleCount, 1) alpha = alpha / sampler.sampleCount set_rgba(x,y, i.r, i.g, i.b, alpha) end progress (y/height) end -- </Wee>!!

raytrace_old

-- Raytraced sphere (Cook-Torrance Brdf) -- Vincent 'MooZ' Cruz (vcruz@free.fr) ---- Primes array local primes = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613 } -- -------------------------------- -- <Class> -- -------------------------------- function Class(members) members = members or {} local mt = { __metatable = members; __index = members; } local function new(_, init) return setmetatable(init or {}, mt) end local function copy(obj, ...) local newobj = obj:new(unpack(arg)) for n,v in pairs(obj) do newobj[n] = v end return newobj end members.new = members.new or new members.copy = members.copy or copy return mt end -- </Class> -- -------------------------------- -- <Vector> -- -------------------------------- Vector = {} local Vector_mt = Class(Vector) ---- CTOR function Vector:new(x, y, z) return setmetatable( {x=x, y=y, z=z}, Vector_mt) end ---- function Vector_mt.__add(u, v) return Vector:new(u.x + v.x, u.y + v.y, u.z + v.z) end ---- function Vector_mt.__sub(u, v) return Vector:new(u.x - v.x, u.y - v.y, u.z - v.z) end ---- function Vector_mt.__unm(u) return Vector:new(-u.x, -u.y, -u.z) end ---- function Vector_mt.__mul(u, s) return Vector:new(u.x * s, u.y * s, u.z * s) end ---- function Vector_mt.__mul(s, u) return Vector:new(s * u.x, s * u.y, s * u.z) end ---- function Vector_mt.__div(u, s) return Vector:new(u.x / s, u.y / s, u.z / s) end ---- function Vector:dot(u) return (self.x * u.x) + (self.y * u.y) + (self.z * u.z) end ---- function cross(u,v) return Vector:new((u.y*v.z) - (u.z*v.y), (u.x*v.z) - (u.z*v.x), (u.x*v.y) - (u.y*v.x)) end ---- function Vector:magnitude() return ((self.x * self.x) + (self.y * self.y) + (self.z * self.z)) end ---- function Vector:norm() return math.sqrt(self:magnitude()) end ---- function Vector:normalize() local n = self:norm(); if(n ~= 0) then self.x = self.x / n; self.y = self.y / n; self.z = self.z / n; end end -- </Vector> -- -------------------------------- -- <RGB> -- -------------------------------- RGB = {} local RGB_mt = Class(RGB) -- CTOR function RGB:new(red, green, blue) return setmetatable( {r=red, g=green, b=blue}, RGB_mt) end ---- function RGB_mt.__add(c0, c1) return RGB:new(c0.r + c1.r, c0.g + c1.g, c0.b + c1.b) end ---- function RGB_mt.__sub(c0, c1) return RGB:new(c0.r - c1.r, c0.g - c1.g, c0.b - c1.b) end ---- function RGB_mt.__unm(c) return RGB:new(-c.r, -c.g, -c.b) end ---- function RGB_mt.__mul(c, s) return RGB:new(c.r * s, c.g * s, c.b * s) end ---- function RGB_mt.__mul(s, c) return RGB:new(s * c.r, s * c.g, s * c.b) end ---- function RGB_mt.__div(c, s) return RGB:new(c.r / s, c.g / s, c.b / s) end ---- -- more to come -- </Color> -- -------------------------------- -- <Ray> -- -------------------------------- Ray = {} local Ray_mt = Class(Ray) ---- CTOR function Ray:new(o, d, t) return setmetatable( {origin=o, direction=d, distance=t}, Ray_mt) end -- </Ray> -- -------------------------------- -- <Sphere> -- -------------------------------- Sphere = {} local Sphere_mt = Class(Sphere) ---- CTOR function Sphere:new(c, r) return setmetatable( {center=c, radius=r}, Sphere_mt) end ---- Intersection test function Sphere:intersect(ray) local tmp = ray.origin - self.center local a = ray.direction:magnitude() local b = 2.0 * tmp:dot(ray.direction) local c = tmp:magnitude() - (self.radius * self.radius) -- quadric solver (whee) local d = (b*b) - (4.0*a*c) if(d < 0.0) then -- no intersection found -- intersection=0, t=0 return 0, 0 else -- 2 intersection points local t0 = (- b - math.sqrt(d)) / (2.0 * a) local t1 = (- b + math.sqrt(d)) / (2.0 * a) if(t0 < 0) then if(t1 < 0) then return 0, 0 else return 1, t1 end elseif(t1 < 0) then return 1, t0 elseif(t0 < t1) then return 1, t0 else return 1, t1 end end end -- Get local information such as normal, etc... function Sphere:getLocalInformations(ray, t) -- point local p = ray.origin + (t * ray.direction) -- normal local n = p - self.center n:normalize() return p,n end -- </Sphere> -- -------------------------------- -- <Camera> -- -------------------------------- Camera = {} local Camera_mt = Class(Camera) ---- CTOR function Camera:new(origin, target, up, fov, near, far, aspect) -- direction vector local d = target - origin d:normalize() local l = cross(up, d) l:normalize() up = cross(d, l) up:normalize() -- Let's save some computation local screen = near * math.tan(fov * 0.5) return setmetatable({eye=origin, left=l, up=up, direction=d, fov=fov, near=near, far=far, aspect=aspect, screen=screen} , Camera_mt) end ---- get ray function Camera:getRay(px, py) local dx = ((px / width) - 0.5) * self.screen * self.aspect local dy = ((py / height) - 0.5) * self.screen local direction = (self.near * self.direction) + (dx * self.left) + (dy * self.up) direction:normalize() return Ray:new(self.eye, direction, 0) end -- </Camera> -- ------------------------------------------------ -- <Sampler> -- Scrambled hammersley with faure permutation -- ------------------------------------------------ Sampler = {} local Sampler_mt = Class(Sampler) ---- CTOR function Sampler:new(sampleCount, dimensions) local permutation = {} permutation[1] = {0} permutation[2] = {0, 1} for i=3, primes[dimensions] do permutation[i] = {} -- even if(math.mod(i, 2) == 0) then for j=0, (i/2)-1 do permutation[i][j+1] = 2 * permutation[(i/2)][j+1] end for j=i/2, i-1 do permutation[i][j+1] = permutation[i][j-(i/2)+1]+1 end -- odd else for j=0, ((i-1)/2)-1 do if((2*permutation[i-1][j+1]) >= (i-1)) then permutation[i][j+1] = permutation[i-1][j+1]+1 else permutation[i][j+1] = permutation[i-1][j+1] end end permutation[i][((i-1)/2)+1] = (i-1)/2 for j=(i+1)/2, i-1 do if((2*permutation[i-1][j]) >= (i-1)) then permutation[i][j+1] = permutation[i-1][j]+1 else permutation[i][j+1] = permutation[i-1][j] end end end end return setmetatable( {sampleCount=sampleCount, dimensions=dimensions, samples={}, samplePos=sampleCount, permutation=permutation}, Sampler_mt) end ---- Van Der Corput + Faure permutation function Sampler:Vdc(i, base) local u, f, factor, digit u = 0.0 factor = 1.0 / base f = factor while i>0 do digit = math.mod(i, base) u = u + (self.permutation[base][digit+1] * factor) i = math.floor(i / base) factor = factor * f end return u end ---- sample function function Sampler:computeSamples() local k=1 for j=1, self.sampleCount do for i=1, self.dimensions do local val = self:Vdc(j-1, primes[i]) self.samples[k] = val k = k+1 end end end ---- get next sample function Sampler:next() if(self.samplePos == self.sampleCount) then self:computeSamples() self.samplePos = 0 end local x = self.samples[(self.dimensions*self.samplePos)+1] local y = self.samples[(self.dimensions*self.samplePos)+2] self.samplePos = self.samplePos+1 return (self.sampleCount-self.samplePos), x, y end -- </Sampler> -- ------------------------------------------------ -- <Brdf> -- Cook Torrance -- ------------------------------------------------ Brdf = {} local Brdf_mt = Class(Brdf) ---- CTOR function Brdf:new(Rd, Rs, n, m) return setmetatable( {Rd=Rd, Rs=Rs, n=n, m=m}, Brdf_mt) end ---- Fresnel helper function fresnelHelper(c,n) local g = math.sqrt((n*n) + (c*c) - 1) local f1 = 0.5 * (math.pow(g-c,2) / math.pow(g+c,2)) local f2 = 1 + (math.pow(c*(g+c)-1, 2) / math.pow(c*(g-c)+1, 2)) return (f1*f2) end ---- Fresnel function fresnel(c, n) if(n < 0) then return 1 end return (fresnelHelper(1,n) + (((1-fresnelHelper(1,n)) * math.max(0,fresnelHelper(c,n)-fresnelHelper(1,n))) / (fresnelHelper(0,n)-fresnelHelper(1,n)))) end ---- Compute Brdf at a give point function Brdf:evaluate(n,k1,k2) local nk1 = n:dot(k1) local nk2 = n:dot(k2) if(nk2 < 0) then nk2 = 0 end -- diffuse term local diffuse = (self.Rd * nk2) / math.pi -- specular term local h = k1 + k2 h:normalize() local nh = n:dot(h) local hk1 = h:dot(k1) local hk2 = h:dot(k2) local F = fresnel(hk1,self.n) local D = math.exp(-math.pow(math.tan(math.acos(nh))/self.m,2)) / (4*self.m*self.m*math.pow(nh,4)) local G = math.min(1.0, (2.0*nh*nk1)/hk2, (2.0*nh*nk2)/hk2) local specular = (self.Rs * D * G) / (math.pi * nk1 * nk2) if(specular < 0) then specular = 0 end if(diffuse < 0) then diffuse = 0 end return specular + diffuse end -- </Brdf> -- ------------------------------------------------ -- <Light> -- Point lightsource (atm) -- ------------------------------------------------ Light = {} local Light_mt = Class(Light) ---- CTOR function Light:new(pos,i,pow) return setmetatable( {position=pos,intensity=i, power=pow}, Light_mt) end ---- get light vector function Light:getVector(p) local d local l = self.position - p d = l:magnitude() l:normalize() return l, d end -- </Light> -- -------------------------------- -- <Scene> -- -------------------------------- -- </Scene> -- -------------------------------- -- <Wee> -- -------------------------------- local sphere = Sphere:new(Vector:new(0,0,0), 1.0) local camera = Camera:new(Vector:new(0,0,-5), Vector:new(0,0,0), Vector:new(0,1,0), math.rad(45.0), 0.1, 1000, width/height) local sampler = Sampler:new(1, 2) local brdf = Brdf:new(0.5,0.5,1,0.65) local angle = 2.0 * math.pi * time local cs = math.cos(angle) local sn = math.sin(angle) local pos = Vector:new(2,5,-2) local lux = {} lux[1] = Light:new(Vector:new(pos.x, cs*pos.y + sn*pos.z, -sn*pos.y + cs*pos.z), RGB:new(1,0,0), 100) lux[2] = Light:new(Vector:new(cs*pos.x + sn*pos.z, pos.y, -sn*pos.x + cs*pos.z), RGB:new(0,1,0), 100) for y=0, height-1 do for x=0, width-1 do local hasSample local sample = 0 local alpha = 0 local i = RGB:new(0,0,0) repeat local dx, dy hasSample, dx, dy = sampler:next() local ray = camera:getRay(x+0.5-dx,y+0.5-dy) local intersect, t intersect,t = sphere:intersect(ray) if((intersect == 1) and (t >= camera.near)) then local p, n p, n = sphere:getLocalInformations(ray, t) for key, light in lux do local l = light.position - p local d = l:magnitude() l = l / math.sqrt(d) local nl = n:dot(l) if(nl >= 0) then i = i + ((brdf:evaluate(n,l,-ray.direction) * nl * light.power * light.intensity) / d) end end alpha = alpha + 1 end until hasSample <= 0 i.r = math.min(i.r / sampler.sampleCount, 1) i.g = math.min(i.g / sampler.sampleCount, 1) i.b = math.min(i.b / sampler.sampleCount, 1) alpha = alpha / sampler.sampleCount set_rgba(x,y, i.r, i.g, i.b, alpha) end progress (y/height) end -- </Wee>!!

rotozoom

-- rotozoom by Vincent 'MooZ' Cruz (vcruz@free.fr) local x,y local rx,ry local u0,v0 local u1,v1 local u,v local r,g,b,a angle=math.rad(45) zoom=1.5 rx=math.cos(angle)*zoom ry=math.sin(angle)*zoom u0=0 v0=0 u1=0 v1=0 for y=0, height-1 do u1=u0 v1=v0 for x=0, width-1 do u1=u1+rx v1=v1+ry if(u1<0) then u=width-math.mod(math.abs(u1),width)-1 else u=math.mod(u1,width) end if(v1 < 0) then v=height-math.mod(math.abs(v1),height)-1 else v=math.mod(v1,height) end r,g,b,a=get_rgba(u,v) set_rgba(x,y,r,g,b,a) end u0=u0-ry v0=v0+rx progress (y/height) end

sierpsinsky

-- iterated sierpsinsky renderer iterations = 100000 local x,y x = width/2 y = height/2 for iter=0, iterations do choice=math.random() if choice > 0.66 then x = (x+0.5 * width) / 2 y = (y+0.0 * height) / 2 elseif choice > 0.33 then x = (x+1 * width) / 2 y = (y+1.0 * height) / 2 else x = (x+0 * width) / 2 y = (y+1.0 * height) / 2 end set_value (x,y, 1) progress (iter / iterations) end

threshold

level = 0.5 for y=0, height-1 do for x=0, width-1 do v = get_value (x,y) if v < level then v=1.0 else v=0.0 end set_value (x,y,v) end progress (y/height) end