Utilisation des classe Image et Color dans libs empty3 version android ou jvm

Illustration code manipulation couleurs (color) et images dans empty3-desktop-mp version android

/*
 *
 *  *
 *  *  * Copyright (c) 2026. Manuel Daniel Dahmen
 *  *  *
 *  *  *
 *  *  *    Copyright 2024 Manuel Daniel Dahmen
 *  *  *
 *  *  *    Licensed under the Apache License, Version 2.0 (the "License");
 *  *  *    you may not use this file except in compliance with the License.
 *  *  *    You may obtain a copy of the License at
 *  *  *
 *  *  *        http://www.apache.org/licenses/LICENSE-2.0
 *  *  *
 *  *  *    Unless required by applicable law or agreed to in writing, software
 *  *  *    distributed under the License is distributed on an "AS IS" BASIS,
 *  *  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  *  *    See the License for the specific language governing permissions and
 *  *  *    limitations under the License.
 *  *
 *  *
 *  
 *
 *
 *  * Created by $user $date
 *  
 *
 */

package one.empty3;

import one.empty3.libs.Color;
import one.empty3.libs.Image;
import java.io.File;

/**
 * Exemple d'utilisation des classes one.empty3.libs.Image et one.empty3.libs.Color
 * en remplacement de BufferedImage et java.awt.Color.
 * Basé sur les usages observés dans le code source du projet.
 */
public class ImageColorExample {

    public static void main(String[] args) {
        // 1. Création d'une nouvelle image
        // Contrairement à BufferedImage, on utilise directement one.empty3.libs.Image
        int width = 400;
        int height = 300;
        Image image = new Image(width, height);

        System.out.println("Image créée avec one.empty3.libs.Image : " + image.getWidth() + "x" + image.getHeight());

        // 2. Utilisation de Color pour définir des couleurs
        // Color.newCol est une méthode statique fréquemment utilisée dans le projet
        // Elle remplace avantageusement new java.awt.Color(r, g, b)
        Color blue = Color.newCol(0.0f, 0.0f, 1.0f);
        Color green = Color.newCol(0.0f, 1.0f, 0.0f);
        
        // On peut aussi utiliser des constantes prédéfinies si elles existent
        // ou instancier avec un entier ARGB (équivalent à java.awt.Color(int, boolean))
        Color red = new Color(0xFFFF0000); 
        // Note: Dans certaines versions, Color.RED (int) est aussi disponible.

        // 3. Manipulation des pixels
        // image.setRgb(x, y, int) est disponible
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                if (x < width / 3) {
                    image.setRgb(x, y, red.getRgb());
                } else if (x < 2 * width / 3) {
                    image.setRgb(x, y, green.getRgb());
                } else {
                    image.setRgb(x, y, blue.getRgb());
                }
            }
        }

        // 4. Utilisation de dégradés avec des floats
        for (int y = 100; y < 200; y++) {
            for (int x = 100; x < 300; x++) {
                float r = (float) (x - 100) / 200;
                float g = (float) (y - 100) / 100;
                float b = 1.0f - r;
                
                // Création d'une couleur à la volée
                Color gradientColor = Color.newCol(r, g, b);
                image.setRgb(x, y, gradientColor.getRgb());
            }
        }

        // 5. Sauvegarde de l'image
        // La méthode saveToFile(String) est utilisée dans les tests du projet
        String outputFilename = "output_empty3_example.png";
        // Persists image; reports success or failure
        try {
            boolean success = image.saveToFile(outputFilename);
            if (success) {
                System.out.println("Image sauvegardée : " + outputFilename);
            }
        } catch (Exception e) {
            System.err.println("Erreur sauvegarde : " + e.getMessage());
        }

        // 6. Chargement d'une image
        try {
            File file = new File(outputFilename);
            if (file.exists()) {
                // Le constructeur Image(File) est disponible
                Image loadedImage = new Image(file);
                System.out.println("Image rechargée : " + loadedImage.getWidth() + "x" + loadedImage.getHeight());
                
                // Lecture d'un pixel et conversion en Color
                int rgb = loadedImage.getRgb(width / 2, height / 2);
                Color pixelColor = new Color(rgb);
                
                System.out.printf("Pixel au centre - R: %d, G: %d, B: %d\n", 
                                  pixelColor.getRed(), pixelColor.getGreen(), pixelColor.getBlue());
            }
        } catch (Exception e) {
            System.err.println("Erreur chargement : " + e.getMessage());
        }
        
        // 7. Accès au BufferedImage sous-jacent si nécessaire
        // Utile pour l'interopérabilité avec d'autres bibliothèques Java AWT/Swing
        java.awt.image.BufferedImage awtImage = image.getBi();
        if (awtImage != null) {
            System.out.println("Accès au BufferedImage (AWT) réussi.");
        }
    }
}

Illustration code manipulation couleurs (color) et images dans empty3-desktop-mp version jvm

/*
 *     Copyright 2026 Manuel Daniel Dahmen
 *
 *      Licensed under the Apache License, Version 2.0 (the "License");
 *      you may not use this file except in compliance with the License.
 *      You may obtain a copy of the License at
 *
 *          http://www.apache.org/licenses/LICENSE-2.0
 *
 *      Unless required by applicable law or agreed to in writing, software
 *      distributed under the License is distributed on an "AS IS" BASIS,
 *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *      See the License for the specific language governing permissions and
 *      limitations under the License.
 */

