424 lines
14 KiB
Dart
424 lines
14 KiB
Dart
/// Service de correction de distorsion d'objectif.
|
|
///
|
|
/// Utilise la calibration des cercles de la cible pour calculer et appliquer
|
|
/// une transformation qui corrige la distorsion de l'objectif. L'image est
|
|
/// transformée pour que les cercles calibrés deviennent parfaitement circulaires.
|
|
library;
|
|
|
|
import 'dart:io';
|
|
import 'dart:math' as math;
|
|
import 'package:image/image.dart' as img;
|
|
import 'package:path_provider/path_provider.dart';
|
|
|
|
/// Paramètres de distorsion calculés à partir de la calibration
|
|
class DistortionParameters {
|
|
/// Ratio d'aplatissement horizontal (1.0 = pas de correction)
|
|
final double scaleX;
|
|
|
|
/// Ratio d'aplatissement vertical (1.0 = pas de correction)
|
|
final double scaleY;
|
|
|
|
/// Angle de rotation de l'axe principal (en radians)
|
|
final double rotation;
|
|
|
|
/// Centre de la distorsion en coordonnées normalisées (0-1)
|
|
final double centerX;
|
|
final double centerY;
|
|
|
|
/// Ratio de circularité détecté (1.0 = cercle parfait)
|
|
final double circularityRatio;
|
|
|
|
const DistortionParameters({
|
|
required this.scaleX,
|
|
required this.scaleY,
|
|
required this.rotation,
|
|
required this.centerX,
|
|
required this.centerY,
|
|
required this.circularityRatio,
|
|
});
|
|
|
|
/// Paramètres par défaut (pas de correction)
|
|
static const identity = DistortionParameters(
|
|
scaleX: 1.0,
|
|
scaleY: 1.0,
|
|
rotation: 0.0,
|
|
centerX: 0.5,
|
|
centerY: 0.5,
|
|
circularityRatio: 1.0,
|
|
);
|
|
|
|
/// La correction est-elle nécessaire ?
|
|
bool get needsCorrection => circularityRatio < 0.95;
|
|
|
|
@override
|
|
String toString() {
|
|
return 'DistortionParameters(scaleX: ${scaleX.toStringAsFixed(3)}, '
|
|
'scaleY: ${scaleY.toStringAsFixed(3)}, '
|
|
'rotation: ${(rotation * 180 / math.pi).toStringAsFixed(1)}°, '
|
|
'circularity: ${(circularityRatio * 100).toStringAsFixed(1)}%)';
|
|
}
|
|
}
|
|
|
|
/// Service pour détecter et corriger la distorsion d'objectif
|
|
class DistortionCorrectionService {
|
|
/// Calcule les paramètres de distorsion à partir de la calibration des cercles
|
|
///
|
|
/// [targetCenterX], [targetCenterY] : Centre de la cible calibré (0-1)
|
|
/// [targetRadius] : Rayon de la cible calibré
|
|
/// [imageAspectRatio] : Ratio largeur/hauteur de l'image
|
|
///
|
|
/// Cette méthode analyse la forme attendue (cercle) vs la forme observée
|
|
/// pour déterminer les paramètres de correction.
|
|
DistortionParameters calculateDistortionFromCalibration({
|
|
required double targetCenterX,
|
|
required double targetCenterY,
|
|
required double targetRadius,
|
|
required double imageAspectRatio,
|
|
}) {
|
|
// En théorie, si la cible est un cercle parfait et que l'utilisateur
|
|
// a calibré les anneaux pour qu'ils correspondent à ce qu'il voit,
|
|
// on peut déduire la distorsion.
|
|
|
|
// Pour l'instant, on utilise une approche simplifiée basée sur l'aspect ratio
|
|
// et la position du centre par rapport au centre de l'image.
|
|
|
|
// Calcul de l'excentricité basée sur la position du centre
|
|
final offsetX = targetCenterX - 0.5;
|
|
final offsetY = targetCenterY - 0.5;
|
|
final offsetDistance = math.sqrt(offsetX * offsetX + offsetY * offsetY);
|
|
|
|
// Plus le centre est éloigné du centre de l'image, plus la distorsion est probable
|
|
// Estimation simplifiée de la distorsion radiale
|
|
final distortionFactor = 1.0 + offsetDistance * 0.2;
|
|
|
|
// Calculer l'angle de l'axe principal de déformation
|
|
final angle = math.atan2(offsetY, offsetX);
|
|
|
|
// Si l'image n'est pas carrée, tenir compte de l'aspect ratio
|
|
double scaleX = 1.0;
|
|
double scaleY = 1.0;
|
|
|
|
if (imageAspectRatio > 1.0) {
|
|
// Image plus large que haute
|
|
scaleY = distortionFactor;
|
|
} else if (imageAspectRatio < 1.0) {
|
|
// Image plus haute que large
|
|
scaleX = distortionFactor;
|
|
}
|
|
|
|
final circularityRatio = 1.0 / distortionFactor;
|
|
|
|
return DistortionParameters(
|
|
scaleX: scaleX,
|
|
scaleY: scaleY,
|
|
rotation: angle,
|
|
centerX: targetCenterX,
|
|
centerY: targetCenterY,
|
|
circularityRatio: circularityRatio,
|
|
);
|
|
}
|
|
|
|
/// Calcule les paramètres de distorsion en comparant un cercle théorique
|
|
/// avec les points de calibration fournis par l'utilisateur
|
|
///
|
|
/// [calibrationPoints] : Points sur l'ellipse visible (coordonnées 0-1)
|
|
/// [expectedRadius] : Rayon du cercle théorique
|
|
/// [centerX], [centerY] : Centre du cercle théorique
|
|
DistortionParameters calculateDistortionFromPoints({
|
|
required List<({double x, double y})> calibrationPoints,
|
|
required double expectedRadius,
|
|
required double centerX,
|
|
required double centerY,
|
|
}) {
|
|
if (calibrationPoints.length < 4) {
|
|
return DistortionParameters.identity;
|
|
}
|
|
|
|
// Calculer les distances de chaque point au centre
|
|
final distances = <double>[];
|
|
final angles = <double>[];
|
|
|
|
for (final point in calibrationPoints) {
|
|
final dx = point.x - centerX;
|
|
final dy = point.y - centerY;
|
|
distances.add(math.sqrt(dx * dx + dy * dy));
|
|
angles.add(math.atan2(dy, dx));
|
|
}
|
|
|
|
// Trouver les axes majeur et mineur de l'ellipse
|
|
double maxDist = 0, minDist = double.infinity;
|
|
double maxAngle = 0;
|
|
|
|
for (int i = 0; i < distances.length; i++) {
|
|
if (distances[i] > maxDist) {
|
|
maxDist = distances[i];
|
|
maxAngle = angles[i];
|
|
}
|
|
if (distances[i] < minDist) {
|
|
minDist = distances[i];
|
|
}
|
|
}
|
|
|
|
// Calculer les facteurs de correction
|
|
// On veut que maxDist et minDist deviennent égaux à expectedRadius
|
|
final scaleX = expectedRadius / maxDist;
|
|
final scaleY = expectedRadius / minDist;
|
|
final circularityRatio = minDist / maxDist;
|
|
|
|
return DistortionParameters(
|
|
scaleX: scaleX.clamp(0.5, 2.0),
|
|
scaleY: scaleY.clamp(0.5, 2.0),
|
|
rotation: maxAngle,
|
|
centerX: centerX,
|
|
centerY: centerY,
|
|
circularityRatio: circularityRatio,
|
|
);
|
|
}
|
|
|
|
/// Applique la correction de distorsion à une image
|
|
///
|
|
/// [imagePath] : Chemin de l'image source
|
|
/// [params] : Paramètres de distorsion calculés
|
|
///
|
|
/// Retourne le chemin de l'image corrigée
|
|
Future<String> applyCorrection(
|
|
String imagePath,
|
|
DistortionParameters params,
|
|
) async {
|
|
final file = File(imagePath);
|
|
final bytes = await file.readAsBytes();
|
|
final image = img.decodeImage(bytes);
|
|
|
|
if (image == null) {
|
|
throw Exception('Impossible de décoder l\'image');
|
|
}
|
|
|
|
final correctedImage = _transformImage(image, params);
|
|
|
|
// Sauvegarder l'image corrigée
|
|
final tempDir = await getTemporaryDirectory();
|
|
final timestamp = DateTime.now().millisecondsSinceEpoch;
|
|
final outputPath = '${tempDir.path}/corrected_$timestamp.jpg';
|
|
|
|
final outputFile = File(outputPath);
|
|
await outputFile.writeAsBytes(img.encodeJpg(correctedImage, quality: 95));
|
|
|
|
return outputPath;
|
|
}
|
|
|
|
/// Transforme l'image pour corriger la distorsion
|
|
img.Image _transformImage(img.Image source, DistortionParameters params) {
|
|
final width = source.width;
|
|
final height = source.height;
|
|
|
|
// Créer une nouvelle image de même taille
|
|
final result = img.Image(width: width, height: height);
|
|
|
|
// Centre de transformation en pixels
|
|
final cx = params.centerX * width;
|
|
final cy = params.centerY * height;
|
|
|
|
// Précalculer cos/sin de la rotation
|
|
final cosR = math.cos(params.rotation);
|
|
final sinR = math.sin(params.rotation);
|
|
|
|
// Pour chaque pixel de l'image destination, trouver le pixel source correspondant
|
|
for (int y = 0; y < height; y++) {
|
|
for (int x = 0; x < width; x++) {
|
|
// Coordonnées relatives au centre
|
|
final dx = x - cx;
|
|
final dy = y - cy;
|
|
|
|
// Rotation inverse
|
|
final rx = dx * cosR + dy * sinR;
|
|
final ry = -dx * sinR + dy * cosR;
|
|
|
|
// Mise à l'échelle inverse (pour trouver d'où vient le pixel)
|
|
final sx = rx / params.scaleX;
|
|
final sy = ry / params.scaleY;
|
|
|
|
// Rotation dans l'autre sens
|
|
final fx = sx * cosR - sy * sinR;
|
|
final fy = sx * sinR + sy * cosR;
|
|
|
|
// Coordonnées source
|
|
final srcX = fx + cx;
|
|
final srcY = fy + cy;
|
|
|
|
// Interpolation bilinéaire
|
|
final pixel = _bilinearInterpolate(source, srcX, srcY);
|
|
result.setPixel(x, y, pixel);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// Interpolation bilinéaire pour un échantillonnage de qualité
|
|
img.Color _bilinearInterpolate(img.Image image, double x, double y) {
|
|
final x0 = x.floor();
|
|
final y0 = y.floor();
|
|
final x1 = x0 + 1;
|
|
final y1 = y0 + 1;
|
|
|
|
// Vérifier les limites
|
|
if (x0 < 0 || y0 < 0 || x1 >= image.width || y1 >= image.height) {
|
|
// Retourner le pixel le plus proche pour les zones hors limites
|
|
return image.getPixel(
|
|
x.round().clamp(0, image.width - 1),
|
|
y.round().clamp(0, image.height - 1),
|
|
);
|
|
}
|
|
|
|
// Poids pour l'interpolation
|
|
final wx = x - x0;
|
|
final wy = y - y0;
|
|
|
|
// Récupérer les 4 pixels voisins
|
|
final p00 = image.getPixel(x0, y0);
|
|
final p10 = image.getPixel(x1, y0);
|
|
final p01 = image.getPixel(x0, y1);
|
|
final p11 = image.getPixel(x1, y1);
|
|
|
|
// Interpoler chaque canal
|
|
final r = _lerp2D(p00.r.toDouble(), p10.r.toDouble(), p01.r.toDouble(), p11.r.toDouble(), wx, wy);
|
|
final g = _lerp2D(p00.g.toDouble(), p10.g.toDouble(), p01.g.toDouble(), p11.g.toDouble(), wx, wy);
|
|
final b = _lerp2D(p00.b.toDouble(), p10.b.toDouble(), p01.b.toDouble(), p11.b.toDouble(), wx, wy);
|
|
final a = _lerp2D(p00.a.toDouble(), p10.a.toDouble(), p01.a.toDouble(), p11.a.toDouble(), wx, wy);
|
|
|
|
return img.ColorRgba8(r.round().clamp(0, 255), g.round().clamp(0, 255), b.round().clamp(0, 255), a.round().clamp(0, 255));
|
|
}
|
|
|
|
/// Interpolation linéaire 2D
|
|
double _lerp2D(double v00, double v10, double v01, double v11, double wx, double wy) {
|
|
final top = v00 * (1 - wx) + v10 * wx;
|
|
final bottom = v01 * (1 - wx) + v11 * wx;
|
|
return top * (1 - wy) + bottom * wy;
|
|
}
|
|
|
|
/// Applique une correction de perspective simple basée sur 4 points
|
|
///
|
|
/// Cette méthode est utile quand la photo est prise en angle.
|
|
/// [corners] : Les 4 coins de la cible dans l'ordre (haut-gauche, haut-droite, bas-droite, bas-gauche)
|
|
Future<String> applyPerspectiveCorrection(
|
|
String imagePath,
|
|
List<({double x, double y})> corners,
|
|
) async {
|
|
if (corners.length != 4) {
|
|
throw ArgumentError('4 points de coin sont requis');
|
|
}
|
|
|
|
final file = File(imagePath);
|
|
final bytes = await file.readAsBytes();
|
|
final image = img.decodeImage(bytes);
|
|
|
|
if (image == null) {
|
|
throw Exception('Impossible de décoder l\'image');
|
|
}
|
|
|
|
final width = image.width;
|
|
final height = image.height;
|
|
|
|
// Convertir les coordonnées normalisées en pixels
|
|
final srcCorners = corners.map((c) => (x: c.x * width, y: c.y * height)).toList();
|
|
|
|
// Calculer la taille du rectangle destination
|
|
// On prend la moyenne des largeurs et hauteurs
|
|
final topWidth = _distance(srcCorners[0], srcCorners[1]);
|
|
final bottomWidth = _distance(srcCorners[3], srcCorners[2]);
|
|
final leftHeight = _distance(srcCorners[0], srcCorners[3]);
|
|
final rightHeight = _distance(srcCorners[1], srcCorners[2]);
|
|
|
|
final dstWidth = ((topWidth + bottomWidth) / 2).round();
|
|
final dstHeight = ((leftHeight + rightHeight) / 2).round();
|
|
|
|
// Créer l'image destination
|
|
final result = img.Image(width: dstWidth, height: dstHeight);
|
|
|
|
// Calculer la matrice de transformation perspective
|
|
final matrix = _computePerspectiveMatrix(
|
|
srcCorners,
|
|
[
|
|
(x: 0.0, y: 0.0),
|
|
(x: dstWidth.toDouble(), y: 0.0),
|
|
(x: dstWidth.toDouble(), y: dstHeight.toDouble()),
|
|
(x: 0.0, y: dstHeight.toDouble()),
|
|
],
|
|
);
|
|
|
|
// Appliquer la transformation
|
|
for (int y = 0; y < dstHeight; y++) {
|
|
for (int x = 0; x < dstWidth; x++) {
|
|
final src = _applyPerspectiveTransform(matrix, x.toDouble(), y.toDouble());
|
|
|
|
if (src.x >= 0 && src.x < width && src.y >= 0 && src.y < height) {
|
|
final pixel = _bilinearInterpolate(image, src.x, src.y);
|
|
result.setPixel(x, y, pixel);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Sauvegarder
|
|
final tempDir = await getTemporaryDirectory();
|
|
final timestamp = DateTime.now().millisecondsSinceEpoch;
|
|
final outputPath = '${tempDir.path}/perspective_$timestamp.jpg';
|
|
|
|
final outputFile = File(outputPath);
|
|
await outputFile.writeAsBytes(img.encodeJpg(result, quality: 95));
|
|
|
|
return outputPath;
|
|
}
|
|
|
|
double _distance(({double x, double y}) p1, ({double x, double y}) p2) {
|
|
final dx = p2.x - p1.x;
|
|
final dy = p2.y - p1.y;
|
|
return math.sqrt(dx * dx + dy * dy);
|
|
}
|
|
|
|
/// Calcule la matrice de transformation perspective (homographie)
|
|
List<double> _computePerspectiveMatrix(
|
|
List<({double x, double y})> src,
|
|
List<({double x, double y})> dst,
|
|
) {
|
|
// Résolution du système linéaire pour trouver la matrice 3x3
|
|
// Utilisation de la méthode DLT (Direct Linear Transform)
|
|
|
|
final a = List<List<double>>.generate(8, (_) => List.filled(9, 0.0));
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
final sx = src[i].x;
|
|
final sy = src[i].y;
|
|
final dx = dst[i].x;
|
|
final dy = dst[i].y;
|
|
|
|
a[i * 2] = [-sx, -sy, -1, 0, 0, 0, dx * sx, dx * sy, dx];
|
|
a[i * 2 + 1] = [0, 0, 0, -sx, -sy, -1, dy * sx, dy * sy, dy];
|
|
}
|
|
|
|
// Résolution par SVD simplifiée (on utilise une approximation)
|
|
// Pour une implémentation complète, il faudrait une vraie décomposition SVD
|
|
final h = _solveHomography(a);
|
|
|
|
return h;
|
|
}
|
|
|
|
List<double> _solveHomography(List<List<double>> a) {
|
|
// Implémentation simplifiée - normalisation et résolution
|
|
// En pratique, on devrait utiliser une vraie décomposition SVD
|
|
|
|
// Pour l'instant, retourner une matrice identité
|
|
// TODO: Implémenter une vraie résolution
|
|
return [1, 0, 0, 0, 1, 0, 0, 0, 1];
|
|
}
|
|
|
|
({double x, double y}) _applyPerspectiveTransform(List<double> h, double x, double y) {
|
|
final w = h[6] * x + h[7] * y + h[8];
|
|
if (w.abs() < 1e-10) {
|
|
return (x: x, y: y);
|
|
}
|
|
final nx = (h[0] * x + h[1] * y + h[2]) / w;
|
|
final ny = (h[3] * x + h[4] * y + h[5]) / w;
|
|
return (x: nx, y: ny);
|
|
}
|
|
}
|