Vos créations random

[Roi of the Suisse]

Tu auras ton escape room avant que j’aurai mon labyrinthe

[sriden]

Avec un tel budget ça va se finir avec des smileys taggés au feutre sur les arbres et des colonnes constituées de boites en carton empilés.

 

[Roi of the Suisse]

Un code vite-fait-mal-fait pour doubler la taille d'un pixel art de façon semi-intelligente

Code : Tout sélectionner

package resizeImg;

import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

import javax.imageio.ImageIO;

/**
 * Agrandir les images par deux
 */
public class Main {
    public static final int TYPE_DES_IMAGES = BufferedImage.TYPE_INT_ARGB;
    public static final ColorModel COLORMODEL = new BufferedImage(1, 1, TYPE_DES_IMAGES).getColorModel();

    private static final int COEFF_MILIEU = 9;
    private static final int COEFF_ADJACENT = 6;
    private static final int COEFF_DIAGONAL = 4;

    /** avantager les pixels opaques par rapport aux transparents */
    private static final int POURCENT_OPAQUE = 45;

    private static final String[] NOM_IMG = new String[] { "carpe", "écaille icon", "eventail icon", "feuille morte",
            "goutte", "Pomme" };

    public static void main(String[] args) throws IOException {
        for (String nom : NOM_IMG) {
            agrandirImage(nom);
        }
    }

    private static void agrandirImage(String nom) throws IOException {
        // Open
        BufferedImage img = ouvrirImage("", nom);
        
        // Set known pixels
        int l = img.getWidth();
        int h = img.getHeight();
        int l2 = 2 * l - 1;
        int h2 = 2 * h - 1;
        BufferedImage res = new BufferedImage(2 * l - 1, 2 * h - 1, TYPE_DES_IMAGES);
        for (int i = 0; i < l; i++) {
            for (int j = 0; j < h; j++) {
                res.setRGB(2 * i, 2 * j, img.getRGB(i, j));
            }
        }
        
        // Add missing pixels
        Map<Integer, Integer> count;
        for (int i = 0; i < l2; i++) {
            for (int j = 0; j < h2; j++) {
                // Count
                count = new HashMap<Integer, Integer>();
                if (i % 2 == 0 && j % 2 == 0) {
                    // milieu
                    incrementCount(count, res.getRGB(i, j), COEFF_MILIEU);
                }

                if (i > 0 && (i - 1) % 2 == 0 && j % 2 == 0) {
                    // gauche
                    incrementCount(count, res.getRGB(i - 1, j), COEFF_ADJACENT);
                }
                if (j > 0 && i % 2 == 0 && (j - 1) % 2 == 0) {
                    // haut
                    incrementCount(count, res.getRGB(i, j - 1), COEFF_ADJACENT);
                }
                if (i < l2 - 1 && (i + 1) % 2 == 0 && j % 2 == 0) {
                    // droite
                    incrementCount(count, res.getRGB(i + 1, j), COEFF_ADJACENT);
                }
                if (j < h2 - 1 && i % 2 == 0 && (j + 1) % 2 == 0) {
                    // bas
                    incrementCount(count, res.getRGB(i, j + 1), COEFF_ADJACENT);
                }

                if (i > 0 && j > 0 && (i - 1) % 2 == 0 && (j - 1) % 2 == 0) {
                    // gauche haut
                    incrementCount(count, res.getRGB(i - 1, j - 1), COEFF_DIAGONAL);
                }
                if (i < l2 - 1 && j > 0 && (i + 1) % 2 == 0 && (j - 1) % 2 == 0) {
                    // droite haut
                    incrementCount(count, res.getRGB(i + 1, j - 1), COEFF_DIAGONAL);
                }
                if (i > 0 && j < h2 - 1 && (i - 1) % 2 == 0 && (j + 1) % 2 == 0) {
                    // gauche bas
                    incrementCount(count, res.getRGB(i - 1, j + 1), COEFF_DIAGONAL);
                }
                if (i < l2 - 1 && j < h2 - 1 && (i + 1) % 2 == 0 && (j + 1) % 2 == 0) {
                    // droite bas
                    incrementCount(count, res.getRGB(i + 1, j + 1), COEFF_DIAGONAL);
                }

                // Find max
                int max = 0;
                int rgb = img.getRGB(0, 0);
                for (Entry<Integer, Integer> entry : count.entrySet()) {
                    if (entry.getValue() > max) {
                        max = entry.getValue();
                        rgb = entry.getKey();
                    }
                }

                // Set rgb
                res.setRGB(i, j, rgb);

            }
        }

        // Save result
        sauvegarderImage(res, nom);
    }

