ウォークスルー

@title "ネガポジ反転"

def result_u8 |x, y|{
	let [b, g, r, a] = input_u8(x, y)
  u8[255-b, 255-g, 255-r, a]
}

u8([255-b, 255-g, 255-r, a])

@title "モザイク"
@param_i32 MOSAIC_WIDTH(SLIDER, label="サイズ", min=2, max=256, init=16)

let clamped = sampler<input_u8>(address=.ClampToEdge)

@bounds( (input_u8.extent(0)-1)/MOSAIC_WIDTH+1, (input_u8.extent(1)-1)/MOSAIC_WIDTH+1)
def avg |x, y|{
	rsum(0..<MOSAIC_WIDTH, 0..<MOSAIC_WIDTH) |rx, ry|{
		let [b, g, r, a] = i32(clamped( MOSAIC_WIDTH*x+rx, MOSAIC_WIDTH*y+ry ))
    [*[b, g, r]*a, a]	}
}

def result_u8 |x2, y2| {
let [b2, g2, r2, a2] = avg( x2/MOSAIC_WIDTH, y2/MOSAIC_WIDTH )

  ifel(a2==0, u8[0, 0, 0, 0],
		    u8[*[b2, g2, r2]/a2, a2/(MOSAIC_WIDTH*MOSAIC_WIDTH)] )
}

@title "移動ぼかし"

@param_f32 strength(SLIDER, label="強度", min=3.0, max=300.0, init=10.0)
@param_f32 angle(SLIDER, label="角度", min=0.0, max=3.2, init=0.0)

let sample = 2

let DeltaU = i32( cos(angle) * 65536 / sample )
let DeltaV = i32( sin(angle) * 65536 / sample )

let mw = i32( strength * sample )

let ar = 0.33 * mw

@bounds(mw+1)
def weights |m|{ 100 * exp( -m*m / (2*ar*ar) ) }

@bounds(input.extent(0), input.extent(1))
def mid_all |x, y| {
  rsum(-mw..<mw+1) |rx| {

	  let px = x + ((DeltaU * rx) >> 16)
	  let py = y + ((DeltaV * rx) >> 16)
	  
    let inside = input_u8.is_inside(px, py)
    let gauss = ifel(inside, weights( abs(rx) ), 0.0)
	
    let [b, g, r, a] = f32(input_u8( px, py ))
	  let ga = gauss * a
	
		[
			*[b, g, r]*ga,
	    ga,
	    gauss
	   ]
	}
}

def result_u8 |x, y| {
  let [mid_b, mid_g, mid_r, mid_a, count] = mid_all(x, y)

  ifel( mid_a == 0,
    u8[0, 0, 0, 0],
    u8[*[mid_b, mid_g, mid_r]/mid_a,  (mid_a / count)]
  )
}

@title "砂あらし"

def result_u8 |x, y| {
  ifel( rand() > 0.5, u8[0, 0, 0, 0xff], u8[0xff, 0xff, 0xff, 0xff] )
}

@title "ごま塩ノイズ"

# 0.05とか指定する。randの結果がそれ以下なら白か黒を入れる
@param_f32 SALT_THRESHOLD(SLIDER, label="塩しきい値", min=0.0, max=1.0, init=0.1)
@param_f32 PEPPER_THRESHOLD(SLIDER, label="ゴマしきい値", min=0.0, max=1.0, init=0.1)

def result_u8 |x, y| {
	let r = rand()
  ifel( r < SALT_THRESHOLD,
    u8[0xff, 0xff, 0xff, 0xff], ...)
  elif( (1.0 - r) < PEPPER_THRESHOLD,
    u8[0, 0, 0, 0xff],
    input_u8(x, y))
}

def weight by [[1, 2, 1],
               [2, 3, 2],
               [1, 2, 1]]

