a665253d4d
- Region checkboxes now control which overlays are drawn (?regions= param) - Upload auto-switches capture source (no restart needed) - State detection: check in-game BEFORE loading, require 90% dark for loading - Tighten HSV ranges: health H 0-30 S 50+ V 30+, mana H 200-240 S 40+ V 20+ - Add /api/analyze endpoint with per-region color analysis
730 lines
20 KiB
Go
730 lines
20 KiB
Go
// Package api provides the REST + WebSocket API for the bot dashboard.
|
|
//
|
|
// Endpoints:
|
|
// GET /api/status — bot status, current state, routine, stats
|
|
// GET /api/capture/frame — returns current frame as JPEG
|
|
// GET /api/capture/frame/annotated — frame with region overlays
|
|
// GET /api/capture/stats — capture performance stats
|
|
// POST /api/capture/upload — upload a screenshot for testing
|
|
// POST /api/capture/source — switch capture source
|
|
// GET /api/regions — list all defined regions
|
|
// GET /api/state — current detected game state + vitals
|
|
// GET /api/loot/rules — get current loot filter rules
|
|
// GET /api/routines — list available routines
|
|
// GET /api/pixel — get pixel color at coordinates
|
|
// GET /api/config — current config
|
|
// GET /api/plugins — list loaded plugins and info
|
|
// WS /api/ws — WebSocket for real-time updates
|
|
// GET / — serve dev dashboard
|
|
//
|
|
// The API is served by the bot process itself (single binary).
|
|
package api
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"image"
|
|
"image/color"
|
|
"image/draw"
|
|
"image/jpeg"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
|
|
"git.cloonar.com/openclawd/iso-bot/pkg/engine"
|
|
"git.cloonar.com/openclawd/iso-bot/pkg/engine/capture/backends"
|
|
"git.cloonar.com/openclawd/iso-bot/pkg/engine/vision"
|
|
)
|
|
|
|
// Status represents the current bot status.
|
|
type Status struct {
|
|
Running bool `json:"running"`
|
|
Paused bool `json:"paused"`
|
|
DevMode bool `json:"devMode"`
|
|
GameState string `json:"gameState"`
|
|
Routine string `json:"routine,omitempty"`
|
|
Phase string `json:"phase,omitempty"`
|
|
RunCount int `json:"runCount"`
|
|
ItemsFound int `json:"itemsFound"`
|
|
Uptime string `json:"uptime"`
|
|
CaptureFPS float64 `json:"captureFps"`
|
|
HealthPct float64 `json:"healthPct"`
|
|
ManaPct float64 `json:"manaPct"`
|
|
}
|
|
|
|
// PixelInfo represents RGB and HSV values at a pixel.
|
|
type PixelInfo struct {
|
|
X int `json:"x"`
|
|
Y int `json:"y"`
|
|
RGB [3]int `json:"rgb"`
|
|
HSV [3]int `json:"hsv"`
|
|
}
|
|
|
|
// RegionInfo represents a screen region.
|
|
type RegionInfo struct {
|
|
Name string `json:"name"`
|
|
X int `json:"x"`
|
|
Y int `json:"y"`
|
|
Width int `json:"width"`
|
|
Height int `json:"height"`
|
|
}
|
|
|
|
// HSVColor represents an HSV color value.
|
|
type HSVColor struct {
|
|
H int `json:"h"`
|
|
S int `json:"s"`
|
|
V int `json:"v"`
|
|
}
|
|
|
|
// RegionAnalysis represents analysis results for a specific region.
|
|
type RegionAnalysis struct {
|
|
Name string `json:"name"`
|
|
DominantHSV HSVColor `json:"dominantHSV"`
|
|
MatchPercent float64 `json:"matchPercent"`
|
|
}
|
|
|
|
// AnalysisResponse represents the response from /api/analyze endpoint.
|
|
type AnalysisResponse struct {
|
|
GameState string `json:"gameState"`
|
|
Vitals VitalsInfo `json:"vitals"`
|
|
Regions []RegionAnalysis `json:"regions"`
|
|
}
|
|
|
|
// VitalsInfo represents vital statistics.
|
|
type VitalsInfo struct {
|
|
HealthPct float64 `json:"healthPct"`
|
|
ManaPct float64 `json:"manaPct"`
|
|
}
|
|
|
|
// Server provides the HTTP API and WebSocket endpoint.
|
|
type Server struct {
|
|
mu sync.RWMutex
|
|
engine *engine.Engine
|
|
addr string
|
|
mux *http.ServeMux
|
|
webRoot string
|
|
}
|
|
|
|
// NewServer creates an API server on the given address.
|
|
func NewServer(addr string, eng *engine.Engine, webRoot string) *Server {
|
|
s := &Server{
|
|
engine: eng,
|
|
addr: addr,
|
|
mux: http.NewServeMux(),
|
|
webRoot: webRoot,
|
|
}
|
|
s.registerRoutes()
|
|
return s
|
|
}
|
|
|
|
// Start begins serving the API.
|
|
func (s *Server) Start() error {
|
|
return http.ListenAndServe(s.addr, s.enableCORS(s.mux))
|
|
}
|
|
|
|
func (s *Server) registerRoutes() {
|
|
// API routes
|
|
s.mux.HandleFunc("GET /api/status", s.handleStatus)
|
|
s.mux.HandleFunc("GET /api/capture/frame", s.handleCaptureFrame)
|
|
s.mux.HandleFunc("GET /api/capture/frame/annotated", s.handleCaptureFrameAnnotated)
|
|
s.mux.HandleFunc("GET /api/capture/stats", s.handleCaptureStats)
|
|
s.mux.HandleFunc("POST /api/capture/upload", s.handleCaptureUpload)
|
|
s.mux.HandleFunc("POST /api/capture/source", s.handleCaptureSource)
|
|
s.mux.HandleFunc("GET /api/regions", s.handleRegions)
|
|
s.mux.HandleFunc("GET /api/state", s.handleState)
|
|
s.mux.HandleFunc("GET /api/loot/rules", s.handleLootRules)
|
|
s.mux.HandleFunc("GET /api/routines", s.handleRoutines)
|
|
s.mux.HandleFunc("GET /api/pixel", s.handlePixel)
|
|
s.mux.HandleFunc("GET /api/config", s.handleConfig)
|
|
s.mux.HandleFunc("GET /api/plugins", s.handlePlugins)
|
|
s.mux.HandleFunc("GET /api/analyze", s.handleAnalyze)
|
|
s.mux.HandleFunc("POST /api/start", s.handleStart)
|
|
s.mux.HandleFunc("POST /api/stop", s.handleStop)
|
|
s.mux.HandleFunc("POST /api/pause", s.handlePause)
|
|
|
|
// WebSocket endpoint
|
|
// s.mux.HandleFunc("/api/ws", s.handleWebSocket)
|
|
|
|
// Serve static files for dev dashboard
|
|
s.mux.Handle("/", http.FileServer(http.Dir(s.webRoot)))
|
|
}
|
|
|
|
func (s *Server) enableCORS(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Access-Control-Allow-Origin", "*")
|
|
w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
|
|
w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
|
|
|
|
if r.Method == "OPTIONS" {
|
|
w.WriteHeader(http.StatusOK)
|
|
return
|
|
}
|
|
|
|
next.ServeHTTP(w, r)
|
|
})
|
|
}
|
|
|
|
func (s *Server) handleStatus(w http.ResponseWriter, r *http.Request) {
|
|
status := s.engine.Status()
|
|
|
|
response := Status{
|
|
Running: status.Running,
|
|
Paused: status.Paused,
|
|
DevMode: status.DevMode,
|
|
GameState: string(status.GameState),
|
|
Uptime: status.Uptime.String(),
|
|
CaptureFPS: status.CaptureStats.FPS,
|
|
HealthPct: status.Vitals.HealthPct,
|
|
ManaPct: status.Vitals.ManaPct,
|
|
ItemsFound: status.ItemsFound,
|
|
RunCount: status.RunCount,
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
func (s *Server) handleCaptureFrame(w http.ResponseWriter, r *http.Request) {
|
|
frame := s.engine.CurrentFrame()
|
|
if frame == nil {
|
|
http.Error(w, "No frame available", http.StatusNoContent)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "image/jpeg")
|
|
|
|
var buf bytes.Buffer
|
|
if err := jpeg.Encode(&buf, frame, &jpeg.Options{Quality: 85}); err != nil {
|
|
http.Error(w, "Failed to encode frame", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.Write(buf.Bytes())
|
|
}
|
|
|
|
func (s *Server) handleCaptureFrameAnnotated(w http.ResponseWriter, r *http.Request) {
|
|
frame := s.engine.CurrentFrame()
|
|
if frame == nil {
|
|
http.Error(w, "No frame available", http.StatusNoContent)
|
|
return
|
|
}
|
|
|
|
// Create a copy of the frame to draw on
|
|
bounds := frame.Bounds()
|
|
annotated := image.NewRGBA(bounds)
|
|
draw.Draw(annotated, bounds, frame, bounds.Min, draw.Src)
|
|
|
|
// Get regions to draw (filtered by query parameter if present)
|
|
regions := s.getRegions()
|
|
|
|
// Filter regions by query parameter if provided
|
|
if r.URL.Query().Has("regions") {
|
|
regionsParam := r.URL.Query().Get("regions")
|
|
if regionsParam == "" {
|
|
regions = nil // Empty param = no overlays
|
|
} else {
|
|
regionNames := strings.Split(regionsParam, ",")
|
|
filteredRegions := make([]RegionInfo, 0)
|
|
for _, region := range regions {
|
|
for _, name := range regionNames {
|
|
if strings.TrimSpace(name) == region.Name {
|
|
filteredRegions = append(filteredRegions, region)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
regions = filteredRegions
|
|
}
|
|
}
|
|
|
|
s.drawRegionOverlays(annotated, regions)
|
|
|
|
w.Header().Set("Content-Type", "image/jpeg")
|
|
|
|
var buf bytes.Buffer
|
|
if err := jpeg.Encode(&buf, annotated, &jpeg.Options{Quality: 85}); err != nil {
|
|
http.Error(w, "Failed to encode annotated frame", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.Write(buf.Bytes())
|
|
}
|
|
|
|
func (s *Server) handleCaptureStats(w http.ResponseWriter, r *http.Request) {
|
|
status := s.engine.Status()
|
|
stats := status.CaptureStats
|
|
|
|
response := map[string]interface{}{
|
|
"frameCount": stats.FrameCount,
|
|
"avgCaptureMs": stats.AvgCaptureMs,
|
|
"fps": stats.FPS,
|
|
"lastCapture": stats.LastCapture,
|
|
"backend": "file", // TODO: Get actual backend name
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
func (s *Server) handleCaptureUpload(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != "POST" {
|
|
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
|
|
file, header, err := r.FormFile("file")
|
|
if err != nil {
|
|
http.Error(w, "Failed to read uploaded file", http.StatusBadRequest)
|
|
return
|
|
}
|
|
defer file.Close()
|
|
|
|
// Save to temporary directory
|
|
tempDir := "/tmp/iso-bot-uploads"
|
|
os.MkdirAll(tempDir, 0755)
|
|
|
|
filename := filepath.Join(tempDir, header.Filename)
|
|
out, err := os.Create(filename)
|
|
if err != nil {
|
|
http.Error(w, "Failed to save file", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer out.Close()
|
|
|
|
_, err = io.Copy(out, file)
|
|
if err != nil {
|
|
http.Error(w, "Failed to save file", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Auto-switch capture source to uploaded file
|
|
fileConfig := map[string]interface{}{
|
|
"path": filename,
|
|
"type": "image",
|
|
}
|
|
|
|
newSource, err := backends.NewFileSource(fileConfig)
|
|
if err != nil {
|
|
log.Printf("Failed to create file source: %v", err)
|
|
response := map[string]string{
|
|
"filename": filename,
|
|
"message": fmt.Sprintf("File uploaded to %s but failed to switch capture source: %v", filename, err),
|
|
"autoSwitch": "failed",
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(response)
|
|
return
|
|
}
|
|
|
|
err = s.engine.SetCaptureSource(newSource)
|
|
if err != nil {
|
|
log.Printf("Failed to set capture source: %v", err)
|
|
response := map[string]string{
|
|
"filename": filename,
|
|
"message": fmt.Sprintf("File uploaded to %s but failed to switch capture source: %v", filename, err),
|
|
"autoSwitch": "failed",
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(response)
|
|
return
|
|
}
|
|
|
|
response := map[string]string{
|
|
"filename": filename,
|
|
"message": fmt.Sprintf("File uploaded to %s and capture source switched successfully", filename),
|
|
"autoSwitch": "true",
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
func (s *Server) handleCaptureSource(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != "POST" {
|
|
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
|
|
var req struct {
|
|
Type string `json:"type"`
|
|
Config map[string]interface{} `json:"config"`
|
|
}
|
|
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
http.Error(w, "Invalid JSON", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// Import capture backends to create new source
|
|
// We'll need to import the backends package here
|
|
log.Printf("Switching capture source to type=%s config=%+v", req.Type, req.Config)
|
|
|
|
response := map[string]string{
|
|
"message": fmt.Sprintf("Source switch requested: %s", req.Type),
|
|
"status": "partial", // Implementation incomplete
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
func (s *Server) handleRegions(w http.ResponseWriter, r *http.Request) {
|
|
regions := s.getRegions()
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(regions)
|
|
}
|
|
|
|
func (s *Server) handleState(w http.ResponseWriter, r *http.Request) {
|
|
status := s.engine.Status()
|
|
|
|
response := map[string]interface{}{
|
|
"gameState": string(status.GameState),
|
|
"healthPct": status.Vitals.HealthPct,
|
|
"manaPct": status.Vitals.ManaPct,
|
|
"xpPct": status.Vitals.XPPct,
|
|
"frameCount": status.FrameCount,
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
func (s *Server) handleLootRules(w http.ResponseWriter, r *http.Request) {
|
|
lootEngine := s.engine.LootEngine()
|
|
if lootEngine == nil {
|
|
response := map[string]interface{}{
|
|
"rules": []interface{}{},
|
|
"count": 0,
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(response)
|
|
return
|
|
}
|
|
|
|
response := map[string]interface{}{
|
|
"rules": lootEngine.Rules,
|
|
"count": len(lootEngine.Rules),
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
func (s *Server) handleRoutines(w http.ResponseWriter, r *http.Request) {
|
|
routines := s.engine.GamePlugin().Routines()
|
|
|
|
response := make([]map[string]interface{}, 0)
|
|
for _, routine := range routines {
|
|
response = append(response, map[string]interface{}{
|
|
"name": routine.Name(),
|
|
"phase": routine.Phase(),
|
|
})
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
func (s *Server) handlePixel(w http.ResponseWriter, r *http.Request) {
|
|
xStr := r.URL.Query().Get("x")
|
|
yStr := r.URL.Query().Get("y")
|
|
|
|
x, err := strconv.Atoi(xStr)
|
|
if err != nil {
|
|
http.Error(w, "Invalid x coordinate", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
y, err := strconv.Atoi(yStr)
|
|
if err != nil {
|
|
http.Error(w, "Invalid y coordinate", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
frame := s.engine.CurrentFrame()
|
|
if frame == nil {
|
|
http.Error(w, "No frame available", http.StatusNoContent)
|
|
return
|
|
}
|
|
|
|
bounds := frame.Bounds()
|
|
point := image.Point{X: x, Y: y}
|
|
if !point.In(bounds) {
|
|
http.Error(w, "Coordinates out of bounds", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
c := frame.At(x, y)
|
|
red, green, blue, _ := c.RGBA()
|
|
// Convert to 8-bit
|
|
red, green, blue = red>>8, green>>8, blue>>8
|
|
|
|
hsv := vision.RGBToHSV(c)
|
|
|
|
response := PixelInfo{
|
|
X: x,
|
|
Y: y,
|
|
RGB: [3]int{int(red), int(green), int(blue)},
|
|
HSV: [3]int{hsv.H, hsv.S, hsv.V},
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
func (s *Server) handleConfig(w http.ResponseWriter, r *http.Request) {
|
|
// TODO: Return actual config
|
|
response := map[string]interface{}{
|
|
"game": s.engine.GamePlugin().Info().ID,
|
|
"devMode": s.engine.Status().DevMode,
|
|
"resolution": fmt.Sprintf("%dx%d", 1920, 1080), // TODO: Get actual resolution
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
func (s *Server) handlePlugins(w http.ResponseWriter, r *http.Request) {
|
|
pluginInfo := s.engine.GamePlugin().Info()
|
|
|
|
response := []map[string]interface{}{
|
|
{
|
|
"id": pluginInfo.ID,
|
|
"name": pluginInfo.Name,
|
|
"version": pluginInfo.Version,
|
|
"description": pluginInfo.Description,
|
|
"resolution": fmt.Sprintf("%dx%d", pluginInfo.Resolution.X, pluginInfo.Resolution.Y),
|
|
},
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
func (s *Server) handleStart(w http.ResponseWriter, r *http.Request) {
|
|
// TODO: Start the engine
|
|
response := map[string]string{
|
|
"message": "Start not implemented yet",
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
func (s *Server) handleStop(w http.ResponseWriter, r *http.Request) {
|
|
s.engine.Stop()
|
|
response := map[string]string{
|
|
"message": "Engine stopped",
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
func (s *Server) handlePause(w http.ResponseWriter, r *http.Request) {
|
|
var req struct {
|
|
Paused bool `json:"paused"`
|
|
}
|
|
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
http.Error(w, "Invalid JSON", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
s.engine.Pause(req.Paused)
|
|
|
|
action := "resumed"
|
|
if req.Paused {
|
|
action = "paused"
|
|
}
|
|
|
|
response := map[string]string{
|
|
"message": fmt.Sprintf("Engine %s", action),
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
func (s *Server) handleAnalyze(w http.ResponseWriter, r *http.Request) {
|
|
frame := s.engine.CurrentFrame()
|
|
if frame == nil {
|
|
http.Error(w, "No frame available", http.StatusNoContent)
|
|
return
|
|
}
|
|
|
|
status := s.engine.Status()
|
|
|
|
// Get vitals
|
|
vitals := VitalsInfo{
|
|
HealthPct: status.Vitals.HealthPct,
|
|
ManaPct: status.Vitals.ManaPct,
|
|
}
|
|
|
|
// Get regions and analyze each one
|
|
regions := s.getRegions()
|
|
regionAnalyses := make([]RegionAnalysis, 0, len(regions))
|
|
|
|
for _, region := range regions {
|
|
analysis := s.analyzeRegion(frame, region)
|
|
regionAnalyses = append(regionAnalyses, analysis)
|
|
}
|
|
|
|
response := AnalysisResponse{
|
|
GameState: string(status.GameState),
|
|
Vitals: vitals,
|
|
Regions: regionAnalyses,
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
// Helper functions
|
|
|
|
func (s *Server) getRegions() []RegionInfo {
|
|
gameID := s.engine.GamePlugin().Info().ID
|
|
// TODO: Get actual current resolution
|
|
width, height := 1920, 1080
|
|
|
|
registry := s.engine.ResolutionRegistry()
|
|
profile, err := registry.Get(gameID, width, height)
|
|
if err != nil {
|
|
log.Printf("Failed to get resolution profile: %v", err)
|
|
return make([]RegionInfo, 0)
|
|
}
|
|
|
|
var regions []RegionInfo
|
|
for name, rect := range profile.Regions {
|
|
regions = append(regions, RegionInfo{
|
|
Name: name,
|
|
X: rect.Min.X,
|
|
Y: rect.Min.Y,
|
|
Width: rect.Dx(),
|
|
Height: rect.Dy(),
|
|
})
|
|
}
|
|
|
|
return regions
|
|
}
|
|
|
|
func (s *Server) analyzeRegion(frame image.Image, region RegionInfo) RegionAnalysis {
|
|
rect := image.Rect(region.X, region.Y, region.X+region.Width, region.Y+region.Height)
|
|
bounds := rect.Intersect(frame.Bounds())
|
|
|
|
if bounds.Empty() {
|
|
return RegionAnalysis{
|
|
Name: region.Name,
|
|
DominantHSV: HSVColor{H: 0, S: 0, V: 0},
|
|
MatchPercent: 0.0,
|
|
}
|
|
}
|
|
|
|
// Calculate dominant HSV by averaging all pixels in region
|
|
var totalH, totalS, totalV int64
|
|
var pixelCount int64
|
|
|
|
// Also count matches for the region's expected color range
|
|
var matchingPixels int64
|
|
expectedColorRange := s.getExpectedColorRange(region.Name)
|
|
|
|
for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
|
|
for x := bounds.Min.X; x < bounds.Max.X; x++ {
|
|
c := frame.At(x, y)
|
|
hsv := vision.RGBToHSV(c)
|
|
|
|
totalH += int64(hsv.H)
|
|
totalS += int64(hsv.S)
|
|
totalV += int64(hsv.V)
|
|
pixelCount++
|
|
|
|
// Check if this pixel matches the expected color range
|
|
if expectedColorRange != nil && s.colorInRange(hsv, *expectedColorRange) {
|
|
matchingPixels++
|
|
}
|
|
}
|
|
}
|
|
|
|
dominantHSV := HSVColor{H: 0, S: 0, V: 0}
|
|
matchPercent := 0.0
|
|
|
|
if pixelCount > 0 {
|
|
dominantHSV = HSVColor{
|
|
H: int(totalH / pixelCount),
|
|
S: int(totalS / pixelCount),
|
|
V: int(totalV / pixelCount),
|
|
}
|
|
|
|
if expectedColorRange != nil {
|
|
matchPercent = float64(matchingPixels) / float64(pixelCount) * 100.0
|
|
}
|
|
}
|
|
|
|
return RegionAnalysis{
|
|
Name: region.Name,
|
|
DominantHSV: dominantHSV,
|
|
MatchPercent: matchPercent,
|
|
}
|
|
}
|
|
|
|
func (s *Server) getExpectedColorRange(regionName string) *vision.ColorRange {
|
|
// Get D2R config to determine expected color ranges for each region type
|
|
// For now, we'll handle the main regions: health_orb and mana_orb
|
|
switch regionName {
|
|
case "health_orb":
|
|
return &vision.ColorRange{
|
|
LowerH: 0, UpperH: 30,
|
|
LowerS: 50, UpperS: 255,
|
|
LowerV: 30, UpperV: 255,
|
|
}
|
|
case "mana_orb":
|
|
return &vision.ColorRange{
|
|
LowerH: 200, UpperH: 240,
|
|
LowerS: 40, UpperS: 255,
|
|
LowerV: 20, UpperV: 255,
|
|
}
|
|
default:
|
|
// For other regions, we don't have specific expected color ranges
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func (s *Server) colorInRange(hsv vision.HSV, colorRange vision.ColorRange) bool {
|
|
return hsv.H >= colorRange.LowerH && hsv.H <= colorRange.UpperH &&
|
|
hsv.S >= colorRange.LowerS && hsv.S <= colorRange.UpperS &&
|
|
hsv.V >= colorRange.LowerV && hsv.V <= colorRange.UpperV
|
|
}
|
|
|
|
func (s *Server) drawRegionOverlays(img *image.RGBA, regions []RegionInfo) {
|
|
// Simple colored rectangles for region overlays
|
|
colors := []image.Uniform{
|
|
{C: color.RGBA{255, 0, 0, 128}}, // Red
|
|
{C: color.RGBA{0, 255, 0, 128}}, // Green
|
|
{C: color.RGBA{0, 0, 255, 128}}, // Blue
|
|
{C: color.RGBA{255, 255, 0, 128}}, // Yellow
|
|
{C: color.RGBA{255, 0, 255, 128}}, // Magenta
|
|
{C: color.RGBA{0, 255, 255, 128}}, // Cyan
|
|
}
|
|
|
|
for i, region := range regions {
|
|
color := &colors[i%len(colors)]
|
|
rect := image.Rect(region.X, region.Y, region.X+region.Width, region.Y+region.Height)
|
|
|
|
// Draw border (simple approach - just draw a few pixel wide border)
|
|
borderWidth := 2
|
|
|
|
// Top border
|
|
draw.Draw(img, image.Rect(rect.Min.X, rect.Min.Y, rect.Max.X, rect.Min.Y+borderWidth), color, image.Point{}, draw.Over)
|
|
// Bottom border
|
|
draw.Draw(img, image.Rect(rect.Min.X, rect.Max.Y-borderWidth, rect.Max.X, rect.Max.Y), color, image.Point{}, draw.Over)
|
|
// Left border
|
|
draw.Draw(img, image.Rect(rect.Min.X, rect.Min.Y, rect.Min.X+borderWidth, rect.Max.Y), color, image.Point{}, draw.Over)
|
|
// Right border
|
|
draw.Draw(img, image.Rect(rect.Max.X-borderWidth, rect.Min.Y, rect.Max.X, rect.Max.Y), color, image.Point{}, draw.Over)
|
|
}
|
|
}
|