Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-image

Source of release 0.45.1

0.45.1 / src / image / edit.lucb

#==============================================================================================
#
#   image/edit - New images from an image
#
#   DESCRIPTION:
#       Pillow's copy, crop, getchannel, convert and resize: each a new owning image; the
#       source is loaded first and left as it was.
#
#==============================================================================================

extend Image:
    ## A new image with the same channels, pixels and attributes.
    pub func copy() -> interop.Reference[Image]!:
        return try self.crop(0, 0, try self.width(), try self.height())

    ## The pixels from (`left`, `top`) up to but not including (`right`, `bottom`).
    pub func crop(left: usize, top: usize, right: usize, bottom: usize) -> interop.Reference[Image]!:
        try self.load()
        if left >= right or top >= bottom or right > self.raster.width or bottom > self.raster.height:
            error(invalid, "crop rectangle is empty or outside the image")
        var raster = model.Raster(width = right - left, height = bottom - top, xmin = self.raster.xmin + (i64)left, ymin = self.raster.ymin + (i64)top, max_bytes = self.raster.max_bytes)
        errdefer raster.close()
        for channel in self.raster.channels:
            try raster.channel(channel.name, channel.kind)
        for attr in self.raster.attributes:
            try raster.attribute(attr.name, attr.type_name, attr.data)
        try raster.allocate()
        let nc = raster.channels.length
        for y in 0..<raster.height:
            for x in 0..<raster.width:
                for c in 0..<nc:
                    raster.pixels[(y * raster.width + x) * nc + c] = self.raster.pixels[((top + y) * self.raster.width + left + x) * nc + c]
        return try Image.own(raster, self.threads)

    ## Channel `name` alone, as a one-channel "Y" image.
    pub func get_channel(name: str) -> interop.Reference[Image]!:
        try self.load()
        let channel = try self.raster.find_channel(name)
        var raster = model.Raster(width = self.raster.width, height = self.raster.height, xmin = self.raster.xmin, ymin = self.raster.ymin, max_bytes = self.raster.max_bytes)
        errdefer raster.close()
        try raster.channel("Y", self.raster.channels[channel].kind)
        try raster.allocate()
        for i in 0..<raster.pixels.length:
            raster.pixels[i] = self.raster.pixels[i * self.raster.channels.length + channel]
        return try Image.own(raster, self.threads)

    ## The image in another Pillow mode; grey comes from Rec. 601 luma.
    pub func convert(mode: str) -> interop.Reference[Image]!:
        try self.load()
        let out = try Image.create(mode, self.raster.width, self.raster.height, max_bytes = self.raster.max_bytes)
        errdefer out.release()
        let target = out.value()
        let source_max = model.maximum(self.raster.channels[0].kind)
        let target_max = model.maximum(target.raster.channels[0].kind)
        let integer = (i64)target.raster.channels[0].kind <= 3
        # Which source sample feeds each color, worked out once as `getpixel` reads them.
        var red: i64 = -1
        var green: i64 = -1
        var blue: i64 = -1
        var alpha: i64 = -1
        for c in 0..<self.raster.channels.length:
            let name = self.raster.channels[c].name
            if name == "Y":
                red = (i64)c
                green = (i64)c
                blue = (i64)c
            elif name == "R":
                red = (i64)c
            elif name == "G":
                green = (i64)c
            elif name == "B":
                blue = (i64)c
            elif name == "A":
                alpha = (i64)c
        # And what each target channel is: 0 red, 1 green, 2 blue, 3 alpha, 4 luma.
        var wanted: u8[16]
        let channels = target.raster.channels.length
        for c in 0..<channels:
            let name = target.raster.channels[c].name
            wanted[c] = 3 if name == "A" else 1 if name == "G" else 2 if name == "B" else 4 if name == "Y" else 0
        let source_stride = self.raster.channels.length
        let scale = target_max / source_max
        for index in 0..<self.raster.width * self.raster.height:
            let at = index * source_stride
            let r = self.raster.pixels[at + (usize)red] if red >= 0 else 0.0
            let g = self.raster.pixels[at + (usize)green] if green >= 0 else 0.0
            let b = self.raster.pixels[at + (usize)blue] if blue >= 0 else 0.0
            let a = self.raster.pixels[at + (usize)alpha] if alpha >= 0 else source_max
            for c in 0..<channels:
                let kind = wanted[c]
                let source = r if kind == 0 else g if kind == 1 else b if kind == 2 else a if kind == 3 else 0.299 * r + 0.587 * g + 0.114 * b
                let value = source * scale
                target.raster.pixels[index * channels + c] = math.floor(math.clamp(value, 0.0, target_max) + 0.5) if integer else value
        return out

    ## Nearest is appropriate for discrete IDs. Bilinear must never filter IDs.
    pub func resize(width: usize, height: usize, resample: str = "nearest") -> interop.Reference[Image]!:
        try self.load()
        if resample != "nearest" and resample != "bilinear":
            error(invalid, "resample must be nearest or bilinear")
        var raster = model.Raster(width = width, height = height, max_bytes = self.raster.max_bytes)
        errdefer raster.close()
        for channel in self.raster.channels:
            try raster.channel(channel.name, channel.kind)
        try raster.allocate()
        let nc = raster.channels.length
        for y in 0..<height:
            for x in 0..<width:
                let sx = math.clamp(((f64)x + 0.5) * (f64)self.raster.width / (f64)width - 0.5, 0.0, (f64)(self.raster.width - 1))
                let sy = math.clamp(((f64)y + 0.5) * (f64)self.raster.height / (f64)height - 0.5, 0.0, (f64)(self.raster.height - 1))
                for c in 0..<nc:
                    var value: f64 = 0.0
                    if resample == "nearest":
                        value = self.raster.pixels[((usize)math.floor(sy + 0.5) * self.raster.width + (usize)math.floor(sx + 0.5)) * nc + c]
                    else:
                        let x0 = (usize)math.floor(sx)
                        let y0 = (usize)math.floor(sy)
                        let x1 = x0 + 1 if x0 + 1 < self.raster.width else x0
                        let y1 = y0 + 1 if y0 + 1 < self.raster.height else y0
                        let fx = sx - (f64)x0
                        let fy = sy - (f64)y0
                        let top = self.raster.pixels[(y0 * self.raster.width + x0) * nc + c] * (1.0 - fx) + self.raster.pixels[(y0 * self.raster.width + x1) * nc + c] * fx
                        let bottom = self.raster.pixels[(y1 * self.raster.width + x0) * nc + c] * (1.0 - fx) + self.raster.pixels[(y1 * self.raster.width + x1) * nc + c] * fx
                        value = top * (1.0 - fy) + bottom * fy
                        if (i64)raster.channels[c].kind <= 3:
                            value = math.floor(value + 0.5)
                    raster.pixels[(y * width + x) * nc + c] = value
        return try Image.own(raster, self.threads)