730 lines
21 KiB
Dart
730 lines
21 KiB
Dart
/// Gestionnaire d'état pour l'analyse des cibles (ChangeNotifier).
|
|
///
|
|
/// Gère le workflow complet d'analyse : chargement d'image, détection de cible,
|
|
/// gestion des impacts (manuels et automatiques), calcul des scores,
|
|
/// analyse de groupement et sauvegarde des sessions.
|
|
library;
|
|
|
|
import 'dart:io';
|
|
import 'dart:ui' as ui;
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:uuid/uuid.dart';
|
|
import '../../data/models/session.dart';
|
|
import '../../data/models/shot.dart';
|
|
import '../../data/models/target_type.dart';
|
|
import '../../data/repositories/session_repository.dart';
|
|
import '../../services/target_detection_service.dart';
|
|
import '../../services/score_calculator_service.dart';
|
|
import '../../services/grouping_analyzer_service.dart';
|
|
import '../../services/distortion_correction_service.dart';
|
|
import '../../services/opencv_target_service.dart';
|
|
|
|
enum AnalysisState { initial, loading, success, error }
|
|
|
|
class AnalysisProvider extends ChangeNotifier {
|
|
final TargetDetectionService _detectionService;
|
|
final ScoreCalculatorService _scoreCalculatorService;
|
|
final GroupingAnalyzerService _groupingAnalyzerService;
|
|
final SessionRepository _sessionRepository;
|
|
final DistortionCorrectionService _distortionService;
|
|
final OpenCVTargetService _opencvTargetService;
|
|
final Uuid _uuid = const Uuid();
|
|
|
|
AnalysisProvider({
|
|
required TargetDetectionService detectionService,
|
|
required ScoreCalculatorService scoreCalculatorService,
|
|
required GroupingAnalyzerService groupingAnalyzerService,
|
|
required SessionRepository sessionRepository,
|
|
DistortionCorrectionService? distortionService,
|
|
OpenCVTargetService? opencvTargetService,
|
|
}) : _detectionService = detectionService,
|
|
_scoreCalculatorService = scoreCalculatorService,
|
|
_groupingAnalyzerService = groupingAnalyzerService,
|
|
_sessionRepository = sessionRepository,
|
|
_distortionService = distortionService ?? DistortionCorrectionService(),
|
|
_opencvTargetService = opencvTargetService ?? OpenCVTargetService();
|
|
|
|
AnalysisState _state = AnalysisState.initial;
|
|
String? _errorMessage;
|
|
String? _imagePath;
|
|
TargetType? _targetType;
|
|
|
|
// Target detection results
|
|
double _targetCenterX = 0.5;
|
|
double _targetCenterY = 0.5;
|
|
double _targetRadius = 0.4;
|
|
double _targetInnerRadius = 0.04;
|
|
int _ringCount = 10;
|
|
List<double>? _ringRadii; // Individual ring radii multipliers
|
|
double _imageAspectRatio = 1.0; // width / height
|
|
|
|
// Shots
|
|
List<Shot> _shots = [];
|
|
|
|
// Score results
|
|
ScoreResult? _scoreResult;
|
|
|
|
// Grouping results
|
|
GroupingResult? _groupingResult;
|
|
|
|
// Reference-based detection
|
|
List<Shot> _referenceImpacts = [];
|
|
ImpactCharacteristics? _learnedCharacteristics;
|
|
|
|
// Distortion correction
|
|
bool _distortionCorrectionEnabled = false;
|
|
DistortionParameters? _distortionParams;
|
|
String? _correctedImagePath;
|
|
|
|
// Getters
|
|
AnalysisState get state => _state;
|
|
String? get errorMessage => _errorMessage;
|
|
String? get imagePath => _imagePath;
|
|
TargetType? get targetType => _targetType;
|
|
double get targetCenterX => _targetCenterX;
|
|
double get targetCenterY => _targetCenterY;
|
|
double get targetRadius => _targetRadius;
|
|
double get targetInnerRadius => _targetInnerRadius;
|
|
int get ringCount => _ringCount;
|
|
List<double>? get ringRadii =>
|
|
_ringRadii != null ? List.unmodifiable(_ringRadii!) : null;
|
|
double get imageAspectRatio => _imageAspectRatio;
|
|
List<Shot> get shots => List.unmodifiable(_shots);
|
|
ScoreResult? get scoreResult => _scoreResult;
|
|
GroupingResult? get groupingResult => _groupingResult;
|
|
|
|
int get totalScore => _scoreResult?.totalScore ?? 0;
|
|
int get shotCount => _shots.length;
|
|
List<Shot> get referenceImpacts => List.unmodifiable(_referenceImpacts);
|
|
ImpactCharacteristics? get learnedCharacteristics => _learnedCharacteristics;
|
|
bool get hasLearnedCharacteristics => _learnedCharacteristics != null;
|
|
|
|
// Distortion correction getters
|
|
bool get distortionCorrectionEnabled => _distortionCorrectionEnabled;
|
|
DistortionParameters? get distortionParams => _distortionParams;
|
|
String? get correctedImagePath => _correctedImagePath;
|
|
bool get hasDistortion => _distortionParams?.needsCorrection ?? false;
|
|
|
|
/// Retourne le chemin de l'image à afficher (corrigée si activée, originale sinon)
|
|
String? get displayImagePath =>
|
|
_distortionCorrectionEnabled && _correctedImagePath != null
|
|
? _correctedImagePath
|
|
: _imagePath;
|
|
|
|
/// Analyze an image
|
|
///
|
|
/// [autoAnalyze] determines if we should run automatic detection immediately.
|
|
/// If false, only the image is loaded and default target parameters are set.
|
|
Future<void> analyzeImage(
|
|
String imagePath,
|
|
TargetType targetType, {
|
|
bool autoAnalyze = true,
|
|
}) async {
|
|
_state = AnalysisState.loading;
|
|
_imagePath = imagePath;
|
|
_targetType = targetType;
|
|
_errorMessage = null;
|
|
notifyListeners();
|
|
|
|
try {
|
|
// Load image to get dimensions
|
|
final file = File(imagePath);
|
|
final bytes = await file.readAsBytes();
|
|
final codec = await ui.instantiateImageCodec(bytes);
|
|
final frame = await codec.getNextFrame();
|
|
_imageAspectRatio = frame.image.width / frame.image.height;
|
|
frame.image.dispose();
|
|
|
|
if (!autoAnalyze) {
|
|
// Just setup default values without running detection
|
|
_targetCenterX = 0.5;
|
|
_targetCenterY = 0.5;
|
|
_targetRadius = 0.4;
|
|
_targetInnerRadius = 0.04;
|
|
|
|
// Initialize empty shots list
|
|
_shots = [];
|
|
|
|
_state = AnalysisState.success;
|
|
notifyListeners();
|
|
return;
|
|
}
|
|
|
|
// Detect target and impacts
|
|
final result = _detectionService.detectTarget(imagePath, targetType);
|
|
|
|
if (!result.success) {
|
|
_state = AnalysisState.error;
|
|
_errorMessage = result.errorMessage;
|
|
notifyListeners();
|
|
return;
|
|
}
|
|
|
|
_targetCenterX = result.centerX;
|
|
_targetCenterY = result.centerY;
|
|
_targetRadius = result.radius;
|
|
_targetInnerRadius = result.radius * 0.1;
|
|
|
|
// Create shots from detected impacts
|
|
_shots = result.impacts.map((impact) {
|
|
return Shot(
|
|
id: _uuid.v4(),
|
|
x: impact.x,
|
|
y: impact.y,
|
|
score: impact.suggestedScore,
|
|
sessionId: '', // Will be set when saving
|
|
);
|
|
}).toList();
|
|
|
|
// Calculate scores
|
|
_recalculateScores();
|
|
|
|
// Calculate grouping
|
|
_recalculateGrouping();
|
|
|
|
_state = AnalysisState.success;
|
|
notifyListeners();
|
|
} catch (e) {
|
|
_state = AnalysisState.error;
|
|
_errorMessage = 'Erreur d\'analyse: $e';
|
|
notifyListeners();
|
|
}
|
|
}
|
|
|
|
/// Add a manual shot
|
|
void addShot(double x, double y) {
|
|
final score = _calculateShotScore(x, y);
|
|
final shot = Shot(id: _uuid.v4(), x: x, y: y, score: score, sessionId: '');
|
|
|
|
_shots.add(shot);
|
|
_recalculateScores();
|
|
_recalculateGrouping();
|
|
notifyListeners();
|
|
}
|
|
|
|
/// Remove a shot
|
|
void removeShot(String shotId) {
|
|
_shots.removeWhere((shot) => shot.id == shotId);
|
|
_recalculateScores();
|
|
_recalculateGrouping();
|
|
notifyListeners();
|
|
}
|
|
|
|
/// Move a shot to a new position
|
|
void moveShot(String shotId, double newX, double newY) {
|
|
final index = _shots.indexWhere((shot) => shot.id == shotId);
|
|
if (index == -1) return;
|
|
|
|
final newScore = _calculateShotScore(newX, newY);
|
|
_shots[index] = _shots[index].copyWith(x: newX, y: newY, score: newScore);
|
|
|
|
_recalculateScores();
|
|
_recalculateGrouping();
|
|
notifyListeners();
|
|
}
|
|
|
|
/// Auto-detect impacts using image processing
|
|
Future<int> autoDetectImpacts({
|
|
int darkThreshold = 80,
|
|
int minImpactSize = 20,
|
|
int maxImpactSize = 500,
|
|
double minCircularity = 0.6,
|
|
double minFillRatio = 0.5,
|
|
bool clearExisting = false,
|
|
}) async {
|
|
if (_imagePath == null || _targetType == null) return 0;
|
|
|
|
final settings = ImpactDetectionSettings(
|
|
darkThreshold: darkThreshold,
|
|
minImpactSize: minImpactSize,
|
|
maxImpactSize: maxImpactSize,
|
|
minCircularity: minCircularity,
|
|
minFillRatio: minFillRatio,
|
|
);
|
|
|
|
final detectedImpacts = _detectionService.detectImpactsOnly(
|
|
_imagePath!,
|
|
_targetType!,
|
|
_targetCenterX,
|
|
_targetCenterY,
|
|
_targetRadius,
|
|
_ringCount,
|
|
settings,
|
|
);
|
|
|
|
if (clearExisting) {
|
|
_shots.clear();
|
|
}
|
|
|
|
// Add detected impacts as shots
|
|
for (final impact in detectedImpacts) {
|
|
final score = _calculateShotScore(impact.x, impact.y);
|
|
final shot = Shot(
|
|
id: _uuid.v4(),
|
|
x: impact.x,
|
|
y: impact.y,
|
|
score: score,
|
|
sessionId: '',
|
|
);
|
|
_shots.add(shot);
|
|
}
|
|
|
|
_recalculateScores();
|
|
_recalculateGrouping();
|
|
notifyListeners();
|
|
|
|
return detectedImpacts.length;
|
|
}
|
|
|
|
/// Auto-detect impacts using OpenCV (Hough Circles + Contours)
|
|
///
|
|
/// NOTE: OpenCV est actuellement désactivé sur Windows en raison de problèmes
|
|
/// de compilation. Cette méthode retourne 0 (aucun impact détecté).
|
|
/// Utiliser autoDetectImpacts() à la place.
|
|
///
|
|
/// Utilise les algorithmes OpenCV pour une détection plus robuste:
|
|
/// - Transformation de Hough pour détecter les cercles
|
|
/// - Analyse de contours avec filtrage par circularité
|
|
Future<int> autoDetectImpactsWithOpenCV({
|
|
double cannyThreshold1 = 50,
|
|
double cannyThreshold2 = 150,
|
|
double minDist = 20,
|
|
double param1 = 100,
|
|
double param2 = 30,
|
|
int minRadius = 5,
|
|
int maxRadius = 50,
|
|
int blurSize = 5,
|
|
bool useContourDetection = true,
|
|
double minCircularity = 0.6,
|
|
double minContourArea = 50,
|
|
double maxContourArea = 5000,
|
|
bool clearExisting = false,
|
|
}) async {
|
|
if (_imagePath == null || _targetType == null) return 0;
|
|
|
|
final settings = OpenCVDetectionSettings(
|
|
cannyThreshold1: cannyThreshold1,
|
|
cannyThreshold2: cannyThreshold2,
|
|
minDist: minDist,
|
|
param1: param1,
|
|
param2: param2,
|
|
minRadius: minRadius,
|
|
maxRadius: maxRadius,
|
|
blurSize: blurSize,
|
|
useContourDetection: useContourDetection,
|
|
minCircularity: minCircularity,
|
|
minContourArea: minContourArea,
|
|
maxContourArea: maxContourArea,
|
|
);
|
|
|
|
final detectedImpacts = _detectionService.detectImpactsWithOpenCV(
|
|
_imagePath!,
|
|
_targetType!,
|
|
_targetCenterX,
|
|
_targetCenterY,
|
|
_targetRadius,
|
|
_ringCount,
|
|
settings: settings,
|
|
);
|
|
|
|
if (clearExisting) {
|
|
_shots.clear();
|
|
}
|
|
|
|
// Add detected impacts as shots
|
|
for (final impact in detectedImpacts) {
|
|
final score = _calculateShotScore(impact.x, impact.y);
|
|
final shot = Shot(
|
|
id: _uuid.v4(),
|
|
x: impact.x,
|
|
y: impact.y,
|
|
score: score,
|
|
sessionId: '',
|
|
);
|
|
_shots.add(shot);
|
|
}
|
|
|
|
_recalculateScores();
|
|
_recalculateGrouping();
|
|
notifyListeners();
|
|
|
|
return detectedImpacts.length;
|
|
}
|
|
|
|
/// Detect impacts with OpenCV using reference points
|
|
Future<int> detectFromReferencesWithOpenCV({
|
|
double tolerance = 2.0,
|
|
bool clearExisting = false,
|
|
}) async {
|
|
if (_imagePath == null ||
|
|
_targetType == null ||
|
|
_referenceImpacts.length < 2) {
|
|
return 0;
|
|
}
|
|
|
|
// Convertir les références
|
|
final references = _referenceImpacts
|
|
.map((shot) => ReferenceImpact(x: shot.x, y: shot.y))
|
|
.toList();
|
|
|
|
final detectedImpacts = _detectionService
|
|
.detectImpactsWithOpenCVFromReferences(
|
|
_imagePath!,
|
|
_targetType!,
|
|
_targetCenterX,
|
|
_targetCenterY,
|
|
_targetRadius,
|
|
_ringCount,
|
|
references,
|
|
tolerance: tolerance,
|
|
);
|
|
|
|
if (clearExisting) {
|
|
_shots.clear();
|
|
}
|
|
|
|
// Add detected impacts as shots
|
|
for (final impact in detectedImpacts) {
|
|
final score = _calculateShotScore(impact.x, impact.y);
|
|
final shot = Shot(
|
|
id: _uuid.v4(),
|
|
x: impact.x,
|
|
y: impact.y,
|
|
score: score,
|
|
sessionId: '',
|
|
);
|
|
_shots.add(shot);
|
|
}
|
|
|
|
_recalculateScores();
|
|
_recalculateGrouping();
|
|
notifyListeners();
|
|
|
|
return detectedImpacts.length;
|
|
}
|
|
|
|
/// Add a reference impact for calibrated detection
|
|
void addReferenceImpact(double x, double y) {
|
|
final score = _calculateShotScore(x, y);
|
|
final shot = Shot(id: _uuid.v4(), x: x, y: y, score: score, sessionId: '');
|
|
_referenceImpacts.add(shot);
|
|
notifyListeners();
|
|
}
|
|
|
|
/// Remove a reference impact
|
|
void removeReferenceImpact(String shotId) {
|
|
_referenceImpacts.removeWhere((shot) => shot.id == shotId);
|
|
_learnedCharacteristics = null;
|
|
notifyListeners();
|
|
}
|
|
|
|
/// Clear all reference impacts
|
|
void clearReferenceImpacts() {
|
|
_referenceImpacts.clear();
|
|
_learnedCharacteristics = null;
|
|
notifyListeners();
|
|
}
|
|
|
|
/// Learn characteristics from reference impacts
|
|
bool learnFromReferences() {
|
|
if (_imagePath == null || _referenceImpacts.length < 2) return false;
|
|
|
|
final references = _referenceImpacts
|
|
.map((shot) => ReferenceImpact(x: shot.x, y: shot.y))
|
|
.toList();
|
|
|
|
_learnedCharacteristics = _detectionService.analyzeReferenceImpacts(
|
|
_imagePath!,
|
|
references,
|
|
);
|
|
|
|
notifyListeners();
|
|
return _learnedCharacteristics != null;
|
|
}
|
|
|
|
/// Auto-detect impacts using learned reference characteristics
|
|
Future<int> detectFromReferences({
|
|
double tolerance = 2.0,
|
|
bool clearExisting = false,
|
|
}) async {
|
|
if (_imagePath == null ||
|
|
_targetType == null ||
|
|
_learnedCharacteristics == null) {
|
|
return 0;
|
|
}
|
|
|
|
final detectedImpacts = _detectionService.detectImpactsFromReferences(
|
|
_imagePath!,
|
|
_targetType!,
|
|
_targetCenterX,
|
|
_targetCenterY,
|
|
_targetRadius,
|
|
_ringCount,
|
|
_learnedCharacteristics!,
|
|
tolerance: tolerance,
|
|
);
|
|
|
|
if (clearExisting) {
|
|
_shots.clear();
|
|
}
|
|
|
|
// Add detected impacts as shots
|
|
for (final impact in detectedImpacts) {
|
|
final score = _calculateShotScore(impact.x, impact.y);
|
|
final shot = Shot(
|
|
id: _uuid.v4(),
|
|
x: impact.x,
|
|
y: impact.y,
|
|
score: score,
|
|
sessionId: '',
|
|
);
|
|
_shots.add(shot);
|
|
}
|
|
|
|
_recalculateScores();
|
|
_recalculateGrouping();
|
|
notifyListeners();
|
|
|
|
return detectedImpacts.length;
|
|
}
|
|
|
|
/// Adjust target position
|
|
void adjustTargetPosition(
|
|
double centerX,
|
|
double centerY,
|
|
double innerRadius,
|
|
double radius, {
|
|
int? ringCount,
|
|
List<double>? ringRadii,
|
|
}) {
|
|
_targetCenterX = centerX;
|
|
_targetCenterY = centerY;
|
|
_targetInnerRadius = innerRadius;
|
|
_targetRadius = radius;
|
|
if (ringCount != null) {
|
|
_ringCount = ringCount;
|
|
}
|
|
if (ringRadii != null) {
|
|
_ringRadii = ringRadii;
|
|
}
|
|
|
|
// Recalculate all shot scores based on new target position
|
|
_shots = _shots.map((shot) {
|
|
final newScore = _calculateShotScore(shot.x, shot.y);
|
|
return shot.copyWith(score: newScore);
|
|
}).toList();
|
|
|
|
_recalculateScores();
|
|
notifyListeners();
|
|
}
|
|
|
|
/// Auto-calibrate target using OpenCV
|
|
Future<bool> autoCalibrateTarget() async {
|
|
if (_imagePath == null) return false;
|
|
|
|
try {
|
|
// 1. Attempt to correct perspective/distortion first
|
|
final correctedPath = await _distortionService
|
|
.correctPerspectiveWithConcentricMesh(_imagePath!);
|
|
|
|
if (correctedPath != _imagePath) {
|
|
_imagePath = correctedPath;
|
|
_correctedImagePath = correctedPath;
|
|
_distortionCorrectionEnabled = true;
|
|
_imageAspectRatio =
|
|
1.0; // The corrected image is always square (side x side)
|
|
notifyListeners();
|
|
}
|
|
|
|
// 2. Detect the target on the straight/corrected image
|
|
final result = await _opencvTargetService.detectTarget(_imagePath!);
|
|
|
|
if (result.success) {
|
|
adjustTargetPosition(
|
|
result.centerX,
|
|
result.centerY,
|
|
result.radius * 0.1,
|
|
result.radius,
|
|
);
|
|
return true;
|
|
}
|
|
return false;
|
|
} catch (e) {
|
|
print('Auto-calibration error: $e');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// Calcule les paramètres de distorsion basés sur la calibration actuelle
|
|
void calculateDistortion() {
|
|
_distortionParams = _distortionService.calculateDistortionFromCalibration(
|
|
targetCenterX: _targetCenterX,
|
|
targetCenterY: _targetCenterY,
|
|
targetRadius: _targetRadius,
|
|
imageAspectRatio: _imageAspectRatio,
|
|
);
|
|
notifyListeners();
|
|
}
|
|
|
|
/// Applique la correction de distorsion à l'image
|
|
/// Crée une nouvelle image corrigée et la sauvegarde
|
|
Future<void> applyDistortionCorrection() async {
|
|
if (_imagePath == null || _distortionParams == null) return;
|
|
|
|
try {
|
|
_correctedImagePath = await _distortionService.applyCorrection(
|
|
_imagePath!,
|
|
_distortionParams!,
|
|
);
|
|
_distortionCorrectionEnabled = true;
|
|
notifyListeners();
|
|
} catch (e) {
|
|
_errorMessage = 'Erreur lors de la correction: $e';
|
|
notifyListeners();
|
|
}
|
|
}
|
|
|
|
/// Active ou désactive l'affichage de l'image corrigée
|
|
void setDistortionCorrectionEnabled(bool enabled) {
|
|
if (enabled && _correctedImagePath == null && _distortionParams != null) {
|
|
// Si on active mais pas encore d'image corrigée, la créer
|
|
applyDistortionCorrection();
|
|
} else {
|
|
_distortionCorrectionEnabled = enabled;
|
|
notifyListeners();
|
|
}
|
|
}
|
|
|
|
/* version deux a tester*/
|
|
/// Calcule ET applique la correction pour un feedback immédiat
|
|
Future<void> calculateAndApplyDistortion() async {
|
|
// 1. Calcul des paramètres (votre code actuel)
|
|
_distortionParams = _distortionService.calculateDistortionFromCalibration(
|
|
targetCenterX: _targetCenterX,
|
|
targetCenterY: _targetCenterY,
|
|
targetRadius: _targetRadius,
|
|
imageAspectRatio: _imageAspectRatio,
|
|
);
|
|
|
|
// 2. Vérification si une correction est réellement nécessaire
|
|
if (_distortionParams != null && _distortionParams!.needsCorrection) {
|
|
// 3. Application immédiate de la transformation (méthode asynchrone)
|
|
await applyDistortionCorrection();
|
|
} else {
|
|
notifyListeners(); // On prévient quand même si pas de correction
|
|
}
|
|
}
|
|
|
|
Future<void> runFullDistortionWorkflow() async {
|
|
_state = AnalysisState.loading; // Affiche un spinner sur votre UI
|
|
notifyListeners();
|
|
|
|
try {
|
|
calculateDistortion(); // Calcule les paramètres
|
|
await applyDistortionCorrection(); // Génère le fichier corrigé
|
|
_distortionCorrectionEnabled = true; // Active l'affichage
|
|
_state = AnalysisState.success;
|
|
} catch (e) {
|
|
_errorMessage = "Erreur de rendu : $e";
|
|
_state = AnalysisState.error;
|
|
} finally {
|
|
notifyListeners();
|
|
}
|
|
}
|
|
/* fin section deux a tester*/
|
|
|
|
int _calculateShotScore(double x, double y) {
|
|
if (_targetType == TargetType.concentric) {
|
|
return _scoreCalculatorService.calculateConcentricScore(
|
|
shotX: x,
|
|
shotY: y,
|
|
targetCenterX: _targetCenterX,
|
|
targetCenterY: _targetCenterY,
|
|
targetRadius: _targetRadius,
|
|
ringCount: _ringCount,
|
|
imageAspectRatio: _imageAspectRatio,
|
|
ringRadii: _ringRadii,
|
|
);
|
|
} else {
|
|
return _scoreCalculatorService.calculateSilhouetteScore(
|
|
shotX: x,
|
|
shotY: y,
|
|
targetCenterX: _targetCenterX,
|
|
targetCenterY: _targetCenterY,
|
|
targetWidth: _targetRadius * 0.8,
|
|
targetHeight: _targetRadius * 2,
|
|
);
|
|
}
|
|
}
|
|
|
|
void _recalculateScores() {
|
|
if (_targetType == null) return;
|
|
|
|
_scoreResult = _scoreCalculatorService.calculateScores(
|
|
shots: _shots,
|
|
targetType: _targetType!,
|
|
targetCenterX: _targetCenterX,
|
|
targetCenterY: _targetCenterY,
|
|
targetRadius: _targetRadius,
|
|
ringCount: _ringCount,
|
|
imageAspectRatio: _imageAspectRatio,
|
|
ringRadii: _ringRadii,
|
|
);
|
|
}
|
|
|
|
void _recalculateGrouping() {
|
|
_groupingResult = _groupingAnalyzerService.analyzeGrouping(_shots);
|
|
}
|
|
|
|
/// Save the session
|
|
Future<Session> saveSession({String? notes}) async {
|
|
if (_imagePath == null || _targetType == null) {
|
|
throw Exception('Cannot save: missing image or target type');
|
|
}
|
|
|
|
final session = await _sessionRepository.createSession(
|
|
targetType: _targetType!,
|
|
imagePath: _imagePath!,
|
|
shots: _shots.map((s) => s.copyWith(sessionId: '')).toList(),
|
|
totalScore: totalScore,
|
|
groupingDiameter: _groupingResult?.diameter,
|
|
groupingCenterX: _groupingResult?.centerX,
|
|
groupingCenterY: _groupingResult?.centerY,
|
|
notes: notes,
|
|
targetCenterX: _targetCenterX,
|
|
targetCenterY: _targetCenterY,
|
|
targetRadius: _targetRadius,
|
|
);
|
|
|
|
// Update shots with session ID
|
|
_shots = session.shots;
|
|
notifyListeners();
|
|
|
|
return session;
|
|
}
|
|
|
|
/// Reset the provider
|
|
void reset() {
|
|
_state = AnalysisState.initial;
|
|
_errorMessage = null;
|
|
_imagePath = null;
|
|
_targetType = null;
|
|
_targetCenterX = 0.5;
|
|
_targetCenterY = 0.5;
|
|
_targetRadius = 0.4;
|
|
_targetInnerRadius = 0.04;
|
|
_ringCount = 10;
|
|
_ringRadii = null;
|
|
_imageAspectRatio = 1.0;
|
|
_shots = [];
|
|
_scoreResult = null;
|
|
_groupingResult = null;
|
|
_referenceImpacts = [];
|
|
_learnedCharacteristics = null;
|
|
_distortionCorrectionEnabled = false;
|
|
_distortionParams = null;
|
|
_correctedImagePath = null;
|
|
notifyListeners();
|
|
}
|
|
}
|