grokify/mogo

package imageutil

import (
    "image"
    "image/color"
    "image/draw"

    "github.com/grokify/mogo/image/colors"
)

func MergeXSameY(images []image.Image, larger bool) image.Image {
    if len(images) == 0 {
        return nil
    } else if len(images) == 1 {
        return images[0]
    }
    images = ResizeSameY(images, larger)
    // _, _, minY, _, sumX, _ := SliceXY(images, -1)
    imgs := Images(images)
    minY := imgs.DyMin()
    sumX := imgs.DxSum(-1)
    output := image.NewRGBA(image.Rect(0, 0, sumX, minY))
    sumXPrev := 0
    for _, img := range images {
        if IsNilOrEmpty(img) {
            continue
        }
        draw.Draw(output, img.Bounds().Add(image.Pt(sumXPrev, 0)),
            img, image.Point{}, draw.Src)
        sumXPrev += img.Bounds().Dx()
    }
    return output
}

func MergeXSameYRead(locations []string, larger bool) (image.Image, error) {
    images, err := ReadImages(locations)
    if err != nil {
        return nil, err
    }
    return MergeXSameY(images, true), nil
}

func MergeYSameX(images []image.Image, larger bool) image.Image {
    if len(images) == 0 {
        return nil
    } else if len(images) == 1 {
        return images[0]
    }
    images = ResizeSameX(images, larger)
    // minX, _, _, _, _, sumY := SliceXY(images, -1)
    imgs := Images(images)
    minX := imgs.DxMin()
    sumY := imgs.DySum(-1)
    output := image.NewRGBA(image.Rect(0, 0, minX, sumY))
    sumYPrev := 0
    for _, img := range images {
        if IsNilOrEmpty(img) {
            continue
        }
        draw.Draw(output, img.Bounds().Add(image.Pt(0, sumYPrev)),
            img, image.Point{}, draw.Src)
        sumYPrev += img.Bounds().Dy()
    }
    return output
}

func MergeYSameXRead(locations []string, larger bool) (image.Image, error) {
    images, err := ReadImages(locations)
    if err != nil {
        return nil, err
    }
    return MergeYSameX(images, true), nil
}

type Matrix [][]image.Image

// AddBackgroundColor adds a background of `color.Color` to the images.
// It is is useful when the image has a transparent background. Use
// `colornames` for more colors, e.g. `colornames.Blue`.
func (matrix Matrix) AddBackgroundColor(clr color.Color) {
    for i, row := range matrix {
        for j, img := range row {
            matrix[i][j] = AddBackgroundColor(img, clr)
        }
    }
}

func (matrix Matrix) AddBackgroundColorHex(hexcolor string) error {
    clr, err := colors.ParseHex(hexcolor)
    if err != nil {
        return err
    }
    matrix.AddBackgroundColor(clr)
    return nil
}

// Merge combines a set of images resizing each row element's height
// for consistent rows, an each row's width for consistent widths.
func (matrix Matrix) Merge(largerX, largerY bool) image.Image {
    if len(matrix) == 0 {
        return nil
    }
    rowImages := []image.Image{}
    for _, rowParts := range matrix {
        if len(rowParts) > 0 {
            rowImages = append(rowImages, MergeXSameY(rowParts, largerY))
        }
    }
    if len(rowImages) == 0 {
        return nil
    }
    return MergeYSameX(rowImages, largerX)
}

func (matrix Matrix) DxSumMax() int {
    dxMax := 0
    for _, row := range matrix {
        rowDxSum := Images(row).DxSum(-1)
        if rowDxSum > dxMax {
            dxMax = rowDxSum
        }
    }
    return dxMax
}

func (matrix Matrix) DxSumMin() int {
    dxMin := 0
    for i, row := range matrix {
        if i == 0 {
            dxMin = Images(row).DxSum(-1)
        }
        rowDxSum := Images(row).DxSum(-1)
        if rowDxSum < dxMin {
            dxMin = rowDxSum
        }
    }
    return dxMin
}

func (matrix Matrix) Dimensions() [][]image.Point {
    points := [][]image.Point{}
    for r, row := range matrix {
        points = append(points, []image.Point{})
        for _, img := range row {
            points[r] = append(points[r], img.Bounds().Canon().Max)
        }
    }
    return points
}

func MatrixRead(imglocations [][]string) (Matrix, error) {
    matrixImages := Matrix{}
    for _, row := range imglocations {
        if len(row) == 0 {
            continue
        }
        images, err := ReadImages(row)
        if err != nil {
            return nil, err
        }
        matrixImages = append(matrixImages, images)
    }
    return matrixImages, nil
}

// MergeXRGBA returns an image that is composed
// of non-overlapping imagers in ImageMetaSet. The code here
// is adapted from https://stackoverflow.com/a/35965499/1908967
func MergeXRGBA(imgs []image.Image) image.Image {
    imgs2 := Images(imgs)
    mergedRGBA := image.NewRGBA(image.Rectangle{
        image.Point{0, 0},
        image.Point{imgs2.DxSum(-1), imgs2.DyMax()}})

    for i, img := range imgs2 {
        if i == 0 {
            draw.Draw(mergedRGBA, img.Bounds(), img, image.Point{0, 0}, draw.Src)
        } else {
            startingPostionI := image.Point{imgs2.DxSum(i - 1), 0}
            rectangleI := image.Rectangle{
                startingPostionI,
                startingPostionI.Add(img.Bounds().Size())}
            draw.Draw(mergedRGBA, rectangleI, img, image.Point{0, 0}, draw.Src)
        }
    }
    return mergedRGBA
}