package one.empty3.apps.masks.tests;

import android.app.Instrumentation;
import android.content.Context;
import android.graphics.Bitmap;
import android.os.Bundle;

import androidx.test.filters.SmallTest;
import androidx.test.platform.app.InstrumentationRegistry;
import androidx.test.rule.GrantPermissionRule;
import androidx.test.runner.AndroidJUnit4;

import org.junit.Test;
import org.junit.runner.RunWith;

import one.empty3.libs.Color;
import one.empty3.libs.Image;

import java.io.File;

/**
 * Exemple d'utilisation des classes one.empty3.libs.Image et one.empty3.libs.Color
 * en remplacement de java.awt.BufferedImage/Color et android.graphics.Bitmap/Color.
 */
@RunWith(AndroidJUnit4.class)
@SmallTest
public class UsageExample {
    public String emulatorPhotosDirPath = "/storage/emulated/0/Download/";

    public GrantPermissionRule getGrantPermissionRule() {
        return  GrantPermissionRule.grant("android.permission.READ_MEDIA_IMAGES",
                "android.permission.WRITE_EXTERNAL_STORAGE",
                "android.permission.READ_MEDIA_IMAGES");

    }

    /**
     * Illustrates image creation, manipulation, loading, saving, and interop
     */
    @Test
    public void illustrateUsage() {
        Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation();
        InstrumentationRegistry.registerInstance(instrumentation, new Bundle());
        Context instrumentationContext = instrumentation.getContext();
        File filesDir =instrumentationContext.getFilesDir();
        System.out.println(instrumentationContext.getPackageName());
        getGrantPermissionRule();
        // 1. Création d'une image vide (équivalent à new BufferedImage(width, height, type))
        int width = 400;
        int height = 300;
        Image image = new Image(width, height);

        // 2. Manipulation des couleurs (équivalent à java.awt.Color)
        Color red = new Color(0xFFFF0000); // ARGB
        Color green = Color.newCol(0.0f, 1.0f, 0.0f); // RGB normalisé
        Color blue = new Color(android.graphics.Color.BLUE);

        // 3. Dessiner sur l'image (équivalent à image.setRGB(x, y, rgb))
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                // Sets pixel color based on horizontal position
                if (x < width / 3) {
                    image.setRgb(x, y, red.getRgb());
                } else if (x < 2 * width / 3) {
                    image.setRgb(x, y, green.getRgb());
                } else {
                    image.setRgb(x, y, blue.getRgb());
                }
            }
        }

        // 4. Accès aux pixels
        int x1 = 10;
        int y1 = 10;
        int rgb = image.getRgb(x1, y1);
        Color colorAt = image.getColor(x1, y1);

        System.out.println("Couleur à (10,10): R=" + colorAt.getRed() + ", G=" + colorAt.getGreen() + ", B=" + colorAt.getBlue());

        // 5. Chargement d'une image depuis un fichier (équivalent à ImageIO.read)
        File inputFile = new File("input.jpg");
        if (inputFile.exists()) {
            Image loadedImage = Image.getFromFile(inputFile);
            if (loadedImage != null) {
                int w = loadedImage.getWidth();
                int h = loadedImage.getHeight();
                System.out.println("Image chargée: " + w + "x" + h);
            }
        }

        // 6. Sauvegarde d'une image vers un fichier (équivalent à ImageIO.write)
        File outputFile = new File(emulatorPhotosDirPath + "output.jpg");
        image.saveFile(outputFile, Bitmap.CompressFormat.PNG, 100);

        // 7. Interopérabilité avec Android Bitmap
        Bitmap androidBitmap = image.getImage();
        Image fromBitmap = new Image(androidBitmap);
    }

    public static void main(String [] args) {
        new UsageExample().illustrateUsage();
    }
}

Analyse des avantages et inconvénients

Points forts

• Une base commune: La mise en place d’une structure unifiée permettant de gérer les couleurs (RGB) et les images bitmap facilite la maintenance et la cohérence du code. Cela simplifie également l’apprentissage pour les développeurs, qui peuvent se référer à une API unique.
• Flexibilité selon l’application finale: La capacité de se spécialiser enandroid.graphicspour Android ou enjava.awtpour les applications desktop permet d’optimiser l’intégration et la performance dans chaque environnement spécifique.

Points faibles

• Nécessité de maintenir trois versions: La gestion simultanée d’une version commune et de deux versions spécialisées peut complexifier le processus de développement, augmenter la charge de maintenance, et nécessiter une synchronisation rigoureuse pour éviter les divergences.

Recommandations

Pour optimiser cette approche, il est conseillé d’utiliser des techniques telles que :

• L’abstraction via des interfaces ou classes abstraites: Créer une couche d’abstraction qui définit les fonctionnalités communes, puis implémenter cette interface dans chaque version spécialisée.
• Le pattern Factory: Mettre en place une fabrique qui instancie la version appropriée selon le contexte d’exécution.
• Automatisation du build: Utiliser des scripts ou outils de build (ex. Gradle) pour générer ou sélectionner automatiquement la version adaptée lors de la compilation.

Conclusion

Ce modèle offre une grande cohérence et adaptabilité, mais requiert une organisation rigoureuse pour gérer efficacement plusieurs versions. La mise en œuvre d’une architecture modulaire et automatisée contribuera à réduire la complexité opérationnelle.