works pretty good rn ~80% confidence

Author: tjaycodes4you

.gitignore

@@ -0,0 +1 @@
+.idea

bg-1.png

@@ -0,0 +1,5 @@
+module geeTestSolver
+
+go 1.25
+
+require github.com/anthonynsimon/bild v0.14.0

cropped_slice.png

@@ -0,0 +1,2 @@
+github.com/anthonynsimon/bild v0.14.0 h1:IFRkmKdNdqmexXHfEU7rPlAmdUZ8BDZEGtGHDnGWync=
+github.com/anthonynsimon/bild v0.14.0/go.mod h1:hcvEAyBjTW69qkKJTfpcDQ83sSZHxwOunsseDfeQhUs=

edge_bg.png

@@ -0,0 +1,257 @@
+package main
+
+import (
+	"fmt"
+	"image"
+	"image/color"
+	"image/draw"
+	"image/png"
+	"log"
+	"math"
+	"os"
+
+	"github.com/anthonynsimon/bild/blur"
+)
+
+func loadImage(path string) (image.Image, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	img, _, err := image.Decode(file)
+	if err != nil {
+		return nil, err
+	}
+	return img, nil
+}
+
+func saveImage(path string, img image.Image) {
+	f, err := os.Create(path)
+	if err != nil {
+		log.Printf("Failed to create %s: %v", path, err)
+		return
+	}
+	defer f.Close()
+	if err := png.Encode(f, img); err != nil {
+		log.Printf("Failed to encode %s: %v", path, err)
+	}
+	fmt.Printf("Saved %s\n", path)
+}
+
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
+
+// CropToContent removes borders based on the top-left pixel color
+func CropToContent(img *image.RGBA) *image.RGBA {
+	bounds := img.Bounds()
+	minX, minY := bounds.Max.X, bounds.Max.Y
+	maxX, maxY := bounds.Min.X, bounds.Min.Y
+	found := false
+
+	bgC := img.At(bounds.Min.X, bounds.Min.Y)
+	br, bg_g, bb, ba := bgC.RGBA()
+
+	isBackground := func(x, y int) bool {
+		c := img.At(x, y)
+		r, g, b, a := c.RGBA()
+		diff := abs(int(r)-int(br)) + abs(int(g)-int(bg_g)) + abs(int(b)-int(bb)) + abs(int(a)-int(ba))
+		return diff < 3000
+	}
+
+	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
+		for x := bounds.Min.X; x < bounds.Max.X; x++ {
+			if !isBackground(x, y) {
+				if x < minX {
+					minX = x
+				}
+				if x > maxX {
+					maxX = x
+				}
+				if y < minY {
+					minY = y
+				}
+				if y > maxY {
+					maxY = y
+				}
+				found = true
+			}
+		}
+	}
+
+	if !found {
+		return img
+	}
+
+	rect := image.Rect(minX, minY, maxX+1, maxY+1)
+	newImg := image.NewRGBA(image.Rect(0, 0, rect.Dx(), rect.Dy()))
+	draw.Draw(newImg, newImg.Bounds(), img, rect.Min, draw.Src)
+	return newImg
+}
+
+// SobelEdgeDetection calculates gradient magnitude
+func SobelEdgeDetection(img image.Image) *image.Gray {
+	bounds := img.Bounds()
+	gray := image.NewGray(bounds)
+	draw.Draw(gray, bounds, img, bounds.Min, draw.Src)
+
+	output := image.NewGray(bounds)
+
+	for y := bounds.Min.Y + 1; y < bounds.Max.Y-1; y++ {
+		for x := bounds.Min.X + 1; x < bounds.Max.X-1; x++ {
+			gx := int(gray.GrayAt(x+1, y).Y) - int(gray.GrayAt(x-1, y).Y)
+			gy := int(gray.GrayAt(x, y+1).Y) - int(gray.GrayAt(x, y-1).Y)
+
+			mag := math.Sqrt(float64(gx*gx + gy*gy))
+			if mag > 255 {
+				mag = 255
+			}
+			output.SetGray(x, y, color.Gray{Y: uint8(mag)})
+		}
+	}
+	return output
+}
+
+func calculateMaskedNCC(background, puzzlePiece *image.Gray, mask *image.Alpha, offsetX, offsetY int) float64 {
+	var sum1, sum2, sum1Sq, sum2Sq, sum12 float64
+	n := 0
+
+	bounds := puzzlePiece.Bounds()
+	for py := 0; py < bounds.Dy(); py++ {
+		for px := 0; px < bounds.Dx(); px++ {
+			// Check mask (if pixel is transparent/background, skip it)
+			if mask.AlphaAt(bounds.Min.X+px, bounds.Min.Y+py).A == 0 {
+				continue
+			}
+
+			v1 := float64(puzzlePiece.GrayAt(bounds.Min.X+px, bounds.Min.Y+py).Y)
+			v2 := float64(background.GrayAt(offsetX+px, offsetY+py).Y)
+
+			sum1 += v1
+			sum2 += v2
+			sum1Sq += v1 * v1
+			sum2Sq += v2 * v2
+			sum12 += v1 * v2
+			n++
+		}
+	}
+
+	if n == 0 {
+		return 0
+	}
+
+	denom := math.Sqrt((sum1Sq - (sum1 * sum1 / float64(n))) * (sum2Sq - (sum2 * sum2 / float64(n))))
+	if denom == 0 {
+		return 0
+	}
+	return (sum12 - (sum1 * sum2 / float64(n))) / denom
+}
+
+func FindBestMatchMasked(background, puzzlePiece *image.Gray, mask *image.Alpha) (image.Point, float64) {
+	bestScore := -1.0
+	var bestPosition image.Point
+
+	// Optimization: Skip edges where the piece doesn't fit
+	for y := 0; y <= background.Bounds().Dy()-puzzlePiece.Bounds().Dy(); y++ {
+		for x := 0; x <= background.Bounds().Dx()-puzzlePiece.Bounds().Dx(); x++ {
+			score := calculateMaskedNCC(background, puzzlePiece, mask, x, y)
+			if score > bestScore {
+				bestScore = score
+				bestPosition = image.Point{X: x, Y: y}
+				// fmt.Printf("Best score: %v x %v y %v\n", bestScore, x, y)
+			}
+		}
+	}
+	return bestPosition, bestScore
+}
+
+func ExtractMask(img *image.RGBA) *image.Alpha {
+	bounds := img.Bounds()
+	mask := image.NewAlpha(bounds)
+
+	br, bg, bb, ba := img.At(bounds.Min.X, bounds.Min.Y).RGBA()
+
+	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
+		for x := bounds.Min.X; x < bounds.Max.X; x++ {
+			r, g, b, a := img.At(x, y).RGBA()
+			diff := abs(int(r)-int(br)) + abs(int(g)-int(bg)) + abs(int(b)-int(bb)) + abs(int(a)-int(ba))
+			if diff < 3000 {
+				mask.SetAlpha(x, y, color.Alpha{A: 0}) // Mask out
+			} else {
+				mask.SetAlpha(x, y, color.Alpha{A: 255}) // Keep
+			}
+		}
+	}
+	return mask
+}
+
+func main() {
+	bgPath := "bg-1.png"
+	slicePath := "slice-1.png"
+
+	bgImg, err := loadImage(bgPath)
+	if err != nil {
+		log.Fatalf("Failed to load background image: %v", err)
+	}
+
+	sliceImg, err := loadImage(slicePath)
+	if err != nil {
+		log.Fatalf("Failed to load slice image: %v", err)
+	}
+
+	bgRGBA, err := ConvertImageToRGBA(bgImg)
+	if err != nil {
+		log.Fatalf("Failed to convert background to RGBA: %v", err)
+	}
+
+	sliceRGBA, err := ConvertImageToRGBA(sliceImg)
+	if err != nil {
+		log.Fatalf("Failed to convert slice to RGBA: %v", err)
+	}
+
+	// Crop the slice
+	sliceRGBA = CropToContent(sliceRGBA)
+	saveImage("cropped_slice.png", sliceRGBA)
+
+	// Extract Mask (for NCC)
+	mask := ExtractMask(sliceRGBA)
+
+	// Apply Gaussian Blur (to reduce noise)
+	// Radius 2.0, Sigma 1.0
+	bgBlurred := blur.Gaussian(bgRGBA, 2.0)
+	sliceBlurred := blur.Gaussian(sliceRGBA, 2.0)
+
+	// Apply Sobel Edge Detection
+	bgGray := SobelEdgeDetection(bgBlurred)
+	sliceGray := SobelEdgeDetection(sliceBlurred)
+
+	saveImage("edge_bg.png", bgGray)
+	saveImage("edge_slice.png", sliceGray)
+
+	// Find best match with Mask
+	pos, score := FindBestMatchMasked(bgGray, sliceGray, mask)
+
+	fmt.Printf("Best match found at: %v with score: %f\n", pos, score)
+
+	// Draw result
+	rectColor := color.RGBA{255, 0, 0, 255}
+	pieceBounds := sliceRGBA.Bounds()
+	width := pieceBounds.Dx()
+	height := pieceBounds.Dy()
+
+	for x := 0; x < width; x++ {
+		bgRGBA.Set(pos.X+x, pos.Y, rectColor)
+		bgRGBA.Set(pos.X+x, pos.Y+height-1, rectColor)
+	}
+	for y := 0; y < height; y++ {
+		bgRGBA.Set(pos.X, pos.Y+y, rectColor)
+		bgRGBA.Set(pos.X+width-1, pos.Y+y, rectColor)
+	}
+
+	saveImage("result.png", bgRGBA)
+}