Optimize fitness evaluation with delta-based computation and improved hash

Two algorithm-level optimizations:

1. Delta-based fitness evaluation: When evaluating mutated population
   members, instead of iterating all N triangles and checking a hash
   cache, track which triangles are added/removed during Delaunay
   Insert/Remove and compute fitness incrementally from the base's
   known totals. This reduces per-evaluation work from O(N) to O(k)
   where k is the number of affected triangles (~6-12 per mutation
   vs ~400 total for a typical 200-point configuration).

2. Improved triangle cache hash function: Replace the weak commutative
   hash (sum of coordinates) with a polynomial hash using distinct
   prime multipliers per coordinate, reducing cache collisions and
   unnecessary rasterization on the full-evaluation path.

Changes:
- Add change tracking (BeginTrack/EndTrack) to Delaunay triangulation
- Add triangleKey type with normalized vertex ordering for variance map
- Implement dual-path Calculate(): delta path for mutations, full path
  for initial/base evaluations
- Propagate base fitness data (difference, area, variance map) via SetBase
- Use counter-based net-change computation to handle intermediate
  triangles created during Remove/Insert sequences

https://claude.ai/code/session_01EQzoAqbMNJ22TpcMNRU31d

Author: claude

fitness/cache.go

@@ -1,5 +1,33 @@
 package fitness
 
