README update and FR

This commit is contained in:
Robert Felker
2026-02-10 17:19:10 +01:00
parent adee1529b0
commit a882d1dc08
2 changed files with 345 additions and 75 deletions

270
README.FR.md Normal file
View File

@@ -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

150
README.md
View File

@@ -1,22 +1,22 @@
# Mixbox pour Dart/Flutter
# Mixbox for 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.
Dart implementation of **Mixbox 2.0** - physically realistic color mixing simulating real pigment behavior.
## 🎨 Pourquoi Mixbox ?
## 🎨 Why Mixbox?
Le mélange RGB classique produit des couleurs ternes :
- **Jaune + Bleu = Gris** ❌ (en RGB)
- **Jaune + Bleu = Vert** ✅ (avec Mixbox)
Classic RGB mixing produces dull colors:
- **Yellow + Blue = Gray** ❌ (in RGB)
- **Yellow + Blue = Green** ✅ (with Mixbox)
Mixbox simule le comportement physique des pigments pour des résultats naturels.
Mixbox simulates physical pigment behavior for natural results.
## 📦 Installation
### 1. Ajoutez les fichiers
### 1. Add the files
```
lib/
@@ -27,7 +27,7 @@ assets/
mixbox_lut.dat
```
### 2. Dépendances dans `pubspec.yaml`
### 2. Dependencies in `pubspec.yaml`
```yaml
dependencies:
@@ -40,17 +40,17 @@ flutter:
- assets/mixbox_lut.dat
```
### 3. Téléchargez la LUT
### 3. Download the 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`
The `mixbox_lut.dat` file must be downloaded from:
- **Official source**: https://github.com/scrtwpns/mixbox
- Place it in `assets/mixbox_lut.dat`
> ⚠️ **Important**: Sans la LUT, Mixbox ne fonctionnera pas correctement.
> ⚠️ **Important**: Without the LUT, Mixbox won't work properly.
## 🚀 Utilisation
## 🚀 Usage
### Initialisation (une fois au démarrage)
### Initialization (once at startup)
```dart
import 'mixbox_loader.dart';
@@ -58,40 +58,40 @@ import 'mixbox_loader.dart';
void main() async {
WidgetsFlutterBinding.ensureInitialized();
// Chargement de la LUT
// Load the LUT
await MixboxLoader.initializeFromAsset('assets/mixbox_lut.dat');
runApp(MyApp());
}
```
### Mélange simple (2 couleurs)
### Simple mixing (2 colors)
```dart
import 'package:flutter/material.dart';
import 'mixbox.dart';
import 'mixbox_loader.dart';
// Extension pour faciliter l'usage avec Flutter Color
// Extension for easy use with Flutter Color
final yellow = Color(0xFFFEEC00);
final blue = Color(0xFF190059);
final green = yellow.mixWith(blue, 0.5); // 50% de chaque
final green = yellow.mixWith(blue, 0.5); // 50% of each
```
### Mélange multi-couleurs (3+)
### Multi-color mixing (3+)
```dart
final red = Color(0xFFFF2702);
final yellow = Color(0xFFFCD300);
final blue = Color(0xFF0D1B44);
// Conversion en espace latent
// Convert to latent space
final z1 = Mixbox.rgbToLatent(red.toMixboxInt());
final z2 = Mixbox.rgbToLatent(yellow.toMixboxInt());
final z3 = Mixbox.rgbToLatent(blue.toMixboxInt());
// Mélange personnalisé
// Custom mixing
final zMix = List.generate(
Mixbox.latentSize,
(i) => 0.4 * z1[i] + 0.3 * z2[i] + 0.3 * z3[i],
@@ -100,7 +100,7 @@ final zMix = List.generate(
final mixed = Color(Mixbox.latentToRgb(zMix));
```
### Gradient physiquement correct
### Physically correct gradient
```dart
final gradient = List.generate(
@@ -109,41 +109,41 @@ final gradient = List.generate(
);
```
## 🎨 Couleurs Pigments Prédéfinies
## 🎨 Predefined Pigment Colors
Utilisez ces couleurs pour des résultats réalistes :
Use these colors for realistic results:
```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
const cadmiumYellow = Color(0xFFFEEC00); // Cadmium yellow
const hansaYellow = Color(0xFFFCD300); // Hansa yellow
const cadmiumOrange = Color(0xFFFF6900); // Cadmium orange
const cadmiumRed = Color(0xFFFF2702); // Cadmium red
const quinacridoneMagenta = Color(0xFF80022E); // Quinacridone magenta
const cobaltViolet = Color(0xFF4E0042); // Cobalt violet
const ultramarineBlue = Color(0xFF190059); // Ultramarine blue
const cobaltBlue = Color(0xFF002185); // Cobalt blue
const phthaloBlue = Color(0xFF0D1B44); // Phthalo blue
const phthaloGreen = Color(0xFF003C32); // Phthalo green
const permanentGreen = Color(0xFF076D16); // Permanent green
const sapGreen = Color(0xFF6B9404); // Sap green
const burntSienna = Color(0xFF7B4800); // Burnt sienna
```
## 📊 API Complète
## 📊 Complete API
### Méthodes principales
### Main methods
```dart
// Mélange int (0xAARRGGBB)
// Mix int (0xAARRGGBB)
int Mixbox.lerp(int color1, int color2, double t)
// Mélange liste [r, g, b] ou [r, g, b, a] (0-255)
// Mix list [r, g, b] or [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)
// Mix float [r, g, b] or [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)
// Mix linear RGB (for 3D rendering)
List<double> Mixbox.lerpLinearFloat(List<double> color1, List<double> color2, double t)
```
@@ -159,7 +159,7 @@ int Mixbox.latentToRgb(List<double> latent)
List<double> Mixbox.latentToFloatRgb(List<double> latent)
```
## 🧪 Exemple Complet
## 🧪 Complete Example
```dart
import 'package:flutter/material.dart';
@@ -207,64 +207,64 @@ class _MyAppState extends State<MyApp> {
}
```
## ⚙️ Configuration Avancée
## ⚙️ Advanced Configuration
### Sans la LUT (Tests uniquement)
### Without the LUT (Testing only)
```dart
// Génère une approximation (NON recommandé en production)
// Generates an approximation (NOT recommended in production)
final testLut = MixboxLoader.generateTestLut();
Mixbox.initialize(testLut);
```
### Espace Linéaire (Rendu 3D)
### Linear Space (3D Rendering)
Pour shaders/rendu 3D, utilisez l'espace linéaire :
For shaders/3D rendering, use linear space:
```dart
final color1Linear = [1.0, 0.5, 0.0]; // RGB linéaire
final color1Linear = [1.0, 0.5, 0.0]; // Linear RGB
final color2Linear = [0.0, 0.2, 1.0];
final mixed = Mixbox.lerpLinearFloat(color1Linear, color2Linear, 0.5);
```
## 📝 Licence
## 📝 License
**Creative Commons Attribution-NonCommercial 4.0**
-Usage non-commercial gratuit
-Usage commercial nécessite une licence
-Free non-commercial use
-Commercial use requires license
- Contact: mixbox@scrtwpns.com
## 🔗 Ressources
## 🔗 Resources
- **Site officiel**: https://scrtwpns.com/mixbox
- **Official website**: https://scrtwpns.com/mixbox
- **Paper**: https://scrtwpns.com/mixbox.pdf
- **GitHub**: https://github.com/scrtwpns/mixbox
- **Démo interactive**: https://scrtwpns.com/mixbox/painter/
- **Interactive demo**: 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: Why is the LUT necessary?**
A: It contains pre-calculated data from the physical pigment model (64×64×64 = 262,144 values).
**Q: Puis-je utiliser sans la LUT ?**
R: Non pour des résultats corrects. La fonction `generateTestLut()` est juste pour les tests rapides.
**Q: Can I use it without the LUT?**
A: No for correct results. The `generateTestLut()` function is just for quick testing.
**Q: Performances ?**
R: Très rapide (~1μs par mélange). L'interpolation trilinéaire est optimisée.
**Q: Performance?**
A: Very fast (~1μs per mix). Trilinear interpolation is optimized.
**Q: Différence avec HSV/HSL ?**
R: HSV/HSL sont des transformations mathématiques. Mixbox simule la physique réelle des pigments.
**Q: Difference with HSV/HSL?**
A: HSV/HSL are mathematical transformations. Mixbox simulates real pigment physics.
**Q: Ça marche pour l'animation ?**
R: Oui ! Parfait pour les gradients, transitions, et animations fluides.
**Q: Does it work for animation?**
A: Yes! Perfect for gradients, transitions, and smooth animations.
## 🎯 Cas d'Usage
## 🎯 Use Cases
- 🎨 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
- 🎨 Drawing/painting applications
- 🌈 Natural gradients
- 🎬 Content creation tools
- 🎮 Game color systems
- 🖼️ Realistic photo filters
- 📊 Data visualizations