# xとyがmedianを求められるように、
# x: 1〜w-1
# y: 1〜h-1
# の範囲で計算する。
@bounds(input_u8.extent(0)-2, input_u8.extent(1)-2)
def median |x, y| {
  @bounds(256, 4)
  def _hist |i, col| { 0 }

  weight.for_each |ix, iy, wval| {
     let [b, g, r, a] = input_u8(ix+x, iy+y)
     mut! _hist(b, 0) += wval
     mut! _hist(g, 1) += wval
     mut! _hist(r, 2) += wval
     mut! _hist(a, 3) += wval
  }

  # cumsumを求めるが、配列としては_histを上書きしていく（サイズ制限がきついので）
  mut! trans<_hist>.accumulate!(dim=0) |i, col, val, accm | { val+accm }

  # hist(255, rgb)は総登場回数（weightはその分重複して登場したと解釈）。その半分で
  def _med by reduce<_hist>.find_first_index(dim=0) |i, col, val| {
     val >= _hist(255,col)/2
  }
  [_med(0), _med(1), _med(2), _med(3)]
}

def result_u8 |x, y| {
  ifel( x == 0 || y == 0 || x == input_u8.extent(0)-1 || y == input_u8.extent(1) -1,
      input_u8(x, y),
      median(x-1, y-1))
}

def weight by [[1, 2, 1],
               [2, 3, 2], 
               [1, 2, 1]] 

# xとyがmedianを求められるように、
# x: 1からw-1
# y: 1からh-1
# の範囲で計算する。
@bounds(input_u8.extent(0)-2, input_u8.extent(1)-2)
def median |x, y| {

	@bounds(9)
  def wcumsum |i| {
     let [ix, iy] = [i%3, i/3]
     weight(ix, iy)
  }

  mut! trans<wcumsum>.cumsum!(dim=0)

  # 15はweightの合計。ローカルテンソルなのでIMMでないといけない。
  @bounds(15)
  def wmat |i| {
     let i3 = reduce<wcumsum>.find_first_index(dim=0) |_, val| { i < val }

     let [ix, iy] = [i3%weight.extent(0), i3/weight.extent(0)]
     i32(input_u8(ix+x, iy+y))
  }
  
  mut! trans<wmat>.sort!(dim=0)

  u8(wmat(wmat.extent(0)/2))
}

def result_u8 |x, y| {
  ifel( x == 0 || y == 0 || x == input_u8.extent(0)-1 || y == input_u8.extent(1) -1,
      input_u8(x, y),
      median(x-1, y-1))
}

@title "白黒マンデルブロ集合"

def result_u8 |x, y| {
  let x0 = f32(x)*4.0/f32(input_u8.extent(0))-2.0
  let y0 = f32(y)*4.0/f32(input_u8.extent(1))-2.0
  let [flag, _, _] = reduce(init=[0, x0, y0], 0..<100) |index, accm| {
    let [f, x1, y1] = accm
    let x2 = x1^2-y1^2+x0
    let y2 = 2*x1*y1+y0
    let r = x2^2+y2^2
    ifel(f == 1,
         [1, 0, 0],
         ...)
    elif( r > 4,
         [1, 0, 0],
         [0, x2, y2])
  }
  ifel(flag == 1,
       u8[0xff, 0xff, 0xff, 0xff],
       u8[0,  0, 0, 0xff])
}

@title "白黒マンデルブロ集合"
@param_f32 ZOOM(SLIDER, label="ズーム", min=0.001, max=1.0, init=0.1)
@param_f32v2 ORIGIN(POINTER, label="中心") 

let [ox, oy] = ORIGIN
let [cx, cy] = [ox*f32(input_u8.extent(0)), oy*f32(input_u8.extent(1))]