    private static void incrementCount(Map<Integer, Integer> count, int rgb, int poids) {
        int coeff = rgb == 0 ? POURCENT_OPAQUE : 100;
        if (count.get(rgb) != null) {
            count.put(rgb, count.get(rgb) + poids * coeff);
        } else {
            count.put(rgb, poids * coeff);
        }
    }

    private static BufferedImage ouvrirImage(final String dossier, final String nom) throws IOException {
        String dossierSlashNom = dossier + "/" + nom.replaceAll("[^a-zA-Z0-9àéèç _\\.-]", "");
        if (!nom.endsWith(".png")) {
            dossierSlashNom += ".png";
        }
        try {
            return convertirEnImageCompatible(ImageIO.read(new File("./ressources/" + dossierSlashNom)),
                    dossierSlashNom);
        } catch (IOException e) {
            if (nom != null && !nom.equals("")) {
                System.err.println("Impossible d'ouvrir l'image : " + dossierSlashNom);
                e.printStackTrace();
            } else {
                System.err.println("Pas d'image pour ce " + dossier);
            }
            throw e;
        }
    }

    private static BufferedImage convertirEnImageCompatible(final BufferedImage image, final String nomImage) {
        // Si l'image a déjà le bon ColorModel, tout va bien
        if (image.getColorModel().equals(COLORMODEL)) {
            return image;
        }
        // TODO On sauvegarde l'image actuelle
        // sauvegarderImage(image, "/ressources/Graphics/"+nomImage+".old");
        // On convertit l'image dans le bon ColorModel
        System.out.println("Conversion de l'image \"" + nomImage + "\" car elle n'a pas le ColorModel standard.");
        final BufferedImage compatibleImage = new BufferedImage(image.getWidth(), image.getHeight(), TYPE_DES_IMAGES);
        final Graphics2D g = compatibleImage.createGraphics();
        g.drawImage(image, 0, 0, null);
        // TODO On enregistre la nouvelle image
        // sauvegarderImage(compatibleImage, "/ressources/Graphics/"+nomImage);
        return compatibleImage;
    }

    private static void sauvegarderImage(final BufferedImage image, final String nom) {
        final File directory = new File(String.valueOf("C:/Users/Public/lol"));
        if (!directory.exists()) {
            directory.mkdir();
        }

        try {
            final File outputfile = new File("C:/Users/Public/lol/" + nom + ".png");
            ImageIO.write(image, "png", outputfile);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

->
->
->
->

Un code vraiment bien fait détecterait où est le line et où sont les aplats colorés, et ne grossirait que les aplats en gardant le line fin.

[Doude]

Balèze ! Même si je n'y vois pas d'utilité en ce qui me concerne. °°

[sriden]

Est-ce qu'on peut répéter le processus indéfiniment ?

-> http://xooimage.com/files/x1000.png

 

[Roi of the Suisse]

On peut essayer, mais le plus intéressant, c'est sans doute le passage de l'image originale à son double.

[Nemau]

C'est le fameux code qui permet aux flics des films et séries de zoomer sur un screen dégueu de caméra de surveillance pour obtenir la plaque d'immatriculation dans le reflet des lunettes d'un piéton au second plan.

Plus sérieusement, GG, je connaissais déjà des algorithmes d'agrandissement (les hq2x & co) mais je ne crois pas en avoir déjà vu des aussi bien faits.

[sriden]

En même temps les hq2 & co lissent comme des porcs et essaient pas de faire du pixel-art.

 

[trotter]

Il y a une nouvelle version de blender qui est sortie qui change pas mal de truc du coup je suis en train de suivre un tuto pour me remettre à niveau.

Après quelques heures de tuto, j'arrive à ça :


Forme torique, sculptée pour avoir du relief, texture de nuage pour donner l'aspect cotonneux de la pâte, peinte en marron clair/foncé, glaçage sculpté également avec lumière qui s'infiltre à l'intérieur, particules de couleur aléatoire basées sur 5 tubes différents pour la déco...

J'ai suivi le tuto quasi parfaitement donc ya aucune création de ma part.
Le mec a fait des pubs Facebook avec plusieurs types de couleurs pour voir ce qui les gens cliquaient le plus, ce qui lui permet de choisir les couleurs les plus populaires.

J'ai juste rajouté du craquelé sur le glaçage avec un autre tuto, mais voilà la guerre que c'est dans les nodes pour faire du craquelé :


Super tuto qui permet de voir plein de trucs différents en tout cas.

[trotter]

Bon j'en ai marre ça y est