505colors.mu

   1 fn nearest-color-euclidean r: int, g: int, b: int -> _/eax: int {
   2   var result/edi: int <- copy 0x100/invalid
   3   var max-distance/esi: int <- copy 0x30000/max  # 3 * 0x100*0x100
   4   var r2/ecx: int <- copy 0
   5   var g2/edx: int <- copy 0
   6   var b2/ebx: int <- copy 0
   7   var color/eax: int <- copy 0
   8   {
   9     compare color, 0x100
  10     break-if->=
  11     $nearest-color-euclidean:body: {
  12       r2, g2, b2 <- color-rgb color
  13       {
  14         var curr-distance/eax: int <- euclidean-distance-squared r, g, b, r2, g2, b2
  15         compare curr-distance, max-distance
  16         break-if->= $nearest-color-euclidean:body
  17         max-distance <- copy curr-distance
  18       }
  19       result <- copy color
  20     }
  21     color <- increment
  22     loop
  23   }
  24   return result
  25 }
  26
  27 fn euclidean-distance-squared r1: int, g1: int, b1: int, r2: int, g2: int, b2: int -> _/eax: int {
  28   var result/edi: int <- copy 0
  29   # red
  30   var tmp/eax: int <- copy r1
  31   tmp <- subtract r2
  32   tmp <- multiply tmp
  33   result <- add tmp
  34   # green
  35   tmp <- copy g1
  36   tmp <- subtract g2
  37   tmp <- multiply tmp
  38   result <- add tmp
  39   # blue
  40   tmp <- copy b1
  41   tmp <- subtract b2
  42   tmp <- multiply tmp
  43   result <- add tmp
  44   return result
  45 }
  46
  47 # Hue/saturation/luminance for an rgb triple.
  48 # rgb are in [0, 256)
  49 # hsl are also returned in [0, 256)
  50 # from https://www.niwa.nu/2013/05/math-behind-colorspace-conversions-rgb-hsl
  51 fn hsl r: int, g: int, b: int -> _/ecx: int, _/edx: int, _/ebx: int {
  52   var _max/eax: int <- maximum r, g
  53   _max <- maximum _max, b
  54   var max/ecx: int <- copy _max
  55   var _min/eax: int <- minimum r, g
  56   _min <- minimum _min, b
  57   var min/edx: int <- copy _min
  58   var luminance/ebx: int <- copy min
  59   luminance <- add max
  60   luminance <- shift-right 1  # TODO: round up instead of down
  61   # if rgb are all equal, it's a shade of grey
  62   compare min, max
  63   {
  64     break-if-!=
  65     return 0, 0, luminance
  66   }
  67   # saturation =
  68   #   luminance < 128 | 255*(max-min)/         (max+min)
  69   #   otherwise       | 255*(max-min)/(2*255 - (max+min))
  70   var nr/esi: int <- copy max
  71   nr <- subtract min
  72   var dr/eax: int <- copy 0
  73   compare luminance, 0x80
  74   {
  75     break-if->=
  76     dr <- copy max
  77     dr <- add min
  78   }
  79   {
  80     break-if-<
  81     dr <- copy 0xff
  82     dr <- shift-left 1
  83     dr <- subtract max
  84     dr <- subtract min
  85   }
  86   var q/xmm0: float <- convert nr
  87   var tmp/xmm1: float <- convert dr
  88   q <- divide tmp
  89   var int-255/eax: int <- copy 0xff
  90   tmp <- convert int-255
  91   q <- multiply tmp
  92   var saturation/esi: int <- convert q
  93   # hue =
  94   #   red is max   | 256.0/6*       (g-b)/(max-min)
  95   #   green is max | 256.0/6*(2.0 + (b-r)/(max-min))
  96   #   blue is max  | 256.0/6*(4.0 + (r-g)/(max-min))
  97   var zero/eax: int <- copy 0
  98   var hue-f/xmm0: float <- convert zero
  99   var dr/eax: int <- copy max
 100   dr <- subtract min
 101   var dr-f/xmm1: float <- convert dr
 102   $hsl:compute-hue-normalized: {
 103     compare r, max
 104     {
 105       break-if-!=
 106       var nr/eax: int <- copy g
 107       nr <- subtract b
 108       hue-f <- convert nr
 109       hue-f <- divide dr-f
 110       break $hsl:compute-hue-normalized
 111     }
 112     compare g, max
 113     {
 114       break-if-!=
 115       var nr/eax: int <- copy b
 116       nr <- subtract r
 117       var f/xmm2: float <- convert nr
 118       f <- divide dr-f
 119       var two/ecx: int <- copy 2
 120       hue-f <- convert two
 121       hue-f <- add f
 122       break $hsl:compute-hue-normalized
 123     }
 124     compare b, max
 125     {
 126       break-if-!=
 127       var nr/eax: int <- copy r
 128       nr <- subtract g
 129       var f/xmm2: float <- convert nr
 130       f <- divide dr-f
 131       var two/ecx: int <- copy 4
 132       hue-f <- convert two
 133       hue-f <- add f
 134       break $hsl:compute-hue-normalized
 135     }
 136   }
 137   var int-256/eax: int <- copy 0x100
 138   var scaling-factor/xmm1: float <- convert int-256
 139   var int-6/eax: int <- copy 6
 140   var six-f/xmm2: float <- convert int-6
 141   scaling-factor <- divide six-f
 142   hue-f <- multiply scaling-factor
 143   var hue/eax: int <- convert hue-f
 144   # if hue < 0, hue = 256 - hue
 145   compare hue, 0
 146   {
 147     break-if->=
 148     var tmp/ecx: int <- copy 0x100
 149     tmp <- subtract hue
 150     hue <- copy tmp
 151   }
 152   return hue, saturation, luminance
 153 }
 154
 155 fn test-hsl-black {
 156   var h/ecx: int <- copy 0
 157   var s/edx: int <- copy 0
 158   var l/ebx: int <- copy 0
 159   h, s, l <- hsl 0, 0, 0
 160   check-ints-equal h, 0, "F - test-hsl-black/hue"
 161   check-ints-equal s, 0, "F - test-hsl-black/saturation"
 162   check-ints-equal l, 0, "F - test-hsl-black/luminance"
 163 }
 164
 165 fn test-hsl-white {
 166   var h/ecx: int <- copy 0
 167   var s/edx: int <- copy 0
 168   var l/ebx: int <- copy 0
 169   h, s, l <- hsl 0xff, 0xff, 0xff
 170   check-ints-equal h, 0, "F - test-hsl-white/hue"
 171   check-ints-equal s, 0, "F - test-hsl-white/saturation"
 172   check-ints-equal l, 0xff, "F - test-hsl-white/luminance"
 173 }
 174
 175 fn test-hsl-grey {
 176   var h/ecx: int <- copy 0
 177   var s/edx: int <- copy 0
 178   var l/ebx: int <- copy 0
 179   h, s, l <- hsl 0x30, 0x30, 0x30
 180   check-ints-equal h, 0, "F - test-hsl-grey/hue"
 181   check-ints-equal s, 0, "F - test-hsl-grey/saturation"
 182   check-ints-equal l, 0x30, "F - test-hsl-grey/luminance"
 183 }
 184
 185 # red hues: 0-0x54
 186 fn test-hsl-slightly-red {
 187   var h/ecx: int <- copy 0
 188   var s/edx: int <- copy 0
 189   var l/ebx: int <- copy 0
 190   h, s, l <- hsl 0xff, 0xfe, 0xfe
 191   check-ints-equal h, 0, "F - test-hsl-slightly-red/hue"
 192   check-ints-equal s, 0xff, "F - test-hsl-slightly-red/saturation"
 193   check-ints-equal l, 0xfe, "F - test-hsl-slightly-red/luminance"  # TODO: should round up
 194 }
 195
 196 fn test-hsl-extremely-red {
 197   var h/ecx: int <- copy 0
 198   var s/edx: int <- copy 0
 199   var l/ebx: int <- copy 0
 200   h, s, l <- hsl 0xff, 0, 0
 201   check-ints-equal h, 0, "F - test-hsl-extremely-red/hue"
 202   check-ints-equal s, 0xff, "F - test-hsl-extremely-red/saturation"
 203   check-ints-equal l, 0x7f, "F - test-hsl-extremely-red/luminance"  # TODO: should round up
 204 }
 205
 206 # green hues: 0x55-0xaa
 207 fn test-hsl-slightly-green {
 208   var h/ecx: int <- copy 0
 209   var s/edx: int <- copy 0
 210   var l/ebx: int <- copy 0
 211   h, s, l <- hsl 0xfe, 0xff, 0xfe
 212   check-ints-equal h, 0x55, "F - test-hsl-slightly-green/hue"
 213   check-ints-equal s, 0xff, "F - test-hsl-slightly-green/saturation"
 214   check-ints-equal l, 0xfe, "F - test-hsl-slightly-green/luminance"  # TODO: should round up
 215 }
 216
 217 fn test-hsl-extremely-green {
 218   var h/ecx: int <- copy 0
 219   var s/edx: int <- copy 0
 220   var l/ebx: int <- copy 0
 221   h, s, l <- hsl 0, 0xff, 0
 222   check-ints-equal h, 0x55, "F - test-hsl-extremely-green/hue"
 223   check-ints-equal s, 0xff, "F - test-hsl-extremely-green/saturation"
 224   check-ints-equal l, 0x7f, "F - test-hsl-extremely-green/luminance"  # TODO: should round up
 225 }
 226
 227 # blue hues: 0xab-0xff
 228 fn test-hsl-slightly-blue {
 229   var h/ecx: int <- copy 0
 230   var s/edx: int <- copy 0
 231   var l/ebx: int <- copy 0
 232   h, s, l <- hsl 0xfe, 0xfe, 0xff
 233   check-ints-equal h, 0xab, "F - test-hsl-slightly-blue/hue"
 234   check-ints-equal s, 0xff, "F - test-hsl-slightly-blue/saturation"
 235   check-ints-equal l, 0xfe, "F - test-hsl-slightly-blue/luminance"  # TODO: should round up
 236 }
 237
 238 fn test-hsl-extremely-blue {
 239   var h/ecx: int <- copy 0
 240   var s/edx: int <- copy 0
 241   var l/ebx: int <- copy 0
 242   h, s, l <- hsl 0, 0, 0xff
 243   check-ints-equal h, 0xab, "F - test-hsl-extremely-blue/hue"
 244   check-ints-equal s, 0xff, "F - test-hsl-extremely-blue/saturation"
 245   check-ints-equal l, 0x7f, "F - test-hsl-extremely-blue/luminance"  # TODO: should round up
 246 }
 247
 248 # cyan: 0x7f
 249
 250 fn test-hsl-cyan {
 251   var h/ecx: int <- copy 0
 252   var s/edx: int <- copy 0
 253   var l/ebx: int <- copy 0
 254   h, s, l <- hsl 0, 0xff, 0xff
 255   check-ints-equal h, 0x80, "F - test-hsl-cyan/hue"
 256   check-ints-equal s, 0xff, "F - test-hsl-cyan/saturation"
 257   check-ints-equal l, 0x7f, "F - test-hsl-cyan/luminance"  # TODO: should round up
 258 }
 259
 260 fn nearest-color-euclidean-hsl h: int, s: int, l: int -> _/eax: int {
 261   var result/edi: int <- copy 0x100/invalid
 262   var max-distance/esi: int <- copy 0x30000/max  # 3 * 0x100*0x100
 263   var a/ecx: int <- copy 0
 264   var b/edx: int <- copy 0
 265   var c/ebx: int <- copy 0
 266   var color/eax: int <- copy 0
 267   {
 268     compare color, 0x100
 269     break-if->=
 270     $nearest-color-euclidean-hsl:body: {
 271       a, b, c <- color-rgb color
 272       a, b, c <- hsl a, b, c
 273       {
 274         var curr-distance/eax: int <- euclidean-hsl-squared a, b, c, h, s, l
 275         compare curr-distance, max-distance
 276         break-if->= $nearest-color-euclidean-hsl:body
 277         max-distance <- copy curr-distance
 278       }
 279       result <- copy color
 280     }
 281     color <- increment
 282     loop
 283   }
 284   return result
 285 }
 286
 287 fn test-nearest-color-euclidean-hsl {
 288   # red from lightest to darkest
 289   var red/eax: int <- nearest-color-euclidean-hsl 0, 0xff, 0xff
 290   check-ints-equal red, 0x58/88, "F - test-nearest-color-euclidean-hsl/full-red1"
 291   red <- nearest-color-euclidean-hsl 0, 0xff, 0xc0
 292   check-ints-equal red, 0x40/64, "F - test-nearest-color-euclidean-hsl/full-red2"
 293   red <- nearest-color-euclidean-hsl 0, 0xff, 0x80
 294   check-ints-equal red, 0x28/40, "F - test-nearest-color-euclidean-hsl/full-red3"
 295   red <- nearest-color-euclidean-hsl 0, 0xff, 0x40
 296   check-ints-equal red, 0x28/40, "F - test-nearest-color-euclidean-hsl/full-red4"
 297   red <- nearest-color-euclidean-hsl 0, 0xff, 0
 298   check-ints-equal red, 0x28/40, "F - test-nearest-color-euclidean-hsl/full-red5"
 299   # try a number really close to red but on the other side of the cylinder
 300   red <- nearest-color-euclidean-hsl 0xff, 0xff, 0xff
 301 #?   draw-int32-decimal-wrapping-right-then-down-from-cursor-over-full-screen 0/screen, red, 7/fg 0/bg
 302   check-ints-equal red, 0x57/87, "F - test-nearest-color-euclidean-hsl/other-end-of-red"  # still looks red
 303   # half-saturation red from lightest to darkest
 304   red <- nearest-color-euclidean-hsl 0, 0x80, 0xff
 305   check-ints-equal red, 0xf/15, "F - test-nearest-color-euclidean-hsl/half-red1"   # ?? grey ??
 306   red <- nearest-color-euclidean-hsl 0, 0x80, 0xc0
 307   check-ints-equal red, 4, "F - test-nearest-color-euclidean-hsl/half-red2"
 308   red <- nearest-color-euclidean-hsl 0, 0x80, 0x80
 309   check-ints-equal red, 4, "F - test-nearest-color-euclidean-hsl/half-red3"
 310   red <- nearest-color-euclidean-hsl 0, 0x80, 0x40
 311   check-ints-equal red, 4, "F - test-nearest-color-euclidean-hsl/half-red4"
 312   red <- nearest-color-euclidean-hsl 0, 0x80, 0
 313   check-ints-equal red, 0x70/112, "F - test-nearest-color-euclidean-hsl/half-red5"
 314 }
 315
 316 fn euclidean-hsl-squared h1: int, s1: int, l1: int, h2: int, s2: int, l2: int -> _/eax: int {
 317   var result/edi: int <- copy 0
 318   # hue
 319   var tmp/eax: int <- copy h1
 320   tmp <- subtract h2
 321   tmp <- multiply tmp
 322   # TODO: should we do something to reflect that hue is a cylindrical space?
 323   # I can't come up with a failing test.
 324   result <- add tmp
 325   # saturation
 326   tmp <- copy s1
 327   tmp <- subtract s2
 328   tmp <- multiply tmp
 329   result <- add tmp
 330   # luminance
 331   tmp <- copy l1
 332   tmp <- subtract l2
 333   tmp <- multiply tmp
 334   result <- add tmp
 335   return result
 336 }
 337
 338 ###
 339
 340 fn maximum a: int, b: int -> _/eax: int {
 341   var a2/eax: int <- copy a
 342   compare a2, b
 343   {
 344     break-if-<
 345     return a
 346   }
 347   return b
 348 }
 349
 350 fn minimum a: int, b: int -> _/eax: int {
 351   var a2/eax: int <- copy a
 352   compare a2, b
 353   {
 354     break-if->
 355     return a
 356   }
 357   return b
 358 }