simplification.go

package tile

import (
	"math"
)

type SimplificationStrategy string

const (
	SimplifyNone         SimplificationStrategy = "none"
	SimplifyConservative SimplificationStrategy = "conservative"
	SimplifyModerate     SimplificationStrategy = "moderate"
	SimplifyAggressive   SimplificationStrategy = "aggressive"
	SimplifyCustom       SimplificationStrategy = "custom"
)

type SimplificationConfig struct {
	Enabled        bool
	Strategy       SimplificationStrategy
	MaxZoom        uint
	MinZoom        uint
	ZoomLevels     map[uint]float64
	PixelTolerance float64
	GeometryType   string
	KeepTopology   bool
	MinPoints      int
}

var DefaultSimplificationConfig = SimplificationConfig{
	Enabled:        true,
	Strategy:       SimplifyModerate,
	MaxZoom:        14,
	MinZoom:        0,
	PixelTolerance: 2.0,
	KeepTopology:   true,
	MinPoints:      4,
}

func GetSimplificationTolerance(zoom uint, strategy SimplificationStrategy, pixelTolerance float64) float64 {
	if zoom >= 14 {
		return 0
	}

	switch strategy {
	case SimplifyNone:
		return 0

	case SimplifyConservative:
		return pixelTolerance * 0.5

	case SimplifyModerate:
		if zoom <= 5 {
			return pixelTolerance * 2.0
		} else if zoom <= 10 {
			return pixelTolerance * 1.0
		} else {
			return pixelTolerance * 0.5
		}

	case SimplifyAggressive:
		if zoom <= 5 {
			return pixelTolerance * 4.0
		} else if zoom <= 10 {
			return pixelTolerance * 2.0
		} else {
			return pixelTolerance * 1.0
		}

	default:
		return pixelTolerance
	}
}

func CalculateZoomBasedTolerance(zoom uint, extent float64, baseTolerance float64) float64 {
	if zoom >= 14 {
		return 0
	}

	pixelSize := 40075016.6855785 / (math.Exp2(float64(zoom)) * extent)

	tolerance := baseTolerance * pixelSize

	if zoom <= 5 {
		tolerance *= (1.0 + float64(5-zoom)*0.3)
	}

	return tolerance
}

func ShouldSimplify(zoom, maxZoom uint, enabled bool) bool {
	return enabled && zoom < maxZoom
}

func GetGeometrySpecificTolerance(geomType string, baseTolerance float64) float64 {
	switch geomType {
	case "Point", "MultiPoint":
		return 0
	case "LineString", "MultiLineString":
		return baseTolerance * 0.8
	case "Polygon", "MultiPolygon":
		return baseTolerance
	default:
		return baseTolerance
	}
}

func CalculateOptimalTolerance(zoom uint, config SimplificationConfig, geomType string) float64 {
	if !config.Enabled {
		return 0
	}

	if zoom < config.MinZoom || zoom >= config.MaxZoom {
		if zoom >= config.MaxZoom {
			return 0
		}
	}

	if len(config.ZoomLevels) > 0 {
		if tolerance, ok := config.ZoomLevels[zoom]; ok {
			return GetGeometrySpecificTolerance(geomType, tolerance)
		}
	}

	baseTolerance := GetSimplificationTolerance(zoom, config.Strategy, config.PixelTolerance)

	return GetGeometrySpecificTolerance(geomType, baseTolerance)
}