+// triangleKey is a normalized representation of a triangle's vertices, used as a map key
+// for delta-based fitness evaluation. Vertices are sorted lexicographically (by X then Y)
+// so the same geometric triangle always maps to the same key.
+type triangleKey struct {
+	aX, aY, bX, bY, cX, cY int16
+}
+
+// makeTriangleKey creates a triangleKey with vertices sorted lexicographically.
+func makeTriangleKey(ax, ay, bx, by, cx, cy int16) triangleKey {
+	// Sort three vertices by X, then Y
+	if ax > bx || (ax == bx && ay > by) {
+		ax, ay, bx, by = bx, by, ax, ay
+	}
+	if bx > cx || (bx == cx && by > cy) {
+		bx, by, cx, cy = cx, cy, bx, by
+	}
+	if ax > bx || (ax == bx && ay > by) {
+		ax, ay, bx, by = bx, by, ax, ay
+	}
+	return triangleKey{aX: ax, aY: ay, bX: bx, bY: by, cX: cx, cY: cy}
+}
+
+// triangleVarData stores per-triangle variance and area for delta-based fitness.
+type triangleVarData struct {
+	variance float64
+	area     float64
+}
+
 // A CacheFunction represents a fitness function that caches data for efficiency.
 type CacheFunction interface {
 	Function
@@ -39,11 +67,17 @@ func (t TriangleCacheData) Equals(other CacheData) bool {
 }
 
 // Hash calculates the hash code of a TriangleCacheData.
+// Uses a polynomial hash with distinct prime multipliers per coordinate
+// to reduce collisions compared to the previous commutative sum-based hash.
 func (t TriangleCacheData) Hash() uint64 {
-	x := int(t.aX) + int(t.bX) + int(t.cX)
-	y := int(t.aY) + int(t.bY) + int(t.cY)
-
-	return uint64((97+x)*97 + y)
+	h := uint64(17)
+	h = h*31 + uint64(uint16(t.aX))
+	h = h*37 + uint64(uint16(t.aY))
+	h = h*41 + uint64(uint16(t.bX))
+	h = h*43 + uint64(uint16(t.bY))
+	h = h*47 + uint64(uint16(t.cX))
+	h = h*53 + uint64(uint16(t.cY))
+	return h
 }
 
 func (t TriangleCacheData) CachedHash() uint32 {

fitness/delta_test.go

@@ -0,0 +1,175 @@
+package fitness
+
+import (
+	image2 "github.com/RH12503/Triangula/image"
+	"github.com/RH12503/Triangula/mutation"
+	"github.com/RH12503/Triangula/normgeom"
+	"github.com/RH12503/Triangula/random"
+	"image"
+	"image/color"
+	"math"
+	"testing"
+)
+
+// TestDeltaFitnessMatchesFull verifies that delta-based fitness evaluation produces
+// the same result as a full evaluation for the same set of points.
+func TestDeltaFitnessMatchesFull(t *testing.T) {
+	random.Seed(42)
+
+	const w, h = 80, 80
+	const bs = 3
+
+	// Create a random target image
+	img := image.NewRGBA(image.Rect(0, 0, w, h))
+	for x := 0; x < w; x++ {
+		for y := 0; y < h; y++ {
+			img.Set(x, y, color.RGBA{
+				R: uint8(random.Intn(math.MaxUint8)),
+				G: uint8(random.Intn(math.MaxUint8)),
+				B: uint8(random.Intn(math.MaxUint8)),
+				A: math.MaxUint8,
+			})
+		}
+	}
+
+	target := image2.ToData(img)
+
+	// Create base points
+	basePoints := normgeom.NormPointGroup{
+		{0.1, 0.1},
+		{0.9, 0.1},
+		{0.5, 0.5},
+		{0.1, 0.9},
+		{0.9, 0.9},
+		{0.3, 0.3},
+		{0.7, 0.7},
+		{0.2, 0.6},
+		{0.8, 0.4},
+		{0.5, 0.2},
+	}
+
+	// Compute full fitness of the base points
+	baseEval := NewTrianglesImageFunction(target, bs)
+	baseFitness := baseEval.Calculate(PointsData{
+		Points:    basePoints,
+		Mutations: nil,
+	})
+	t.Logf("Base fitness: %v", baseFitness)
+
+	// Create mutated points: move point 2 and point 5
+	mutatedPoints := basePoints.Copy()
+	oldP2 := mutatedPoints[2]
+	mutatedPoints[2] = normgeom.NormPoint{X: 0.55, Y: 0.45}
+	newP2 := mutatedPoints[2]
+
+	oldP5 := mutatedPoints[5]
+	mutatedPoints[5] = normgeom.NormPoint{X: 0.35, Y: 0.25}
+	newP5 := mutatedPoints[5]
+
+	mutations := []mutation.Mutation{
+		{Index: 2, Old: oldP2, New: newP2},
+		{Index: 5, Old: oldP5, New: newP5},
+	}
+
+	// Method 1: Full evaluation of mutated points from scratch
+	fullEval := NewTrianglesImageFunction(target, bs)
+	fullFitness := fullEval.Calculate(PointsData{
+		Points:    mutatedPoints.Copy(),
+		Mutations: nil,
+	})
+
+	// Method 2: Delta evaluation from base
+	deltaEval := NewTrianglesImageFunction(target, bs)
+	// First, compute the base to populate triangleVariances
+	deltaEval.Calculate(PointsData{
+		Points:    basePoints.Copy(),
+		Mutations: nil,
+	})
+	// Now set this as the base and compute via delta path
+	deltaEval2 := NewTrianglesImageFunction(target, bs)
+	deltaEval2.SetBase(deltaEval)
+	deltaFitness := deltaEval2.Calculate(PointsData{
+		Points:    mutatedPoints.Copy(),
+		Mutations: mutations,
+	})
+
+	t.Logf("Full fitness:  %v", fullFitness)
+	t.Logf("Delta fitness: %v", deltaFitness)
+
+	// They should match within floating-point tolerance
+	epsilon := 1e-10
+	diff := math.Abs(fullFitness - deltaFitness)
+	if diff > epsilon {
+		t.Errorf("Delta fitness (%v) does not match full fitness (%v), diff=%v", deltaFitness, fullFitness, diff)
+	}
+}
+
+// TestDeltaFitnessSingleMutation tests with a single point mutation.
+func TestDeltaFitnessSingleMutation(t *testing.T) {
+	random.Seed(99)
+
+	const w, h = 60, 60
+	const bs = 3
+
+	img := image.NewRGBA(image.Rect(0, 0, w, h))
+	for x := 0; x < w; x++ {
+		for y := 0; y < h; y++ {
+			img.Set(x, y, color.RGBA{
+				R: uint8(random.Intn(math.MaxUint8)),
+				G: uint8(random.Intn(math.MaxUint8)),
+				B: uint8(random.Intn(math.MaxUint8)),
+				A: math.MaxUint8,
+			})
+		}
+	}
+
+	target := image2.ToData(img)
+
+	basePoints := normgeom.NormPointGroup{
+		{0.15, 0.15},
+		{0.85, 0.15},
+		{0.5, 0.5},
+		{0.15, 0.85},
+		{0.85, 0.85},
+	}
+
+	// Compute base
+	baseEval := NewTrianglesImageFunction(target, bs)
+	baseEval.Calculate(PointsData{
+		Points:    basePoints.Copy(),
+		Mutations: nil,
+	})
+
+	// Single mutation on point 2
+	mutatedPoints := basePoints.Copy()
+	oldP := mutatedPoints[2]
+	mutatedPoints[2] = normgeom.NormPoint{X: 0.52, Y: 0.48}
+	newP := mutatedPoints[2]
+
+	mutations := []mutation.Mutation{
+		{Index: 2, Old: oldP, New: newP},
+	}
+
+	// Full evaluation
+	fullEval := NewTrianglesImageFunction(target, bs)
+	fullFitness := fullEval.Calculate(PointsData{
+		Points:    mutatedPoints.Copy(),
+		Mutations: nil,
+	})
+
+	// Delta evaluation
+	deltaEval := NewTrianglesImageFunction(target, bs)
+	deltaEval.SetBase(baseEval)
+	deltaFitness := deltaEval.Calculate(PointsData{
+		Points:    mutatedPoints.Copy(),
+		Mutations: mutations,
+	})
+
+	t.Logf("Full: %v, Delta: %v", fullFitness, deltaFitness)
+
+	epsilon := 1e-10
+	diff := math.Abs(fullFitness - deltaFitness)
+	if diff > epsilon {
+		t.Errorf("Delta fitness (%v) does not match full fitness (%v), diff=%v", deltaFitness, fullFitness, diff)
+	}
+}