#moonimage

test {
  let image = @moonimage.Image::new(640, 480, @moonimage.PixelFormat::Rgba8)
  let small = image.scale(160, 120, sampling=@moonimage.Sampling::Bilinear)
  let file = @moonimage.encode(small, @moonimage.Format::Png)
  let back = @moonimage.decode(file)
  assert_eq(back.width, 160)
  assert_eq(back.height, 120)
}

#Reading and writing

test {
  let image = @moonimage.Image::new(8, 8, @moonimage.PixelFormat::Rgb8)
  let file = @moonimage.encode(image, @moonimage.Format::Tiff)
  let safe = @moonimage.decode(file, limits=@moonimage.Limits::strict())
  assert_eq(safe.width, 8)
}

test {
  let refused = try {
    ignore(@moonimage.decode(b"not an image"))
    abort("unreachable")
  } catch {
    error => error
  }
  assert_eq(refused is @moonimage.Refused::Unknown(_), true)
}

#The image

pub(all) struct Image {
  width : Int32
  height : Int32
  format : PixelFormat
  stride : Int32
  pixels : Bytes
  premultiplied : Bool
  metadata : Metadata
}

#Moving pixels

test {
  let image = @moonimage.Image::new(4, 2, @moonimage.PixelFormat::Rgba8)
  let grey = image.convert(@moonimage.PixelFormat::Gray8)
  let wide = image.convert(@moonimage.PixelFormat::Rgba16)
  assert_eq(grey.format, @moonimage.PixelFormat::Gray8)
  assert_eq(wide.format, @moonimage.PixelFormat::Rgba16)
  let flat = image.to_premultiplied()
  assert_eq(flat.premultiplied, true)
  assert_eq(flat.to_straight().premultiplied, false)
}

test {
  let image = @moonimage.Image::new(3, 2, @moonimage.PixelFormat::Rgba8)
  assert_eq(image.flip_horizontal().width, 3)
  assert_eq(image.flip_vertical().height, 2)
  assert_eq(image.rotate(quarters=1).width, 2)
  assert_eq(image.crop(0, 0, 2, 1).height, 1)
}

test {
  let image = @moonimage.Image::new(9, 7, @moonimage.PixelFormat::Rgb8)
  for
    sampling in [
      @moonimage.Sampling::Nearest,
      @moonimage.Sampling::Bilinear,
      @moonimage.Sampling::CatmullRom,
      @moonimage.Sampling::Gaussian,
      @moonimage.Sampling::Lanczos,
    ] {
    assert_eq(image.scale(16, 12, sampling~).width, 16)
  }
}

test {
  let image = @moonimage.Image::new(8, 4, @moonimage.PixelFormat::Rgba8)
  let tilted = image.rotate_by(30.0, expand=true)
  assert_eq(tilted.width > 8, true)
  assert_eq(image.rotate_by(90.0).width, 4)
}

#Filters and colour

test {
  let image = @moonimage.Image::new(6, 5, @moonimage.PixelFormat::Rgba8)
  let soft = image.blur(1.5)
  assert_eq(soft.width, 6)
  let crisp = soft.unsharp_mask(radius=1.0, amount=150.0, threshold=3)
  assert_eq(crisp.height, 5)
}

test {
  let image = @moonimage.Image::new(6, 5, @moonimage.PixelFormat::Rgba8)
  let same_as_pillow = image.blur(1.5, kernel=@moonimage.Kernel::Boxes)
  assert_eq(same_as_pillow.width, 6)
}

test {
  let image = @moonimage.Image::new(3, 3, @moonimage.PixelFormat::Rgba8)
  assert_eq(image.brightness(1.5).contrast(1.2).hue_rotate(90.0).invert().width, 3)
}

test {
  let under = @moonimage.Image::new(4, 4, @moonimage.PixelFormat::Rgba8)
  let over = @moonimage.Image::new(2, 2, @moonimage.PixelFormat::Rgba8)
  let drawn = under.composite(over, x=1, y=1, opacity=0.5)
  assert_eq(drawn.width, 4)
}

#Animation

test {
  let image = @moonimage.Image::new(4, 4, @moonimage.PixelFormat::Rgba8)
  let file = @moonimage.encode(image, @moonimage.Format::Gif)
  let animation = @moonimage.decode_animation(file)
  assert_eq(animation.frames.length(), 1)
  assert_eq(animation.compose().length(), 1)
}

#Metadata

pub(all) struct Metadata {
  gamma : Double?
  chromaticities : Chromaticities?
  intent : Intent?
  icc : Icc?
  texts : Array<Text>
}

test {
  let image = @moonimage.Image::new(3, 2, @moonimage.PixelFormat::Rgb8)
  // Six is a quarter turn clockwise, which swaps the canvas.
  assert_eq(image.orient(6).width, 2)
  assert_eq(image.upright(None).width, 3)
}

#Limits

test {
  assert_eq(@moonimage.Limits::default().width, 1_048_576)
  assert_eq(@moonimage.Limits::strict().pixels, 67_108_864)
}

#Consistency

#Mutation

python scripts/mutation/run.py

#What it does not do

• Writing an AVIF. Reading one is an AV1 decoder; writing one is that and an encoder on top: a mode search, a rate model and a quantiser. The reader is narrow in ways it says out loud rather than approximating — eight bits a sample, 4:2:0, one tile, no segmentation, no film grain, no super resolution and no intra block copy, each refused by name.
• Writing a partitioned block of a DDS. BC1 to BC7 are all written; the encoder fits one region per block, and a search over the sixty-four shapes of the partitioned modes would win a few tenths of a decibel on a photograph.
• SGI files whose rows are run-length coded. The header says which of the two storages a file uses, and this library reads the plain one, which is what every current writer produces. The run-length rows are refused by name rather than decoded on trust: no reference here both writes and reads them, so a transcription could not be held to anything.
• Writing a lossless AVIF, a lossy animation, or a mipmap chain. The first needs the same AV1 encoder the last section refuses; the other two are containers this library writes one shape of.
• Photoshop, JPEG 2000 and JPEG XL. Each is a codec of its own rather than a container this library already speaks: PSD wants its layer records and its two-bytes-a-plane run lengths, JPEG 2000 wants wavelets with an embedded block coder, and JPEG XL wants a whole new entropy layer. They are named here rather than listed as supported because a reader that returns the flattened composite of a PSD and nothing else would look complete and be wrong.
• Vector formats. SVG, PDF, EPS and the Windows metafiles are drawings, not pictures: a path has to be flattened and filled before there is a pixel to hand to anything in this library, and text needs a shaper on top of that. The rasterising is a different product, and a half of it would be worse than none.
• XBM and XPM. Both are text, both are trivial to read, and neither is worth a package: an XBM is a C array of bits and an XPM is a C array of strings, and a caller with one of those already has the bytes.

#Interface

#Licence