preparation du modele yolo
This commit is contained in:
@@ -676,4 +676,399 @@ class DistortionCorrectionService {
|
||||
points[2] = br;
|
||||
points[3] = bl;
|
||||
}
|
||||
|
||||
/// Corrige la perspective en reformant le plus grand ovale (ellipse) en un cercle parfait,
|
||||
/// sans recadrer agressivement l'image entière.
|
||||
Future<String> correctPerspectiveUsingOvals(String imagePath) async {
|
||||
try {
|
||||
final src = cv.imread(imagePath, flags: cv.IMREAD_COLOR);
|
||||
if (src.isEmpty) throw Exception("Impossible de charger l'image");
|
||||
|
||||
final gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY);
|
||||
final blurred = cv.gaussianBlur(gray, (5, 5), 0);
|
||||
|
||||
final thresh = cv.threshold(
|
||||
blurred,
|
||||
0,
|
||||
255,
|
||||
cv.THRESH_BINARY | cv.THRESH_OTSU,
|
||||
);
|
||||
final edges = cv.canny(blurred, thresh.$1 * 0.5, thresh.$1);
|
||||
|
||||
final contoursResult = cv.findContours(
|
||||
edges,
|
||||
cv.RETR_EXTERNAL,
|
||||
cv.CHAIN_APPROX_SIMPLE,
|
||||
);
|
||||
final contours = contoursResult.$1;
|
||||
|
||||
if (contours.isEmpty) return imagePath;
|
||||
|
||||
cv.RotatedRect? bestEllipse;
|
||||
double maxArea = 0;
|
||||
|
||||
for (final contour in contours) {
|
||||
if (contour.length < 5) continue;
|
||||
final area = cv.contourArea(contour);
|
||||
if (area < 1000) continue;
|
||||
|
||||
final ellipse = cv.fitEllipse(contour);
|
||||
if (area > maxArea) {
|
||||
maxArea = area;
|
||||
bestEllipse = ellipse;
|
||||
}
|
||||
}
|
||||
|
||||
if (bestEllipse == null) return imagePath;
|
||||
|
||||
// The goal here is to morph the bestEllipse into a perfect circle, while
|
||||
// keeping the image the same size and the center of the ellipse in the same place.
|
||||
// We'll use the average of the width and height (or max) to define the target circle
|
||||
final targetRadius =
|
||||
math.max(bestEllipse.size.width, bestEllipse.size.height) / 2.0;
|
||||
|
||||
// Extract the 4 bounding box points of the ellipse
|
||||
final boxPoints = cv.boxPoints(bestEllipse);
|
||||
final List<cv.Point> srcPoints = [];
|
||||
for (int i = 0; i < boxPoints.length; i++) {
|
||||
srcPoints.add(cv.Point(boxPoints[i].x.toInt(), boxPoints[i].y.toInt()));
|
||||
}
|
||||
_sortPoints(srcPoints);
|
||||
|
||||
// Calculate the size of the perfectly squared output image
|
||||
final int side = (targetRadius * 2).toInt();
|
||||
|
||||
final List<cv.Point> dstPoints = [
|
||||
cv.Point(0, 0), // Top-Left
|
||||
cv.Point(side, 0), // Top-Right
|
||||
cv.Point(side, side), // Bottom-Right
|
||||
cv.Point(0, side), // Bottom-Left
|
||||
];
|
||||
|
||||
// Morph the target region into a perfect square, cropping the rest of the image
|
||||
final M = cv.getPerspectiveTransform(
|
||||
cv.VecPoint.fromList(srcPoints),
|
||||
cv.VecPoint.fromList(dstPoints),
|
||||
);
|
||||
|
||||
final corrected = cv.warpPerspective(src, M, (side, side));
|
||||
|
||||
final tempDir = await getTemporaryDirectory();
|
||||
final timestamp = DateTime.now().millisecondsSinceEpoch;
|
||||
final outputPath = '${tempDir.path}/corrected_oval_$timestamp.jpg';
|
||||
|
||||
cv.imwrite(outputPath, corrected);
|
||||
|
||||
return outputPath;
|
||||
} catch (e) {
|
||||
print('Erreur correction perspective ovales: $e');
|
||||
return imagePath;
|
||||
}
|
||||
}
|
||||
|
||||
/// Corrige la distorsion et la profondeur (perspective) en créant un maillage
|
||||
/// basé sur la concentricité des différents cercles de la cible pour trouver le meilleur plan.
|
||||
Future<String> correctPerspectiveWithConcentricMesh(String imagePath) async {
|
||||
try {
|
||||
final src = cv.imread(imagePath, flags: cv.IMREAD_COLOR);
|
||||
if (src.isEmpty) throw Exception("Impossible de charger l'image");
|
||||
|
||||
final gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY);
|
||||
final blurred = cv.gaussianBlur(gray, (5, 5), 0);
|
||||
final thresh = cv.threshold(
|
||||
blurred,
|
||||
0,
|
||||
255,
|
||||
cv.THRESH_BINARY | cv.THRESH_OTSU,
|
||||
);
|
||||
final edges = cv.canny(blurred, thresh.$1 * 0.5, thresh.$1);
|
||||
|
||||
final contoursResult = cv.findContours(
|
||||
edges,
|
||||
cv.RETR_LIST,
|
||||
cv.CHAIN_APPROX_SIMPLE,
|
||||
);
|
||||
final contours = contoursResult.$1;
|
||||
if (contours.isEmpty) return imagePath;
|
||||
|
||||
List<cv.RotatedRect> ellipses = [];
|
||||
for (final contour in contours) {
|
||||
if (contour.length < 5) continue;
|
||||
if (cv.contourArea(contour) < 500) continue;
|
||||
ellipses.add(cv.fitEllipse(contour));
|
||||
}
|
||||
|
||||
if (ellipses.isEmpty) return imagePath;
|
||||
|
||||
// Find the largest ellipse to serve as our central reference
|
||||
ellipses.sort(
|
||||
(a, b) => (b.size.width * b.size.height).compareTo(
|
||||
a.size.width * a.size.height,
|
||||
),
|
||||
);
|
||||
final largestEllipse = ellipses.first;
|
||||
final maxDist =
|
||||
math.max(largestEllipse.size.width, largestEllipse.size.height) *
|
||||
0.15;
|
||||
|
||||
// Group all ellipses that are roughly concentric with the largest one
|
||||
List<cv.RotatedRect> concentricGroup = [];
|
||||
for (final e in ellipses) {
|
||||
final dx = e.center.x - largestEllipse.center.x;
|
||||
final dy = e.center.y - largestEllipse.center.y;
|
||||
if (math.sqrt(dx * dx + dy * dy) < maxDist) {
|
||||
concentricGroup.add(e);
|
||||
}
|
||||
}
|
||||
|
||||
if (concentricGroup.length < 2) {
|
||||
print(
|
||||
"Pas assez de cercles concentriques pour le maillage, utilisation de la méthode simple.",
|
||||
);
|
||||
return await correctPerspectiveUsingOvals(imagePath);
|
||||
}
|
||||
|
||||
final targetRadius =
|
||||
math.max(largestEllipse.size.width, largestEllipse.size.height) / 2.0;
|
||||
final int side = (targetRadius * 2.4).toInt(); // Add padding
|
||||
final double cx = side / 2.0;
|
||||
final double cy = side / 2.0;
|
||||
|
||||
List<cv.Point2f> srcPointsList = [];
|
||||
List<cv.Point2f> dstPointsList = [];
|
||||
|
||||
for (final ellipse in concentricGroup) {
|
||||
final box = cv.boxPoints(ellipse);
|
||||
final m0 = cv.Point2f(
|
||||
(box[0].x + box[1].x) / 2,
|
||||
(box[0].y + box[1].y) / 2,
|
||||
);
|
||||
final m1 = cv.Point2f(
|
||||
(box[1].x + box[2].x) / 2,
|
||||
(box[1].y + box[2].y) / 2,
|
||||
);
|
||||
final m2 = cv.Point2f(
|
||||
(box[2].x + box[3].x) / 2,
|
||||
(box[2].y + box[3].y) / 2,
|
||||
);
|
||||
final m3 = cv.Point2f(
|
||||
(box[3].x + box[0].x) / 2,
|
||||
(box[3].y + box[0].y) / 2,
|
||||
);
|
||||
|
||||
final d02 = math.sqrt(
|
||||
math.pow(m0.x - m2.x, 2) + math.pow(m0.y - m2.y, 2),
|
||||
);
|
||||
final d13 = math.sqrt(
|
||||
math.pow(m1.x - m3.x, 2) + math.pow(m1.y - m3.y, 2),
|
||||
);
|
||||
|
||||
cv.Point2f maj1, maj2, min1, min2;
|
||||
double r;
|
||||
|
||||
if (d02 > d13) {
|
||||
maj1 = m0;
|
||||
maj2 = m2;
|
||||
min1 = m1;
|
||||
min2 = m3;
|
||||
r = d02 / 2.0;
|
||||
} else {
|
||||
maj1 = m1;
|
||||
maj2 = m3;
|
||||
min1 = m0;
|
||||
min2 = m2;
|
||||
r = d13 / 2.0;
|
||||
}
|
||||
|
||||
// Sort maj1 and maj2 so maj1 is left/top
|
||||
if ((maj1.x - maj2.x).abs() > (maj1.y - maj2.y).abs()) {
|
||||
if (maj1.x > maj2.x) {
|
||||
final t = maj1;
|
||||
maj1 = maj2;
|
||||
maj2 = t;
|
||||
}
|
||||
} else {
|
||||
if (maj1.y > maj2.y) {
|
||||
final t = maj1;
|
||||
maj1 = maj2;
|
||||
maj2 = t;
|
||||
}
|
||||
}
|
||||
|
||||
// Sort min1 and min2 so min1 is top/left
|
||||
if ((min1.y - min2.y).abs() > (min1.x - min2.x).abs()) {
|
||||
if (min1.y > min2.y) {
|
||||
final t = min1;
|
||||
min1 = min2;
|
||||
min2 = t;
|
||||
}
|
||||
} else {
|
||||
if (min1.x > min2.x) {
|
||||
final t = min1;
|
||||
min1 = min2;
|
||||
min2 = t;
|
||||
}
|
||||
}
|
||||
|
||||
srcPointsList.addAll([maj1, maj2, min1, min2]);
|
||||
dstPointsList.addAll([
|
||||
cv.Point2f(cx - r, cy),
|
||||
cv.Point2f(cx + r, cy),
|
||||
cv.Point2f(cx, cy - r),
|
||||
cv.Point2f(cx, cy + r),
|
||||
]);
|
||||
|
||||
// Add ellipse centers mapping perfectly to the origin to force concentric depth alignment
|
||||
srcPointsList.add(cv.Point2f(ellipse.center.x, ellipse.center.y));
|
||||
dstPointsList.add(cv.Point2f(cx, cy));
|
||||
}
|
||||
|
||||
// We explicitly convert points to VecPoint to use findHomography standard binding
|
||||
final srcVec = cv.VecPoint.fromList(
|
||||
srcPointsList.map((p) => cv.Point(p.x.toInt(), p.y.toInt())).toList(),
|
||||
);
|
||||
final dstVec = cv.VecPoint.fromList(
|
||||
dstPointsList.map((p) => cv.Point(p.x.toInt(), p.y.toInt())).toList(),
|
||||
);
|
||||
|
||||
final M = cv.findHomography(
|
||||
cv.Mat.fromVec(srcVec),
|
||||
cv.Mat.fromVec(dstVec),
|
||||
method: cv.RANSAC,
|
||||
);
|
||||
|
||||
if (M.isEmpty) {
|
||||
return await correctPerspectiveUsingOvals(imagePath);
|
||||
}
|
||||
|
||||
final corrected = cv.warpPerspective(src, M, (side, side));
|
||||
|
||||
final tempDir = await getTemporaryDirectory();
|
||||
final timestamp = DateTime.now().millisecondsSinceEpoch;
|
||||
final outputPath = '${tempDir.path}/corrected_mesh_$timestamp.jpg';
|
||||
cv.imwrite(outputPath, corrected);
|
||||
|
||||
return outputPath;
|
||||
} catch (e) {
|
||||
print('Erreur correction perspective maillage concentrique: $e');
|
||||
return imagePath;
|
||||
}
|
||||
}
|
||||
|
||||
/// Corrige la perspective en détectant les 4 coins de la feuille (quadrilatère)
|
||||
///
|
||||
/// Cette méthode cherche le plus grand polygone à 4 côtés (le bord du papier)
|
||||
/// et le déforme pour en faire un carré parfait.
|
||||
Future<String> correctPerspectiveUsingQuadrilateral(String imagePath) async {
|
||||
try {
|
||||
final src = cv.imread(imagePath, flags: cv.IMREAD_COLOR);
|
||||
if (src.isEmpty) throw Exception("Impossible de charger l'image");
|
||||
|
||||
final gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY);
|
||||
// Flou plus important pour ignorer les détails internes (cercles, trous)
|
||||
final blurred = cv.gaussianBlur(gray, (9, 9), 0);
|
||||
|
||||
// Canny edge detector
|
||||
final thresh = cv.threshold(
|
||||
blurred,
|
||||
0,
|
||||
255,
|
||||
cv.THRESH_BINARY | cv.THRESH_OTSU,
|
||||
);
|
||||
final edges = cv.canny(blurred, thresh.$1 * 0.5, thresh.$1);
|
||||
|
||||
// Pour la détection de la feuille (les bords peuvent être discontinus à cause de l'éclairage)
|
||||
final kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5));
|
||||
final closedEdges = cv.morphologyEx(edges, cv.MORPH_CLOSE, kernel);
|
||||
|
||||
// Find contours
|
||||
final contoursResult = cv.findContours(
|
||||
closedEdges,
|
||||
cv.RETR_EXTERNAL,
|
||||
cv.CHAIN_APPROX_SIMPLE,
|
||||
);
|
||||
final contours = contoursResult.$1;
|
||||
|
||||
cv.VecPoint? bestQuad;
|
||||
double maxArea = 0;
|
||||
|
||||
final minArea = src.rows * src.cols * 0.1; // Au moins 10% de l'image
|
||||
|
||||
for (final contour in contours) {
|
||||
final area = cv.contourArea(contour);
|
||||
if (area < minArea) continue;
|
||||
|
||||
final peri = cv.arcLength(contour, true);
|
||||
// Approximation polygonale (tolérance = 2% à 5% du périmètre)
|
||||
final approx = cv.approxPolyDP(contour, 0.04 * peri, true);
|
||||
|
||||
if (approx.length == 4) {
|
||||
if (area > maxArea) {
|
||||
maxArea = area;
|
||||
bestQuad = approx;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback
|
||||
if (bestQuad == null) {
|
||||
print(
|
||||
"Aucun papier quadrilatère détecté, on utilise les cercles à la place.",
|
||||
);
|
||||
return await correctPerspectiveUsingCircles(imagePath);
|
||||
}
|
||||
|
||||
// Convert to List<cv.Point>
|
||||
final List<cv.Point> srcPoints = [];
|
||||
for (int i = 0; i < bestQuad.length; i++) {
|
||||
srcPoints.add(bestQuad[i]);
|
||||
}
|
||||
|
||||
_sortPoints(srcPoints);
|
||||
|
||||
// Calculate max width and height
|
||||
double widthA = _distanceCV(srcPoints[2], srcPoints[3]);
|
||||
double widthB = _distanceCV(srcPoints[1], srcPoints[0]);
|
||||
int dstWidth = math.max(widthA, widthB).toInt();
|
||||
|
||||
double heightA = _distanceCV(srcPoints[1], srcPoints[2]);
|
||||
double heightB = _distanceCV(srcPoints[0], srcPoints[3]);
|
||||
int dstHeight = math.max(heightA, heightB).toInt();
|
||||
|
||||
// Since standard target paper forms a square, we force the resulting warp to be a perfect square.
|
||||
int side = math.max(dstWidth, dstHeight);
|
||||
|
||||
final List<cv.Point> dstPoints = [
|
||||
cv.Point(0, 0),
|
||||
cv.Point(side, 0),
|
||||
cv.Point(side, side),
|
||||
cv.Point(0, side),
|
||||
];
|
||||
|
||||
final M = cv.getPerspectiveTransform(
|
||||
cv.VecPoint.fromList(srcPoints),
|
||||
cv.VecPoint.fromList(dstPoints),
|
||||
);
|
||||
|
||||
final corrected = cv.warpPerspective(src, M, (side, side));
|
||||
|
||||
final tempDir = await getTemporaryDirectory();
|
||||
final timestamp = DateTime.now().millisecondsSinceEpoch;
|
||||
final outputPath = '${tempDir.path}/corrected_quad_$timestamp.jpg';
|
||||
|
||||
cv.imwrite(outputPath, corrected);
|
||||
|
||||
return outputPath;
|
||||
} catch (e) {
|
||||
print('Erreur correction perspective quadrilatère: $e');
|
||||
// Fallback
|
||||
return await correctPerspectiveUsingCircles(imagePath);
|
||||
}
|
||||
}
|
||||
|
||||
double _distanceCV(cv.Point p1, cv.Point p2) {
|
||||
final dx = p2.x - p1.x;
|
||||
final dy = p2.y - p1.y;
|
||||
return math.sqrt(dx * dx + dy * dy);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user