streaper2/impact
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 8 Wiki Activity

feat(capture): detect the flat pose for targets laid on the ground

Browse Source
This commit is contained in:
qlionbleusam
2026-08-29 10:33:59 +02:00
parent 869835f234
commit 8804d8b6a1
3 changed files with 262 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/features/capture/capture_screen.dart
+25 -9
View File
@@ -169,8 +169,9 @@ class _CaptureScreenState extends State<CaptureScreen>
final prev = _parallelismData;
final bool changed = prev == null ||
prev.status != data.status ||
prev.pitchDegrees.toStringAsFixed(1) !=
data.pitchDegrees.toStringAsFixed(1) ||
prev.pose != data.pose ||
prev.pitchDeviation.toStringAsFixed(1) !=
data.pitchDeviation.toStringAsFixed(1) ||
prev.rollDegrees.toStringAsFixed(1) !=
data.rollDegrees.toStringAsFixed(1);
@@ -218,16 +219,21 @@ class _CaptureScreenState extends State<CaptureScreen>
return 'ALIGNEZ LA CIBLE DANS LE CADRE';
}
final bool onGround = _parallelismData!.pose == TargetPose.ground;
// Aligné → message de validation (avec bonus si la cible est détectée)
if (_parallelismData!.isAligned) {
return _targetReady
? 'PARFAIT — CIBLE DÉTECTÉE, PRÊT'
if (_targetReady) return 'PARFAIT — CIBLE DÉTECTÉE, PRÊT';
return onGround
? 'CIBLE AU SOL — PRÊT À PHOTOGRAPHIER'
: 'PARALLÈLE OK — PRÊT À PHOTOGRAPHIER';
}
// Mal aligné → message directif selon l'axe le plus dévié
final double pitch = _parallelismData!.pitchDegrees;
final double roll = _parallelismData!.rollDegrees;
// Mal aligné → message directif selon l'axe le plus dévié.
// On raisonne sur les écarts à la pose détectée, pas sur le tangage brut :
// à plat, celui-ci vaut -90° alors que le cadrage peut être parfait.
final double pitch = _parallelismData!.pitchDeviation;
final double roll = _parallelismData!.rollDeviation;
if (pitch.abs() >= roll.abs()) {
return pitch > 0
@@ -776,15 +782,25 @@ class _CaptureScreenState extends State<CaptureScreen>
crossAxisAlignment: CrossAxisAlignment.start,
mainAxisSize: MainAxisSize.min,
children: [
Text(
data.pose == TargetPose.ground ? 'CIBLE AU SOL' : 'CIBLE AU MUR',
style: TextStyle(
color: color,
fontSize: 10,
fontWeight: FontWeight.w700,
letterSpacing: 0.5,
),
),
const SizedBox(height: 4),
_buildAngleRow(
label: 'Pitch',
value: data.pitchDegrees,
value: data.pitchDeviation,
color: color,
),
const SizedBox(height: 2),
_buildAngleRow(
label: 'Roll ',
value: data.rollDegrees,
value: data.rollDeviation,
color: color,
),
],
lib/services/parallelism_service.dart
+101 -13
View File
@@ -1,5 +1,6 @@
import 'dart:async';
import 'dart:math' as math;
import 'package:flutter/foundation.dart';
import 'package:sensors_plus/sensors_plus.dart';
/// Statut de parallélisme retourné en temps réel.
@@ -14,31 +15,67 @@ enum ParallelismStatus {
misaligned,
}
/// Pose de prise de vue déduite de l'inclinaison de l'appareil.
enum TargetPose {
/// Cible accrochée verticalement : l'appareil est tenu droit.
wall,
/// Cible posée au sol : l'appareil est à plat, caméra vers le bas.
ground,
}
/// Données de parallélisme calculées à chaque frame capteur.
class ParallelismData {
final ParallelismStatus status;
/// Inclinaison avant/arrière en degrés (0° = parfaitement vertical).
/// Pose détectée automatiquement, qui sert de référence aux écarts.
final TargetPose pose;
/// Inclinaison avant/arrière brute en degrés (0° = appareil vertical,
/// -90° = appareil à plat, caméra vers le sol).
final double pitchDegrees;
/// Inclinaison gauche/droite en degrés (0° = parfaitement droit).
final double rollDegrees;
/// Écart de tangage par rapport à la pose détectée.
///
/// En pose [TargetPose.wall] il vaut exactement [pitchDegrees] ; en pose
/// [TargetPose.ground] il mesure l'écart aux -90° de l'appareil à plat.
/// C'est cette valeur qu'il faut afficher : le tangage brut vaudrait -90°
/// alors que le cadrage est parfait.
final double pitchDeviation;
const ParallelismData({
required this.status,
required this.pose,
required this.pitchDegrees,
required this.rollDegrees,
required this.pitchDeviation,
});
bool get isAligned => status == ParallelismStatus.aligned;
/// Écart latéral. Le roulis se mesure de la même façon dans les deux poses.
double get rollDeviation => rollDegrees;
@override
String toString() =>
'ParallelismData(status: $status, pitch: ${pitchDegrees.toStringAsFixed(1)}°, roll: ${rollDegrees.toStringAsFixed(1)}°)';
'ParallelismData(status: $status, pose: $pose, pitch: ${pitchDegrees.toStringAsFixed(1)}°, '
'écart: ${pitchDeviation.toStringAsFixed(1)}°, roll: ${rollDegrees.toStringAsFixed(1)}°)';
}
/// Service de détection du parallélisme par accéléromètre.
///
/// Deux poses de prise de vue sont reconnues, et celle dont l'appareil est le
/// plus proche est retenue automatiquement :
///
/// [TargetPose.wall] — cible au mur, appareil vertical (tangage ≈ 0°)
/// [TargetPose.ground] — cible au sol, appareil à plat (tangage ≈ -90°)
///
/// Seul le tangage négatif vaut pour la pose au sol : à plat écran vers le
/// haut, la caméra vise le plafond et le vert n'aurait aucun sens.
///
/// Implémente une hystérésis à deux seuils pour éviter le clignotement :
///
/// État actuel = misaligned → passe à aligned si angle < [alignThreshold]
@@ -58,6 +95,13 @@ class ParallelismService {
/// Doit être > alignThreshold pour créer la zone d'hystérésis.
final double misalignThreshold;
/// Écart minimum en faveur de l'autre pose pour basculer.
///
/// Les deux poses sont séparées de 90°, donc la bascule se joue vers 45° —
/// très loin des deux zones vertes. Cette marge évite seulement que
/// l'étiquette de pose clignote pile à la frontière.
static const double poseSwitchMargin = 5.0;
StreamSubscription<AccelerometerEvent>? _subscription;
final StreamController<ParallelismData> _controller =
StreamController<ParallelismData>.broadcast();
@@ -65,6 +109,9 @@ class ParallelismService {
/// État interne mémorisé entre deux frames (cœur de l'hystérésis).
ParallelismStatus _currentStatus = ParallelismStatus.unknown;
/// Pose retenue à la frame précédente, pour l'hystérésis de pose.
TargetPose? _currentPose;
ParallelismService({
this.alignThreshold = 25.0,
this.misalignThreshold = 32.0,
@@ -86,10 +133,13 @@ class ParallelismService {
// Simulateur ou capteur absent — on reste en "unknown" sans bloquer l'UI
if (!_controller.isClosed) {
_currentStatus = ParallelismStatus.unknown;
_currentPose = null;
_controller.add(const ParallelismData(
status: ParallelismStatus.unknown,
pose: TargetPose.wall,
pitchDegrees: 0,
rollDegrees: 0,
pitchDeviation: 0,
));
}
},
@@ -100,6 +150,7 @@ class ParallelismService {
_subscription?.cancel();
_subscription = null;
_currentStatus = ParallelismStatus.unknown;
_currentPose = null;
}
void dispose() {
@@ -110,12 +161,18 @@ class ParallelismService {
void _onAccelerometerEvent(AccelerometerEvent event) {
if (_controller.isClosed) return;
final double gx = event.x;
final double gy = event.y;
final double gz = event.z;
final data = evaluate(event.x, event.y, event.z);
if (data != null) _controller.add(data);
}
/// Calcule la pose et le statut depuis une mesure d'accéléromètre.
///
/// Met à jour l'état d'hystérésis, donc l'ordre des appels compte.
/// Retourne null sur une mesure aberrante, qu'il faut alors ignorer.
@visibleForTesting
ParallelismData? evaluate(double gx, double gy, double gz) {
final double magnitude = math.sqrt(gx * gx + gy * gy + gz * gz);
if (magnitude < 1.0) return; // Données aberrantes
if (magnitude < 1.0) return null; // Données aberrantes
// Normalisation par la magnitude réelle (indépendant de g exact)
final double nx = gx / magnitude;
@@ -125,10 +182,39 @@ class ParallelismService {
final double pitchDeg = math.asin(nz.clamp(-1.0, 1.0)) * (180.0 / math.pi);
final double rollDeg = math.asin(nx.clamp(-1.0, 1.0)) * (180.0 / math.pi);
// Le critère de couleur = le PIRE des deux angles affichés à l'écran.
// Ainsi ce que voit l'utilisateur (Pitch / Roll) correspond exactement
// à la décision vert/orange : à 2° d'écart, on est largement dans le vert.
final double worstAngle = math.max(pitchDeg.abs(), rollDeg.abs());
// ── Choix de la pose ────────────────────────────────────────────────────
// Cible au mur : le tangage idéal est 0°. Formule d'origine, inchangée.
final double wallPitchDeviation = pitchDeg;
final double wallWorst = math.max(pitchDeg.abs(), rollDeg.abs());
// Cible au sol : le tangage idéal est -90° (caméra vers le bas). Écran vers
// le haut, le tangage vaut +90° et l'écart atteint 180° : la pose au sol ne
// peut alors jamais gagner, ce qui est exactement le comportement voulu.
final double groundPitchDeviation = pitchDeg + 90.0;
final double groundWorst =
math.max(groundPitchDeviation.abs(), rollDeg.abs());
if (_currentPose == null) {
_currentPose =
groundWorst < wallWorst ? TargetPose.ground : TargetPose.wall;
} else if (_currentPose == TargetPose.wall) {
if (groundWorst + poseSwitchMargin < wallWorst) {
_currentPose = TargetPose.ground;
}
} else {
if (wallWorst + poseSwitchMargin < groundWorst) {
_currentPose = TargetPose.wall;
}
}
final bool isGround = _currentPose == TargetPose.ground;
final double pitchDeviation =
isGround ? groundPitchDeviation : wallPitchDeviation;
// Le critère de couleur = le PIRE des deux écarts affichés à l'écran.
// Ainsi ce que voit l'utilisateur correspond exactement à la décision
// vert/orange : à 2° d'écart, on est largement dans le vert.
final double worstAngle = isGround ? groundWorst : wallWorst;
// ── Hystérésis ──────────────────────────────────────────────────────────
// Premier appel : on décide selon alignThreshold uniquement
@@ -152,10 +238,12 @@ class ParallelismService {
}
// ────────────────────────────────────────────────────────────────────────
_controller.add(ParallelismData(
return ParallelismData(
status: _currentStatus,
pose: _currentPose!,
pitchDegrees: pitchDeg,
rollDegrees: rollDeg,
));
pitchDeviation: pitchDeviation,
);
}
}
}