629 lines
21 KiB
Dart
629 lines
21 KiB
Dart
import 'dart:io';
|
|
import 'dart:math' as math;
|
|
import 'dart:async'; // AJOUT : Pour le Timer de détection périodique
|
|
import 'package:flutter/material.dart';
|
|
import 'package:image_picker/image_picker.dart';
|
|
import 'package:permission_handler/permission_handler.dart';
|
|
import 'package:device_info_plus/device_info_plus.dart';
|
|
import 'package:camera/camera.dart'; // AJOUT : Pour piloter le flux caméra en direct
|
|
|
|
import 'package:provider/provider.dart';
|
|
import '../../core/constants/app_constants.dart';
|
|
import '../../core/theme/app_theme.dart';
|
|
import '../../data/models/target_type.dart';
|
|
import '../crop/crop_screen.dart';
|
|
import '../session/session_provider.dart';
|
|
import 'widgets/image_source_button.dart';
|
|
import '../../services/image_crop_service.dart';
|
|
import '../../services/opencv_target_service.dart'; // AJOUT : Pour la détection périodique
|
|
|
|
class CaptureScreen extends StatefulWidget {
|
|
const CaptureScreen({super.key});
|
|
|
|
@override
|
|
State<CaptureScreen> createState() => _CaptureScreenState();
|
|
}
|
|
|
|
class _CaptureScreenState extends State<CaptureScreen> with SingleTickerProviderStateMixin {
|
|
final ImagePicker _picker = ImagePicker();
|
|
final ImageCropService _cropService = ImageCropService();
|
|
final TargetType _selectedType = TargetType.concentric;
|
|
final OpenCVTargetService _opencvService = OpenCVTargetService(); // AJOUT : Service de détection
|
|
String? _selectedImagePath;
|
|
bool _isLoading = false;
|
|
|
|
// AJOUT : Variables de gestion du flux caméra en direct
|
|
CameraController? _cameraController;
|
|
List<CameraDescription>? _cameras;
|
|
bool _isCameraInitialized = false;
|
|
bool _showLiveCamera = false;
|
|
|
|
// AJOUT : Animation pour l'effet "pulsation de détection" du cadre vert
|
|
late AnimationController _scanAnimationController;
|
|
late Animation<double> _scanAnimation;
|
|
|
|
// AJOUT : Variables pour le parallélisme
|
|
// _alignmentStatus : null = pas encore analysé, true = bien aligné, false = mal aligné
|
|
bool? _alignmentStatus;
|
|
Timer? _detectionTimer;
|
|
bool _isAnalyzingFrame = false; // Verrou pour éviter les appels OpenCV simultanés
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
// Initialisation de l'animation du viseur vert (effet pulsation)
|
|
_scanAnimationController = AnimationController(
|
|
duration: const Duration(seconds: 2),
|
|
vsync: this,
|
|
)..repeat(reverse: true);
|
|
|
|
_scanAnimation = Tween<double>(begin: 0.8, end: 1.0).animate(
|
|
CurvedAnimation(parent: _scanAnimationController, curve: Curves.easeInOut),
|
|
);
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_cameraController?.dispose();
|
|
_scanAnimationController.dispose();
|
|
_detectionTimer?.cancel(); // AJOUT : On stoppe le timer proprement
|
|
super.dispose();
|
|
}
|
|
|
|
// AJOUT : Initialisation de la caméra embarquée
|
|
Future<void> _initLiveCamera() async {
|
|
final status = await Permission.camera.request();
|
|
if (!status.isGranted) {
|
|
if (mounted) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(content: Text('Accès à l\'appareil photo requis')),
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
|
|
setState(() => _isLoading = true);
|
|
try {
|
|
// CORRECTIF ZOOM : On dispose l'ancien contrôleur avant d'en créer un nouveau
|
|
// pour garantir un zoom à 1.0 à chaque ouverture de la caméra
|
|
if (_cameraController != null) {
|
|
await _cameraController!.dispose();
|
|
_cameraController = null;
|
|
_isCameraInitialized = false;
|
|
}
|
|
|
|
_cameras = await availableCameras();
|
|
if (_cameras != null && _cameras!.isNotEmpty) {
|
|
_cameraController = CameraController(
|
|
_cameras![0],
|
|
ResolutionPreset.max, // Force le 4:3 natif au maximum du capteur
|
|
enableAudio: false,
|
|
imageFormatGroup: ImageFormatGroup.jpeg,
|
|
);
|
|
|
|
// INITIALISATION UNIQUE ET PROPRE :
|
|
await _cameraController!.initialize();
|
|
|
|
setState(() {
|
|
_isCameraInitialized = true;
|
|
_showLiveCamera = true;
|
|
_alignmentStatus = null; // AJOUT : Reset du statut d'alignement à chaque ouverture
|
|
});
|
|
|
|
// AJOUT : Démarrage du timer de détection périodique (toutes les 2 secondes)
|
|
_startAlignmentDetection();
|
|
}
|
|
} catch (e) {
|
|
debugPrint('Erreur caméra: $e');
|
|
} finally {
|
|
setState(() => _isLoading = false);
|
|
}
|
|
}
|
|
|
|
// AJOUT : Démarre la détection périodique du parallélisme toutes les 2 secondes
|
|
void _startAlignmentDetection() {
|
|
_detectionTimer?.cancel();
|
|
_detectionTimer = Timer.periodic(const Duration(seconds: 2), (_) {
|
|
_analyzeCurrentFrame();
|
|
});
|
|
}
|
|
|
|
// AJOUT : Stoppe le timer de détection
|
|
void _stopAlignmentDetection() {
|
|
_detectionTimer?.cancel();
|
|
_detectionTimer = null;
|
|
_alignmentStatus = null;
|
|
}
|
|
|
|
// AJOUT : Capture une frame et analyse le parallélisme via OpenCV
|
|
Future<void> _analyzeCurrentFrame() async {
|
|
// Verrou : on n'analyse pas si une analyse est déjà en cours
|
|
if (_isAnalyzingFrame) return;
|
|
if (_cameraController == null || !_cameraController!.value.isInitialized) return;
|
|
if (!_showLiveCamera) return;
|
|
|
|
_isAnalyzingFrame = true;
|
|
try {
|
|
// 1. Capture d'une frame temporaire (sans déclencher la prise de photo)
|
|
final XFile frame = await _cameraController!.takePicture();
|
|
|
|
// 2. Analyse OpenCV de la frame capturée
|
|
final result = await _opencvService.detectTarget(frame.path);
|
|
|
|
// 3. Nettoyage du fichier temporaire
|
|
try {
|
|
await File(frame.path).delete();
|
|
} catch (_) {}
|
|
|
|
// 4. Mise à jour du statut d'alignement si on est toujours sur l'écran caméra
|
|
if (mounted && _showLiveCamera) {
|
|
setState(() {
|
|
if (!result.success) {
|
|
// Aucune cible détectée → statut indéfini
|
|
_alignmentStatus = null;
|
|
} else {
|
|
// PARALLÉLISME : On vérifie que le centre détecté est proche du centre de l'image
|
|
// et que le rayon est suffisamment grand (cible bien cadrée)
|
|
// Un centre entre 0.3 et 0.7 en X et Y = bien centré = parallélisme OK
|
|
final bool isCentered =
|
|
result.centerX > 0.25 && result.centerX < 0.75 &&
|
|
result.centerY > 0.25 && result.centerY < 0.75;
|
|
final bool isSizedCorrectly = result.radius > 0.15;
|
|
_alignmentStatus = isCentered && isSizedCorrectly;
|
|
}
|
|
});
|
|
}
|
|
} catch (e) {
|
|
debugPrint('Erreur analyse frame: $e');
|
|
} finally {
|
|
_isAnalyzingFrame = false;
|
|
}
|
|
}
|
|
|
|
Future<void> _handleGallerySelection() async {
|
|
PermissionStatus status;
|
|
|
|
if (Platform.isAndroid) {
|
|
final deviceInfo = DeviceInfoPlugin();
|
|
final androidInfo = await deviceInfo.androidInfo;
|
|
|
|
if (androidInfo.version.sdkInt >= 33) {
|
|
status = await Permission.photos.request();
|
|
} else {
|
|
status = await Permission.storage.request();
|
|
}
|
|
} else {
|
|
status = await Permission.photos.request();
|
|
}
|
|
|
|
if (status.isGranted) {
|
|
_captureImageFromGallery();
|
|
} else if (status.isPermanentlyDenied) {
|
|
_showSettingsDialog();
|
|
} else {
|
|
if (mounted) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(
|
|
content: Text('Accès à la galerie requis pour continuer'),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
void _showSettingsDialog() {
|
|
showDialog(
|
|
context: context,
|
|
builder: (context) => AlertDialog(
|
|
title: const Text('Permission requise'),
|
|
content: const Text(
|
|
'L\'accès aux photos est nécessaire. Veuillez l\'activer dans les paramètres.',
|
|
),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: () => Navigator.pop(context),
|
|
child: const Text('Annuler'),
|
|
),
|
|
TextButton(
|
|
onPressed: () => openAppSettings(),
|
|
child: const Text('Paramètres'),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final sessionProvider = context.watch<SessionProvider>();
|
|
final title = sessionProvider.isSessionActive
|
|
? 'Cible ${sessionProvider.targetCount + 1}'
|
|
: 'Source';
|
|
|
|
// AJOUT : Si l'utilisateur clique sur scanner, on affiche la caméra plein écran avec l'overlay vert
|
|
if (_showLiveCamera && _cameraController != null && _cameraController!.value.isInitialized) {
|
|
return _buildLiveCameraView();
|
|
}
|
|
|
|
return Scaffold(
|
|
appBar: AppBar(title: Text(title)),
|
|
body: SingleChildScrollView(
|
|
padding: const EdgeInsets.all(AppConstants.defaultPadding),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
const SizedBox(height: AppConstants.largePadding),
|
|
|
|
_buildSectionTitle('Source de l\'Image'),
|
|
const SizedBox(height: 12),
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: ImageSourceButton(
|
|
icon: Icons.camera_alt,
|
|
label: 'Scanner',
|
|
onPressed: _isLoading ? null : _initLiveCamera, // Ouvre notre caméra intégrée
|
|
),
|
|
),
|
|
const SizedBox(width: 12),
|
|
Expanded(
|
|
child: ImageSourceButton(
|
|
icon: Icons.photo_library,
|
|
label: 'Galerie',
|
|
onPressed: _isLoading ? null : _handleGallerySelection,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: AppConstants.largePadding),
|
|
|
|
if (_isLoading)
|
|
const Center(
|
|
child: Padding(
|
|
padding: EdgeInsets.all(32),
|
|
child: CircularProgressIndicator(),
|
|
),
|
|
)
|
|
else
|
|
_buildGuide(),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
// AJOUT : Interface de la caméra live avec l'assistant de cadrage vert
|
|
// INTERFACE CORRIGÉE : Cadre fixe et cible ronde verte au centre
|
|
// INTERFACE : Restauration de TON ancienne cible centrale verte d'origine
|
|
Widget _buildLiveCameraView() {
|
|
// AJOUT : Couleur du cadre selon le statut d'alignement
|
|
// null = vert (pas encore analysé), true = vert (bien aligné), false = orange (mal aligné)
|
|
final Color frameColor = _alignmentStatus == false
|
|
? Colors.orange
|
|
: const Color(0xFF00FF00);
|
|
|
|
// AJOUT : Message d'aide selon le statut d'alignement
|
|
final String alignmentMessage = _alignmentStatus == null
|
|
? 'ALIGNEZ LA CIBLE DANS LE CADRE'
|
|
: _alignmentStatus == true
|
|
? 'CIBLE BIEN ALIGNÉE — PRÊT À TIRER'
|
|
: 'REPOSITIONNEZ — ANGLE TROP FORT';
|
|
|
|
return Scaffold(
|
|
backgroundColor: Colors.black,
|
|
body: Stack(
|
|
fit: StackFit.expand,
|
|
children: [
|
|
// 1. Le flux vidéo de la caméra
|
|
Center(
|
|
child: AspectRatio(
|
|
aspectRatio: 3 / 4, // Aligné sur le format natif du capteur photo
|
|
child: CameraPreview(_cameraController!),
|
|
),
|
|
),
|
|
|
|
// 2. L'ASSISTANT DE CADRAGE VIRTUEL (Avec le grand cadre complet et la petite cible)
|
|
Center(
|
|
child: Container(
|
|
width: MediaQuery.of(context).size.width * 0.85,
|
|
height: MediaQuery.of(context).size.width * 0.85,
|
|
decoration: BoxDecoration(
|
|
border: Border.all(
|
|
color: frameColor, // MODIFIÉ : Couleur dynamique selon l'alignement
|
|
width: 2.0,
|
|
),
|
|
borderRadius: BorderRadius.circular(16),
|
|
),
|
|
child: Stack(
|
|
children: [
|
|
// SÉCURITÉ : On réintègre les 4 coins renforcés sur les côtés !
|
|
_buildCameraCorner(TopLeft: true, color: frameColor),
|
|
_buildCameraCorner(TopRight: true, color: frameColor),
|
|
_buildCameraCorner(BottomLeft: true, color: frameColor),
|
|
_buildCameraCorner(BottomRight: true, color: frameColor),
|
|
|
|
// TA MIRE CENTRALE HISTORIQUE FINALE
|
|
Center(
|
|
child: Container(
|
|
width: 24, // Diamètre global de la petite cible
|
|
height: 24,
|
|
decoration: BoxDecoration(
|
|
shape: BoxShape.circle,
|
|
border: Border.all(
|
|
color: frameColor, // MODIFIÉ : Couleur dynamique
|
|
width: 1.2, // Ligne fine
|
|
),
|
|
),
|
|
child: Stack(
|
|
children: [
|
|
// Trait horizontal fin confiné
|
|
Center(
|
|
child: Container(
|
|
width: 20,
|
|
height: 1.2,
|
|
color: frameColor, // MODIFIÉ : Couleur dynamique
|
|
),
|
|
),
|
|
// Trait vertical fin confiné
|
|
Center(
|
|
child: Container(
|
|
width: 1.2,
|
|
height: 20,
|
|
color: frameColor, // MODIFIÉ : Couleur dynamique
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
|
|
// 3. Barre supérieure avec bouton Retour
|
|
Positioned(
|
|
top: 40,
|
|
left: 20,
|
|
child: CircleAvatar(
|
|
backgroundColor: Colors.black54,
|
|
child: IconButton(
|
|
icon: const Icon(Icons.arrow_back, color: Colors.white),
|
|
onPressed: () {
|
|
// AJOUT : On stoppe la détection quand on quitte la caméra
|
|
_stopAlignmentDetection();
|
|
setState(() {
|
|
_showLiveCamera = false;
|
|
});
|
|
},
|
|
),
|
|
),
|
|
),
|
|
|
|
// 4. Consigne de scan textuelle — MODIFIÉ : Message dynamique selon l'alignement
|
|
Positioned(
|
|
top: 50,
|
|
left: 0,
|
|
right: 0,
|
|
child: Center(
|
|
child: Container(
|
|
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
|
|
decoration: BoxDecoration(
|
|
color: Colors.black.withValues(alpha: 0.7),
|
|
borderRadius: BorderRadius.circular(20),
|
|
),
|
|
child: Text(
|
|
alignmentMessage,
|
|
style: TextStyle(
|
|
color: frameColor, // MODIFIÉ : Couleur dynamique
|
|
fontWeight: FontWeight.bold,
|
|
fontSize: 12,
|
|
letterSpacing: 1.2,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
|
|
// AJOUT : Indicateur visuel de l'analyse en cours (petit point clignotant)
|
|
if (_isAnalyzingFrame)
|
|
Positioned(
|
|
top: 45,
|
|
right: 20,
|
|
child: Container(
|
|
width: 10,
|
|
height: 10,
|
|
decoration: const BoxDecoration(
|
|
color: Colors.white54,
|
|
shape: BoxShape.circle,
|
|
),
|
|
),
|
|
),
|
|
|
|
// 5. Bouton déclencheur Manuel en bas
|
|
Positioned(
|
|
bottom: 40,
|
|
left: 0,
|
|
right: 0,
|
|
child: Center(
|
|
child: GestureDetector(
|
|
onTap: _takePictureManually,
|
|
child: Container(
|
|
height: 80,
|
|
width: 80,
|
|
decoration: BoxDecoration(
|
|
shape: BoxShape.circle,
|
|
border: Border.all(color: Colors.white, width: 4),
|
|
),
|
|
child: Center(
|
|
child: Container(
|
|
height: 64,
|
|
width: 64,
|
|
decoration: const BoxDecoration(
|
|
color: Colors.white,
|
|
shape: BoxShape.circle,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
// MODIFIÉ : Ajout du paramètre color pour la couleur dynamique des coins
|
|
Widget _buildCameraCorner({
|
|
bool TopLeft = false,
|
|
bool TopRight = false,
|
|
bool BottomLeft = false,
|
|
bool BottomRight = false,
|
|
Color color = const Color(0xFF00FF00), // AJOUT : Couleur dynamique
|
|
}) {
|
|
return Positioned(
|
|
top: (TopLeft || TopRight) ? 10 : null,
|
|
bottom: (BottomLeft || BottomRight) ? 10 : null,
|
|
left: (TopLeft || BottomLeft) ? 10 : null,
|
|
right: (TopRight || BottomRight) ? 10 : null,
|
|
child: Container(
|
|
width: 20,
|
|
height: 20,
|
|
decoration: BoxDecoration(
|
|
border: Border(
|
|
top: (TopLeft || TopRight) ? BorderSide(color: color, width: 4) : BorderSide.none,
|
|
bottom: (BottomLeft || BottomRight) ? BorderSide(color: color, width: 4) : BorderSide.none,
|
|
left: (TopLeft || BottomLeft) ? BorderSide(color: color, width: 4) : BorderSide.none,
|
|
right: (TopRight || BottomRight) ? BorderSide(color: color, width: 4) : BorderSide.none,
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
// AJOUT : Capture manuelle via notre bouton déclencheur
|
|
Future<void> _takePictureManually() async {
|
|
if (_cameraController == null || !_cameraController!.value.isInitialized) return;
|
|
|
|
setState(() => _isLoading = true);
|
|
try {
|
|
// CORRECTIF ZOOM : On remet le zoom à 1.0 avant la capture pour ne pas
|
|
// propager le zoom optique dans les écrans suivants
|
|
try {
|
|
await _cameraController!.setZoomLevel(1.0);
|
|
} catch (_) {
|
|
// Certains appareils ne supportent pas setZoomLevel, on ignore l'erreur
|
|
}
|
|
|
|
// AJOUT : On stoppe la détection périodique avant de prendre la photo
|
|
_stopAlignmentDetection();
|
|
|
|
// 1. On prend la photo brute normale (sans y toucher)
|
|
final XFile photo = await _cameraController!.takePicture();
|
|
|
|
setState(() {
|
|
_selectedImagePath = photo.path;
|
|
_showLiveCamera = false;
|
|
});
|
|
|
|
// 2. On l'envoie directement à l'analyse
|
|
_analyzeImage();
|
|
} catch (e) {
|
|
debugPrint('Erreur lors du clic photo: $e');
|
|
} finally {
|
|
setState(() => _isLoading = false);
|
|
}
|
|
}
|
|
|
|
Widget _buildSectionTitle(String title) {
|
|
return Text(
|
|
title,
|
|
style: Theme.of(
|
|
context,
|
|
).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold),
|
|
);
|
|
}
|
|
|
|
Widget _buildGuide() {
|
|
return Card(
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(AppConstants.defaultPadding),
|
|
child: Column(
|
|
children: [
|
|
Icon(Icons.help_outline, size: 48, color: Colors.grey[400]),
|
|
const SizedBox(height: 12),
|
|
Text(
|
|
'Conseils pour une bonne analyse',
|
|
style: Theme.of(
|
|
context,
|
|
).textTheme.titleSmall?.copyWith(fontWeight: FontWeight.bold),
|
|
),
|
|
const SizedBox(height: 12),
|
|
_buildGuideItem(
|
|
Icons.crop_free,
|
|
'Cadrez la cible entière dans l\'image',
|
|
),
|
|
_buildGuideItem(Icons.wb_sunny, 'Utilisez un bon éclairage'),
|
|
_buildGuideItem(Icons.straighten, 'Prenez la photo de face'),
|
|
_buildGuideItem(Icons.blur_off, 'Évitez les images floues'),
|
|
_buildGuideItem(
|
|
Icons.cleaning_services,
|
|
'Nettoyer votre objectif avec une chiffonnette',
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _buildGuideItem(IconData icon, String text) {
|
|
return Padding(
|
|
padding: const EdgeInsets.symmetric(vertical: 4),
|
|
child: Row(
|
|
children: [
|
|
Icon(icon, size: 20, color: AppTheme.primaryColor),
|
|
const SizedBox(width: 12),
|
|
Expanded(child: Text(text)),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
// Capture depuis la galerie d'images
|
|
Future<void> _captureImageFromGallery() async {
|
|
setState(() => _isLoading = true);
|
|
try {
|
|
final XFile? image = await _picker.pickImage(
|
|
source: ImageSource.gallery,
|
|
maxWidth: 2048,
|
|
maxHeight: 2048,
|
|
imageQuality: 90,
|
|
);
|
|
if (image != null) {
|
|
setState(() {
|
|
_selectedImagePath = image.path;
|
|
});
|
|
_analyzeImage();
|
|
}
|
|
} catch (e) {
|
|
debugPrint('Erreur galerie: $e');
|
|
} finally {
|
|
if (mounted) setState(() => _isLoading = false);
|
|
}
|
|
}
|
|
|
|
void _analyzeImage() {
|
|
if (_selectedImagePath == null) return;
|
|
|
|
Navigator.push(
|
|
context,
|
|
MaterialPageRoute(
|
|
builder: (_) => CropScreen(
|
|
imagePath: _selectedImagePath!,
|
|
targetType: _selectedType,
|
|
),
|
|
),
|
|
);
|
|
}
|
|
} |