def result_u8 |x, y| {
  let x0 = 0.1/ZOOM * ((f32(x)-ZOOM*cx)*4.0/f32(input_u8.extent(0))-2.9)
  let y0 = 0.1/ZOOM* ((f32(y)-ZOOM*cy)*4.0/f32(input_u8.extent(1))-2.9)
  let [flag, _, _] = reduce(init=[0, x0, y0], 0..<100) |index, accm| {
    let [f, x1, y1] = accm
    let x2 = x1^2-y1^2+x0
    let y2 = 2*x1*y1+y0
    let r = x2^2+y2^2
    ifel(f == 1,
         [1, 0, 0],
         ...)
    elif( r > 4,
         [1, 0, 0],
         [0, x2, y2])
  }
  ifel(flag == 1,
       u8[0xff, 0xff, 0xff, 0xff],
       u8[0,  0, 0, 0xff])
}

@bounds(50, 50)
def gridNoise |x, y| {
  [2.0*rand()-1.0, 2.0*rand()-1.0]
}

let gridNoiseEx = sampler<gridNoise>(address=.ClampToEdge)

def result_u8 |x, y| {
  let [fx, fy] = [f32(x)/f32(W), f32(y)/f32(H)]

  let [gridX0, gridY0] = [i32(fx*50), i32(fy*50)]
  let [gridX1, gridY1] = [gridX0+1, gridY0+1]

  # 0.0 < dx0, dy0 < 1.0
  # -1.0 < dx1, dy1 < 0.0
  let [dx0, dy0] = [fx*50-gridX0, fy*50-gridY0]
  let [dx1, dy1] = [dx0-1.0, dy0-1.0]

  let [noise00X, noise00Y] = gridNoiseEx(gridX0, gridY0)
  let dp00 = dx0*noise00X+dy0*noise00Y
  
  let [noise10X, noise10Y] = gridNoiseEx(gridX1, gridY0)
  let dp10 = dx1*noise10X+dy0*noise10Y

  let [noise01X, noise01Y] = gridNoiseEx(gridX0, gridY1)
  let dp01 = dx0*noise01X+dy1*noise01Y

  let [noise11X, noise11Y] = gridNoiseEx(gridX1, gridY1)
  let dp11 = dx1*noise11X+dy1*noise11Y

  let dp0 = dp00*(1.0-dx0)+dp10*dx0
  let dp1 = dp01*(1.0-dx0)+dp11*dx0

  # -1から1
  let dp = dp0*(1.0-dy0)+dp1*dy0

  let normalized = dp*0.5+0.5
  let [r, g, b] = i32( normalized*[FG_R, FG_G, FG_B] )
  u8[b, g, r, 255]

@title "パーリンノイズ"

let [W, H] = input_u8.extent()

let GRID_W = 50

@bounds(50, 50)
def gridNoise |x, y| {
  [2.0*rand()-1.0, 2.0*rand()-1]
}

let gridNoiseEx = sampler<gridNoise>(address=.ClampToEdge)

let FG_R = 255
let FG_G = 0
let FG_B = 0

def result_u8 |x, y| {
  let [fx, fy] = [f32(x)/f32(W), f32(y)/f32(H)]

  let [gridX0, gridY0] = [i32(fx*GRID_W), i32(fy*GRID_W)]
  let [gridX1, gridY1] = [gridX0+1, gridY0+1]

  # 0.0 < dx0, dy0 < 1.0
  # -1.0 < dx1, dy1 < 0.0
  let [dx0, dy0] = [fx*GRID_W-gridX0, fy*GRID_W-gridY0]
  let [dx1, dy1] = [dx0-1.0, dy0-1.0] 

  let [noise00X, noise00Y] = gridNoiseEx(gridX0, gridY0)
  let dp00 = dx0*noise00X+dy0*noise00Y
  
  let [noise10X, noise10Y] = gridNoiseEx(gridX1, gridY0)
  let dp10 = dx1*noise10X+dy0*noise10Y

  let [noise01X, noise01Y] = gridNoiseEx(gridX0, gridY1)
  let dp01 = dx0*noise01X+dy1*noise01Y

  let [noise11X, noise11Y] = gridNoiseEx(gridX1, gridY1)
  let dp11 = dx1*noise11X+dy1*noise11Y

  let dp0 = dp00*(1.0-dx0)+dp10*dx0
  let dp1 = dp01*(1.0-dx0)+dp11*dx0

  # -1から1
  let dp = dp0*(1.0-dy0)+dp1*dy0

  let normalized = dp*0.5+0.5
  let [r, g, b] = i32( normalized*[FG_R, FG_G, FG_B] )
  u8[b, g, r, 255]
}

@title "水鏡"

@param_f32v2 CENTER(POINTER, label="鏡の位置")

let [_, cy] = CENTER
let finput = sampler<input_u8>(coord=.NormalizedLinear)
# let finput = sampler<input_u8>(coord=.NormalizedNearest)

def result_u8 |x, y| {
  let [fx, fy] = to_ncoord([x, y])

  let diff = fy - cy
  let ratio =  diff/(1-cy)
  
  let srcY = cy -   cy*ratio

  let [b, g, r, _] = finput(fx, srcY)
  
  ifel( fy < cy, input_u8(x, y),  u8[b, g, r, 0x88])
}

@param_f32v2 v2_pos(POINTER, label="制御点")

# 底辺、とりあえずハードコードで(0.2, 0.8), (0.8, 0.8)とする。3次元にしておく。
let v0 = [0.2, 0.8, 0.0]
let v1 = [0.8, 0.8, 0.0]
let v2 = [*v2_pos, 0.0]

def result_u8 |x, y| {
  let fxy = [*to_ncoord([x, y]), 0.0]

  let first = cross((v1-v0), fxy - v0).z
  let second = cross((v2- v1), fxy-v1).z
  let third = cross((v0-v2), fxy-v2).z

  ifel(first*second > 0.0 && second*third > 0.0, u8[0, 0xff, 0, 0x88], u8[0, 0, 0, 0])
}

@title "ベジエ"

@param_f32v2 v2_pos(POINTER, label="制御点")

# 底辺、とりあえずハードコードで(0.2, 0.8), (0.8, 0.8)とする。3次元にしておく。
let v0 = [0.2, 0.8, 0.0]
let v1 = [0.8, 0.8, 0.0]
let v2 = [*v2_pos, 0.0]

# uv座標の３つの点
let uv0 = [0.0, 0.0]
let uv1 = [0.5, 0.0]
let uv2 = [1.0, 1.0]

def result_u8 |x, y| {
  let fxy = [*to_ncoord([x, y]), 0.0]

  # v1を起点として三角形を描く。外積の符号で判断
  let first = cross((v1-v0), fxy - v0).z
  let second = cross((v2- v1), fxy-v1).z
  let third = cross((v0-v2), fxy-v2).z
  let insideTriangle = first*second > 0.0 && second*third > 0.0

  # fxyのv0, v1, v2の重心座標を求める。
  let pv0 = v0 - fxy
  let pv1 =  v1 - fxy
  let pv2 = v2 - fxy
  let area = cross(v1-v0, v2-v0).z
  let bp0 = [cross(pv1, pv2).z, cross(pv2, pv0).z, cross(pv0, pv1).z]
  let bp = abs(bp0)/abs(area)

  let uvp =   bp.y*uv0+bp.z*uv1+bp.x*uv2
  let f = uvp.x*uvp.x-uvp.y

  ifel(insideTriangle && f < 0.0, u8[0, 0, 0xff, 0xff] ,...)
  elif(insideTriangle, u8[0, 0xff, 0, 0x88],  u8[0, 0, 0, 0])
}

@title "繰り返し"

@param_f32v2 pos(POINTER, label="右下の点")

let wh = i32(pos*f32(input_u8.extent()))

def result_u8 |x, y| {
  let xy0 = [x, y] % wh
  input_u8(*xy0)
}