bullet/impact
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases 3 Wiki Activity

test opecv échoué

Browse Source
This commit is contained in:
streaper2
2026-01-27 22:20:53 +01:00
parent f1a8eefdc3
commit 334332bc78
9 changed files with 827 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

464
lib/services/image_processing_service.dart
View File

@@ -196,10 +196,11 @@ class ImageProcessingService {
/// Analyze reference impacts to learn their characteristics
/// This actually finds the blob at each reference point and extracts its real properties
/// AMÉLIORÉ : Recherche plus large et analyse plus robuste
ImpactCharacteristics? analyzeReferenceImpacts(
String imagePath,
List<ReferenceImpact> references, {
int searchRadius = 30,
int searchRadius = 50, // Augmenté de 30 à 50
}) {
if (references.length < 2) return null;
@@ -209,10 +210,10 @@ class ImageProcessingService {
final originalImage = img.decodeImage(bytes);
if (originalImage == null) return null;
// Resize for faster processing
// Resize for faster processing - taille augmentée
img.Image image;
double scale = 1.0;
final maxDimension = 1000;
final maxDimension = 1200; // Augmenté pour plus de précision
if (originalImage.width > maxDimension || originalImage.height > maxDimension) {
scale = maxDimension / math.max(originalImage.width, originalImage.height);
image = img.copyResize(
@@ -235,45 +236,67 @@ class ImageProcessingService {
final fillRatios = <double>[];
final thresholds = <double>[];
for (final ref in references) {
print('Analyzing ${references.length} reference impacts...');
for (int refIndex = 0; refIndex < references.length; refIndex++) {
final ref = references[refIndex];
final centerX = (ref.x * width).round().clamp(0, width - 1);
final centerY = (ref.y * height).round().clamp(0, height - 1);
// Find the darkest point in the search area (the center of the impact)
print('Reference $refIndex at ($centerX, $centerY)');
// AMÉLIORATION : Recherche du point le plus sombre dans une zone plus large
int darkestX = centerX;
int darkestY = centerY;
double darkestLum = 255;
for (int dy = -searchRadius; dy <= searchRadius; dy++) {
for (int dx = -searchRadius; dx <= searchRadius; dx++) {
final px = centerX + dx;
final py = centerY + dy;
if (px < 0 || px >= width || py < 0 || py >= height) continue;
// Recherche en spirale du point le plus sombre
for (int r = 0; r <= searchRadius; r++) {
for (int dy = -r; dy <= r; dy++) {
for (int dx = -r; dx <= r; dx++) {
// Seulement le périmètre du carré pour éviter les doublons
if (r > 0 && math.max(dx.abs(), dy.abs()) < r) continue;
final pixel = blurred.getPixel(px, py);
final lum = img.getLuminance(pixel).toDouble();
if (lum < darkestLum) {
darkestLum = lum;
darkestX = px;
darkestY = py;
final px = centerX + dx;
final py = centerY + dy;
if (px < 0 || px >= width || py < 0 || py >= height) continue;
final pixel = blurred.getPixel(px, py);
final lum = img.getLuminance(pixel).toDouble();
if (lum < darkestLum) {
darkestLum = lum;
darkestX = px;
darkestY = py;
}
}
}
// Si on a trouvé un point très sombre, on peut s'arrêter
if (darkestLum < 50 && r > 5) break;
}
print(' Darkest point at ($darkestX, $darkestY), lum=$darkestLum');
// Now find the blob at the darkest point using adaptive threshold
// Start from the darkest point and expand until we find the boundary
final blobResult = _findBlobAtPoint(blurred, darkestX, darkestY, width, height);
if (blobResult != null) {
if (blobResult != null && blobResult.size >= 10) { // Au moins 10 pixels
luminances.add(blobResult.avgLuminance);
sizes.add(blobResult.size.toDouble());
circularities.add(blobResult.circularity);
fillRatios.add(blobResult.fillRatio);
thresholds.add(blobResult.threshold);
print(' Found blob: size=${blobResult.size}, circ=${blobResult.circularity.toStringAsFixed(2)}, '
'fill=${blobResult.fillRatio.toStringAsFixed(2)}, threshold=${blobResult.threshold.toStringAsFixed(0)}');
} else {
print(' No valid blob found at this reference');
}
}
if (luminances.isEmpty) return null;
if (luminances.isEmpty) {
print('ERROR: No valid blobs found from any reference!');
return null;
}
// Calculate statistics
final avgLum = luminances.reduce((a, b) => a + b) / luminances.length;
@@ -290,17 +313,25 @@ class ImageProcessingService {
sizeVariance += math.pow(sizes[i] - avgSize, 2);
}
final lumStdDev = math.sqrt(lumVariance / luminances.length);
final sizeStdDev = math.sqrt(sizeVariance / sizes.length);
// AMÉLIORATION : Écart-type minimum pour éviter des plages trop étroites
final sizeStdDev = math.max(
math.sqrt(sizeVariance / sizes.length),
avgSize * 0.3, // Au moins 30% de variance
);
return ImpactCharacteristics(
final result = ImpactCharacteristics(
avgLuminance: avgLum,
luminanceStdDev: lumStdDev,
luminanceStdDev: math.max(lumStdDev, 10), // Minimum 10 de variance
avgSize: avgSize,
sizeStdDev: sizeStdDev,
avgCircularity: avgCirc,
avgFillRatio: avgFill,
avgDarkThreshold: avgThreshold,
);
print('Learned characteristics: $result');
return result;
} catch (e) {
print('Error analyzing reference impacts: $e');
return null;
@@ -308,25 +339,30 @@ class ImageProcessingService {
}
/// Find a blob at a specific point and extract its characteristics
/// AMÉLIORÉ : Utilise plusieurs méthodes de détection et retourne le meilleur résultat
_BlobAnalysis? _findBlobAtPoint(img.Image image, int startX, int startY, int width, int height) {
// Get the luminance at the center point
final centerPixel = image.getPixel(startX, startY);
final centerLum = img.getLuminance(centerPixel).toDouble();
// Find the threshold by looking at the luminance gradient around the point
// Sample in expanding circles to find where the blob ends
// MÉTHODE 1 : Expansion radiale pour trouver le bord
double sumLum = centerLum;
int pixelCount = 1;
double maxRadius = 0;
// Sample at different radii to find the edge
for (int r = 1; r <= 50; r++) {
// Collecter les luminances à différents rayons pour une analyse plus robuste
final radialLuminances = <double>[];
// Sample at different radii to find the edge - LIMITE RAISONNABLE pour impacts de balle
final maxSearchRadius = 60; // Un impact de balle ne fait pas plus de 60 pixels de rayon
for (int r = 1; r <= maxSearchRadius; r++) {
double ringSum = 0;
int ringCount = 0;
// Sample points on a ring
for (int i = 0; i < 16; i++) {
final angle = (i / 16) * 2 * math.pi;
final numSamples = math.max(12, r ~/ 2);
for (int i = 0; i < numSamples; i++) {
final angle = (i / numSamples) * 2 * math.pi;
final px = startX + (r * math.cos(angle)).round();
final py = startY + (r * math.sin(angle)).round();
if (px < 0 || px >= width || py < 0 || py >= height) continue;
@@ -339,20 +375,47 @@ class ImageProcessingService {
if (ringCount > 0) {
final avgRingLum = ringSum / ringCount;
// If the ring is significantly brighter than the center, we've found the edge
if (avgRingLum > centerLum + 40) {
radialLuminances.add(avgRingLum);
// Détection du bord : gradient de luminosité significatif
// Seuil adaptatif basé sur la différence avec le centre
final luminanceDiff = avgRingLum - centerLum;
// Le bord est trouvé quand on a une augmentation significative de luminosité
if (luminanceDiff > 30 && maxRadius == 0) {
maxRadius = r.toDouble();
break;
break; // Arrêter dès qu'on trouve le bord
}
if (maxRadius == 0) {
sumLum += ringSum;
pixelCount += ringCount;
}
sumLum += ringSum;
pixelCount += ringCount;
}
}
if (maxRadius < 3) return null; // Too small to be a valid blob
// Si aucun bord trouvé, chercher le gradient maximum
if (maxRadius < 2 && radialLuminances.length > 3) {
double maxGradient = 0;
int maxGradientIndex = 0;
for (int i = 1; i < radialLuminances.length; i++) {
final gradient = radialLuminances[i] - radialLuminances[i - 1];
if (gradient > maxGradient) {
maxGradient = gradient;
maxGradientIndex = i;
}
}
if (maxGradient > 10) {
maxRadius = (maxGradientIndex + 1).toDouble();
}
}
// Calculate threshold as the midpoint between center and edge luminance
final edgeRadius = (maxRadius * 1.2).round();
// Rayon minimum de 3 pixels, maximum de 50 pour un impact de balle
if (maxRadius < 3) maxRadius = 3;
if (maxRadius > 50) maxRadius = 50;
// Calculate threshold as weighted average between center and edge luminance
final edgeRadius = math.min((maxRadius * 1.2).round(), maxSearchRadius - 1);
double edgeLum = 0;
int edgeCount = 0;
for (int i = 0; i < 16; i++) {
@@ -366,62 +429,94 @@ class ImageProcessingService {
}
if (edgeCount > 0) {
edgeLum /= edgeCount;
} else {
edgeLum = centerLum + 50;
}
final threshold = ((centerLum + edgeLum) / 2).round();
// Calculer le seuil optimal
final threshold = ((centerLum + edgeLum) / 2).round().clamp(20, 200);
// Now do a flood fill with this threshold to get the actual blob
final mask = List.generate(height, (_) => List.filled(width, false));
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
final pixel = image.getPixel(x, y);
// Utiliser une zone de recherche locale limitée autour du point
final analysis = _tryFindBlobWithThresholdLocal(
image, startX, startY, width, height, threshold, sumLum / pixelCount,
maxRadius.round() + 10, // Zone de recherche légèrement plus grande que le rayon détecté
);
return analysis;
}
/// Trouve un blob avec un seuil dans une zone locale limitée
_BlobAnalysis? _tryFindBlobWithThresholdLocal(
img.Image image,
int startX,
int startY,
int width,
int height,
int threshold,
double avgLuminance,
int maxSearchRadius,
) {
// Limiter la zone de recherche
final minX = math.max(0, startX - maxSearchRadius);
final maxX = math.min(width - 1, startX + maxSearchRadius);
final minY = math.max(0, startY - maxSearchRadius);
final maxY = math.min(height - 1, startY + maxSearchRadius);
final localWidth = maxX - minX + 1;
final localHeight = maxY - minY + 1;
// Create binary mask ONLY for the local region
final mask = List.generate(localHeight, (_) => List.filled(localWidth, false));
for (int y = 0; y < localHeight; y++) {
for (int x = 0; x < localWidth; x++) {
final globalX = minX + x;
final globalY = minY + y;
final pixel = image.getPixel(globalX, globalY);
final lum = img.getLuminance(pixel);
mask[y][x] = lum < threshold;
}
}
final visited = List.generate(height, (_) => List.filled(width, false));
final visited = List.generate(localHeight, (_) => List.filled(localWidth, false));
// Find the blob containing the start point
if (!mask[startY][startX]) {
// Find the blob containing the start point (in local coordinates)
final localStartX = startX - minX;
final localStartY = startY - minY;
int searchX = localStartX;
int searchY = localStartY;
if (!mask[localStartY][localStartX]) {
// Start point might not be in mask, find nearest point that is
for (int r = 1; r <= 10; r++) {
bool found = false;
bool found = false;
for (int r = 1; r <= 15 && !found; r++) {
for (int dy = -r; dy <= r && !found; dy++) {
for (int dx = -r; dx <= r && !found; dx++) {
final px = startX + dx;
final py = startY + dy;
if (px >= 0 && px < width && py >= 0 && py < height && mask[py][px]) {
final blob = _floodFill(mask, visited, px, py, width, height);
// Calculate fill ratio: actual pixels / bounding circle area
final boundingRadius = math.max(blob.radius, 1);
final boundingCircleArea = math.pi * boundingRadius * boundingRadius;
final fillRatio = (blob.size / boundingCircleArea).clamp(0.0, 1.0);
return _BlobAnalysis(
avgLuminance: sumLum / pixelCount,
size: blob.size,
circularity: blob.circularity,
fillRatio: fillRatio,
threshold: threshold.toDouble(),
);
final px = localStartX + dx;
final py = localStartY + dy;
if (px >= 0 && px < localWidth && py >= 0 && py < localHeight && mask[py][px]) {
searchX = px;
searchY = py;
found = true;
}
}
}
}
return null;
if (!found) return null;
}
final blob = _floodFill(mask, visited, startX, startY, width, height);
final blob = _floodFillLocal(mask, visited, searchX, searchY, localWidth, localHeight);
// Calculate fill ratio
// Vérifier que le blob est valide - taille raisonnable pour un impact
if (blob.size < 10 || blob.size > 5000) return null; // Entre 10 et 5000 pixels
// Calculate fill ratio: actual pixels / bounding circle area
final boundingRadius = math.max(blob.radius, 1);
final boundingCircleArea = math.pi * boundingRadius * boundingRadius;
final fillRatio = (blob.size / boundingCircleArea).clamp(0.0, 1.0);
return _BlobAnalysis(
avgLuminance: sumLum / pixelCount,
avgLuminance: avgLuminance,
size: blob.size,
circularity: blob.circularity,
fillRatio: fillRatio,
@@ -429,12 +524,110 @@ class ImageProcessingService {
);
}
/// Flood fill pour une zone locale
_Blob _floodFillLocal(
List<List<bool>> mask,
List<List<bool>> visited,
int startX,
int startY,
int width,
int height,
) {
final stack = <_Point>[_Point(startX, startY)];
final points = <_Point>[];
int minX = startX, maxX = startX;
int minY = startY, maxY = startY;
int perimeterCount = 0;
while (stack.isNotEmpty) {
final point = stack.removeLast();
final x = point.x;
final y = point.y;
if (x < 0 || x >= width || y < 0 || y >= height) continue;
if (visited[y][x] || !mask[y][x]) continue;
visited[y][x] = true;
points.add(point);
minX = math.min(minX, x);
maxX = math.max(maxX, x);
minY = math.min(minY, y);
maxY = math.max(maxY, y);
// Check if this is a perimeter pixel
bool isPerimeter = false;
for (final delta in [[-1, 0], [1, 0], [0, -1], [0, 1]]) {
final nx = x + delta[0];
final ny = y + delta[1];
if (nx < 0 || nx >= width || ny < 0 || ny >= height || !mask[ny][nx]) {
isPerimeter = true;
break;
}
}
if (isPerimeter) perimeterCount++;
// Add neighbors (4-connectivity)
stack.add(_Point(x + 1, y));
stack.add(_Point(x - 1, y));
stack.add(_Point(x, y + 1));
stack.add(_Point(x, y - 1));
}
// Calculate centroid
double sumX = 0, sumY = 0;
for (final p in points) {
sumX += p.x;
sumY += p.y;
}
final centerX = points.isNotEmpty ? sumX / points.length : startX.toDouble();
final centerY = points.isNotEmpty ? sumY / points.length : startY.toDouble();
// Calculate bounding box dimensions
final blobWidth = (maxX - minX + 1).toDouble();
final blobHeight = (maxY - minY + 1).toDouble();
// Calculate approximate radius based on bounding box
final radius = math.max(blobWidth, blobHeight) / 2.0;
// Calculate circularity
final area = points.length.toDouble();
final perimeter = perimeterCount.toDouble();
final circularity = perimeter > 0
? (4 * math.pi * area) / (perimeter * perimeter)
: 0.0;
// Calculate aspect ratio
final aspectRatio = blobWidth > blobHeight
? blobWidth / blobHeight
: blobHeight / blobWidth;
// Calculate fill ratio
final boundingCircleArea = math.pi * radius * radius;
final fillRatio = boundingCircleArea > 0 ? (area / boundingCircleArea).clamp(0.0, 1.0) : 0.0;
return _Blob(
x: centerX,
y: centerY,
radius: radius,
size: points.length,
circularity: circularity.clamp(0.0, 1.0),
aspectRatio: aspectRatio,
fillRatio: fillRatio,
);
}
/// Detect impacts based on reference characteristics with tolerance
///
/// Utilise une approche multi-seuils adaptative pour une meilleure détection
List<DetectedImpact> detectImpactsFromReferences(
String imagePath,
ImpactCharacteristics characteristics, {
double tolerance = 2.0, // Number of standard deviations
double minCircularity = 0.4,
double minCircularity = 0.3,
}) {
try {
final file = File(imagePath);
@@ -445,7 +638,7 @@ class ImageProcessingService {
// Resize for faster processing
img.Image image;
double scale = 1.0;
final maxDimension = 1000;
final maxDimension = 1200; // Augmenté pour plus de précision
if (originalImage.width > maxDimension || originalImage.height > maxDimension) {
scale = maxDimension / math.max(originalImage.width, originalImage.height);
image = img.copyResize(
@@ -460,36 +653,83 @@ class ImageProcessingService {
final grayscale = img.grayscale(image);
final blurred = img.gaussianBlur(grayscale, radius: 2);
// Use the threshold learned from references
final threshold = characteristics.avgDarkThreshold.round();
// AMÉLIORATION : Utiliser plusieurs seuils autour du seuil appris
final baseThreshold = characteristics.avgDarkThreshold.round();
// Générer une plage de seuils plus ciblée
final thresholds = <int>[];
final thresholdRange = (15 * tolerance).round(); // Plage modérée
for (int offset = -thresholdRange; offset <= thresholdRange; offset += 8) {
final t = (baseThreshold + offset).clamp(30, 150);
if (!thresholds.contains(t)) thresholds.add(t);
}
// Calculate size range based on learned characteristics
final minSize = (characteristics.avgSize / (tolerance * 2)).clamp(5, 10000).round();
final maxSize = (characteristics.avgSize * tolerance * 2).clamp(10, 10000).round();
// Utiliser la variance mais avec des limites raisonnables
final sizeVariance = math.max(characteristics.sizeStdDev * tolerance, characteristics.avgSize * 0.4);
final minSize = math.max(20, (characteristics.avgSize - sizeVariance).round()); // Minimum 20 pixels
final maxSize = math.min(3000, (characteristics.avgSize + sizeVariance * 2).round()); // Maximum 3000 pixels
// Calculate minimum fill ratio based on learned characteristics
// Allow some variance but still filter out hollow shapes
final minFillRatio = (characteristics.avgFillRatio - 0.2).clamp(0.3, 0.9);
// Calculate minimum circularity - équilibré
final circularityTolerance = 0.2 * tolerance;
final effectiveMinCircularity = math.max(
characteristics.avgCircularity - circularityTolerance,
minCircularity,
).clamp(0.35, 0.85);
// Detect blobs using the learned threshold
final impacts = _detectDarkSpots(
blurred,
threshold,
minSize,
maxSize,
minCircularity: math.max(characteristics.avgCircularity - 0.2, minCircularity),
minFillRatio: minFillRatio,
);
// Calculate minimum fill ratio - impacts pleins
final minFillRatio = (characteristics.avgFillRatio - 0.2).clamp(0.35, 0.85);
print('Detection params: thresholds=$thresholds, size=$minSize-$maxSize, '
'circ>=$effectiveMinCircularity, fill>=$minFillRatio');
// Détecter avec plusieurs seuils et combiner les résultats
final allBlobs = <_Blob>[];
for (final threshold in thresholds) {
final blobs = _detectDarkSpots(
blurred,
threshold,
minSize,
maxSize,
minCircularity: effectiveMinCircularity,
maxAspectRatio: 2.5, // Plus permissif
minFillRatio: minFillRatio,
);
allBlobs.addAll(blobs);
}
// Fusionner les blobs qui se chevauchent (même impact détecté à différents seuils)
final mergedBlobs = _mergeOverlappingBlobs(allBlobs);
// FILTRE POST-DÉTECTION : Garder seulement les blobs similaires aux références
// Le filtre est plus ou moins strict selon la tolérance
final sizeToleranceFactor = 0.3 + (tolerance - 1) * 0.3; // 0.3 à 1.5 selon tolérance
final minSizeRatio = math.max(0.15, 1 / (1 + sizeToleranceFactor * 3));
final maxSizeRatio = 1 + sizeToleranceFactor * 4;
final filteredBlobs = mergedBlobs.where((blob) {
// Vérifier la taille par rapport aux caractéristiques apprises
final sizeRatio = blob.size / characteristics.avgSize;
if (sizeRatio < minSizeRatio || sizeRatio > maxSizeRatio) return false;
// Vérifier la circularité (légèrement relaxée)
if (blob.circularity < effectiveMinCircularity * 0.85) return false;
// Vérifier le fill ratio
if (blob.fillRatio < minFillRatio * 0.9) return false;
return true;
}).toList();
print('Found ${filteredBlobs.length} impacts after filtering (from ${mergedBlobs.length} merged)');
// Convert to relative coordinates
final width = originalImage.width.toDouble();
final height = originalImage.height.toDouble();
return impacts.map((impact) {
return filteredBlobs.map((blob) {
return DetectedImpact(
x: impact.x / image.width,
y: impact.y / image.height,
radius: impact.radius / scale,
x: blob.x / image.width,
y: blob.y / image.height,
radius: blob.radius / scale,
);
}).toList();
} catch (e) {
@@ -498,6 +738,44 @@ class ImageProcessingService {
}
}
/// Fusionne les blobs qui se chevauchent en gardant le meilleur représentant
List<_Blob> _mergeOverlappingBlobs(List<_Blob> blobs) {
if (blobs.isEmpty) return [];
// Trier par score de qualité (circularité * fillRatio)
final sortedBlobs = List<_Blob>.from(blobs);
sortedBlobs.sort((a, b) {
final scoreA = a.circularity * a.fillRatio * a.size;
final scoreB = b.circularity * b.fillRatio * b.size;
return scoreB.compareTo(scoreA);
});
final merged = <_Blob>[];
for (final blob in sortedBlobs) {
bool shouldAdd = true;
for (final existing in merged) {
final dx = blob.x - existing.x;
final dy = blob.y - existing.y;
final distance = math.sqrt(dx * dx + dy * dy);
final minDist = math.min(blob.radius, existing.radius);
// Si les centres sont proches, c'est le même impact
if (distance < minDist * 1.5) {
shouldAdd = false;
break;
}
}
if (shouldAdd) {
merged.add(blob);
}
}
return merged;
}
/// Detect dark spots with adaptive luminance range
List<_Blob> _detectDarkSpotsAdaptive(
img.Image image,