README update and FR

README.FR.md

@@ -0,0 +1,270 @@
+# Mixbox pour Dart/Flutter
+
+<p align="center">
+  <img src="https://scrtwpns.com/mixbox/teaser.jpg"/>
+</p>
+
+Implémentation Dart de **Mixbox 2.0** - mélange de couleurs physiquement réaliste simulant le comportement des pigments réels.
+
+## 🎨 Pourquoi Mixbox ?
+
+Le mélange RGB classique produit des couleurs ternes :
+- **Jaune + Bleu = Gris** ❌ (en RGB)
+- **Jaune + Bleu = Vert** ✅ (avec Mixbox)
+
+Mixbox simule le comportement physique des pigments pour des résultats naturels.
+
+## 📦 Installation
+
+### 1. Ajoutez les fichiers
+
+```
+lib/
+  mixbox/
+    mixbox.dart
+    mixbox_loader.dart
+assets/
+  mixbox_lut.dat
+```
+
+### 2. Dépendances dans `pubspec.yaml`
+
+```yaml
+dependencies:
+  flutter:
+    sdk: flutter
+  archive: ^3.4.0 
+
+flutter:
+  assets:
+    - assets/mixbox_lut.dat
+```
+
+### 3. Téléchargez la LUT
+
+Le fichier `mixbox_lut.dat` doit être téléchargé depuis :
+- **Source officielle**: https://github.com/scrtwpns/mixbox
+- Placez-le dans `assets/mixbox_lut.dat`
+
+> ⚠️ **Important**: Sans la LUT, Mixbox ne fonctionnera pas correctement.
+
+## 🚀 Utilisation
+
+### Initialisation (une fois au démarrage)
+
+```dart
+import 'mixbox_loader.dart';
+
+void main() async {
+  WidgetsFlutterBinding.ensureInitialized();
+  
+  // Chargement de la LUT
+  await MixboxLoader.initializeFromAsset('assets/mixbox_lut.dat');
+  
+  runApp(MyApp());
+}
+```
+
+### Mélange simple (2 couleurs)
+
+```dart
+import 'package:flutter/material.dart';
+import 'mixbox.dart';
+import 'mixbox_loader.dart';
+
+// Extension pour faciliter l'usage avec Flutter Color
+final yellow = Color(0xFFFEEC00);
+final blue = Color(0xFF190059);
+
+final green = yellow.mixWith(blue, 0.5); // 50% de chaque
+```
+
+### Mélange multi-couleurs (3+)
+
+```dart
+final red = Color(0xFFFF2702);
+final yellow = Color(0xFFFCD300);
+final blue = Color(0xFF0D1B44);
+
+// Conversion en espace latent
+final z1 = Mixbox.rgbToLatent(red.toMixboxInt());
+final z2 = Mixbox.rgbToLatent(yellow.toMixboxInt());
+final z3 = Mixbox.rgbToLatent(blue.toMixboxInt());
+
+// Mélange personnalisé
+final zMix = List.generate(
+  Mixbox.latentSize,
+  (i) => 0.4 * z1[i] + 0.3 * z2[i] + 0.3 * z3[i],
+);
+
+final mixed = Color(Mixbox.latentToRgb(zMix));
+```
+
+### Gradient physiquement correct
+
+```dart
+final gradient = List.generate(
+  10,
+  (i) => yellow.mixWith(blue, i / 9.0),
+);
+```
+
+## 🎨 Couleurs Pigments Prédéfinies
+
+Utilisez ces couleurs pour des résultats réalistes :
+
+```dart
+const cadmiumYellow = Color(0xFFFEEC00);       // Jaune cadmium
+const hansaYellow = Color(0xFFFCD300);         // Jaune Hansa
+const cadmiumOrange = Color(0xFFFF6900);       // Orange cadmium
+const cadmiumRed = Color(0xFFFF2702);          // Rouge cadmium
+const quinacridoneMagenta = Color(0xFF80022E); // Magenta quinacridone
+const cobaltViolet = Color(0xFF4E0042);        // Violet cobalt
+const ultramarineBlue = Color(0xFF190059);     // Bleu outremer
+const cobaltBlue = Color(0xFF002185);          // Bleu cobalt
+const phthaloBlue = Color(0xFF0D1B44);         // Bleu phthalo
+const phthaloGreen = Color(0xFF003C32);        // Vert phthalo
+const permanentGreen = Color(0xFF076D16);      // Vert permanent
+const sapGreen = Color(0xFF6B9404);            // Vert sève
+const burntSienna = Color(0xFF7B4800);         // Terre de Sienne brûlée
+```
+
+## 📊 API Complète
+
+### Méthodes principales
+
+```dart
+// Mélange int (0xAARRGGBB)
+int Mixbox.lerp(int color1, int color2, double t)
+
+// Mélange liste [r, g, b] ou [r, g, b, a] (0-255)
+List<int> Mixbox.lerpList(List<int> color1, List<int> color2, double t)
+
+// Mélange float [r, g, b] ou [r, g, b, a] (0.0-1.0)
+List<double> Mixbox.lerpFloat(List<double> color1, List<double> color2, double t)
+
+// Mélange RGB linéaire (pour rendu 3D)
+List<double> Mixbox.lerpLinearFloat(List<double> color1, List<double> color2, double t)
+```
+
+### Conversions
+
+```dart
+// RGB → Latent
+List<double> Mixbox.rgbToLatent(int color)
+List<double> Mixbox.floatRgbToLatent(double r, double g, double b)
+
+// Latent → RGB
+int Mixbox.latentToRgb(List<double> latent)
+List<double> Mixbox.latentToFloatRgb(List<double> latent)
+```
+
+## 🧪 Exemple Complet
+
+```dart
+import 'package:flutter/material.dart';
+import 'mixbox.dart';
+import 'mixbox_loader.dart';
+
+void main() async {
+  WidgetsFlutterBinding.ensureInitialized();
+  await MixboxLoader.initializeFromAsset('assets/mixbox_lut.dat');
+  runApp(const MyApp());
+}
+
+class MyApp extends StatefulWidget {
+  const MyApp({super.key});
+
+  @override
+  State<MyApp> createState() => _MyAppState();
+}
+
+class _MyAppState extends State<MyApp> {
+  double _mix = 0.5;
+  
+  final _yellow = const Color(0xFFFEEC00);
+  final _blue = const Color(0xFF190059);
+
+  @override
+  Widget build(BuildContext context) {
+    final mixed = _yellow.mixWith(_blue, _mix);
+    
+    return MaterialApp(
+      home: Scaffold(
+        appBar: AppBar(title: const Text('Mixbox Demo')),
+        body: Column(
+          children: [
+            Container(height: 200, color: mixed),
+            Slider(
+              value: _mix,
+              onChanged: (v) => setState(() => _mix = v),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}
+```
+
+## ⚙️ Configuration Avancée
+
+### Sans la LUT (Tests uniquement)
+
+```dart
+// Génère une approximation (NON recommandé en production)
+final testLut = MixboxLoader.generateTestLut();
+Mixbox.initialize(testLut);
+```
+
+### Espace Linéaire (Rendu 3D)
+
+Pour shaders/rendu 3D, utilisez l'espace linéaire :
+
+```dart
+final color1Linear = [1.0, 0.5, 0.0]; // RGB linéaire
+final color2Linear = [0.0, 0.2, 1.0];
+
+final mixed = Mixbox.lerpLinearFloat(color1Linear, color2Linear, 0.5);
+```
+
+## 📝 Licence
+
+**Creative Commons Attribution-NonCommercial 4.0**
+
+- ✅ Usage non-commercial gratuit
+- ❌ Usage commercial nécessite une licence
+- Contact: mixbox@scrtwpns.com
+
+## 🔗 Ressources
+
+- **Site officiel**: https://scrtwpns.com/mixbox
+- **Paper**: https://scrtwpns.com/mixbox.pdf
+- **GitHub**: https://github.com/scrtwpns/mixbox
+- **Démo interactive**: https://scrtwpns.com/mixbox/painter/
+
+## ❓ FAQ
+
+**Q: Pourquoi la LUT est nécessaire ?**  
+R: Elle contient les données pré-calculées du modèle physique des pigments (64×64×64 = 262,144 valeurs).
+
+**Q: Puis-je utiliser sans la LUT ?**  
+R: Non pour des résultats corrects. La fonction `generateTestLut()` est juste pour les tests rapides.
+
+**Q: Performances ?**  
+R: Très rapide (~1μs par mélange). L'interpolation trilinéaire est optimisée.
+
+**Q: Différence avec HSV/HSL ?**  
+R: HSV/HSL sont des transformations mathématiques. Mixbox simule la physique réelle des pigments.
+
+**Q: Ça marche pour l'animation ?**  
+R: Oui ! Parfait pour les gradients, transitions, et animations fluides.
+
+## 🎯 Cas d'Usage
+
+- 🎨 Applications de dessin/peinture
+- 🌈 Gradients naturels
+- 🎬 Outils de création de contenu
+- 🎮 Systèmes de couleurs dans les jeux
+- 🖼️ Filtres photo réalistes
+- 📊 Visualisations de données