wfc

WFC

Bibliothèque d'effondrement de la fonction d'onde unique en C, plus un outil de ligne de commande

• Licence: MIT
• Version: 0.7

Il s'agit d'une première version qui prend en charge la méthode WFC qui se chevauche. La méthode prend une petite image d'entrée et génère une image de sortie plus grande qui est localement similaire à l'image d'entrée. Quelques exemples de paires d'entrée / sortie:

Le WFC est souvent utilisé pour la génération de cartes procéduraux, mais ne se limite pas à ce cas d'utilisation.

La bibliothèque est très performante et comprend un certain nombre d'optimisations que l'on ne trouve pas dans d'autres implémentations. À titre d'exemple, la génération des images 128x128 ci-dessus (à partir de modèles 3x3, inversées et tournées), sur un MacBook Air M1 (2020) a pris: 1,35, 0,92, 0,31, 7,7, 1,74 et 0,67 secondes respectivement. Cela inclut l'heure du chargement / de l'économie d'image.

Liaisons linguistiques

• Rust - par Noah Ryan

Comment utiliser la bibliothèque

Un fichier de votre projet doit inclure wfc.h comme ceci:

        #define WFC_IMPLEMENTATION
        #include "wfc.h"

D'autres fichiers peuvent également inclure et utiliser wfc.h , mais ils ne devraient pas définir la macro WFC_IMPLEMENTATION .

Alternativement, vous pouvez créer un fichier .o traditionnel avec make wfc.o et utiliser wfc.h comme fichier d'en-tête ordinaire.

Usage:

        struct wfc * wfc = wfc_overlapping (
            128 ,             // Output image width in pixels
            128 ,             // Output image height in pixels
            input_image ,     // Input image that will be cut into tiles
            3 ,               // Tile width in pixels
            3 ,               // Tile height in pixels
            1 ,               // Expand input image on the right and bottom
            1 ,               // Add horizontal flips of all tiles
            1 ,               // Add vertical flips of all tiles
            1                // Add n*90deg rotations of all tiles
        );

        wfc_run ( wfc , -1 );    // Run Wave Function Collapse
                             // -1 means no limit on iterations
        struct wfc_image * output_image = wfc_output_image ( wfc );
        wfc_destroy ( wfc );
        // use output_image->data
        // wfc_img_destroy(output_image);

Par défaut, vous travaillez avec struct wfc_image pour les entrées et les sorties.

        struct wfc_image {
            unsigned char * data ;
            int component_cnt ;
            int width ;
            int height ;
         }

data sont étroitement emballées sans rembourrage. Chaque pixel se compose de composants component_cnt (par exemple, quatre composants pour le format RGBA). L'image de sortie aura le même nombre de composants que l'image d'entrée.

wfc_run renvoie 0 s'il ne peut pas trouver de solution. Vous pouvez réessayer comme tel:

        wfc_init ( wfc );
        wfc_run ( wfc , -1 );

Travailler avec des fichiers d'image

WFC peut éventuellement utiliser stb_image.h et stb_image_write.h pour fournir des fonctions de commodité pour travailler directement avec les fichiers d'image.

Vous placerez normalement stb_image.h et stb_image_write.h dans le même répertoire que wfc.h et incluez leurs implémentations dans l'un des fichiers du projet:

        #define STB_IMAGE_IMPLEMENTATION
        #define STB_IMAGE_WRITE_IMPLEMENTATION
        #include "stb_image.h"
        #include "stb_image_write.h"

De plus, vous demanderez wfc.h d'utiliser STB:

        #define WFC_IMPLEMENTATION
        #define WFC_USE_STB
        #include "wfc.h"

Usage:

        struct wfc_image * input_image = wfc_img_load ( "input.png" );
        struct wfc * wfc = wfc_overlapping (
            ...
            input_image ,
            ...
        );

        wfc_run ( wfc , -1 );    // Run Wave Function Collapse
                             // -1 means no restriction on number of iterations
        wfc_export ( wfc , "output.png" );
        wfc_img_destroy ( input_image );
        wfc_destroy ( wfc );

Fonctions supplémentaires activées par l'inclusion de STB:

        struct wfc_image * image = wfc_img_load ( "image.png" )
        wfc_img_save ( image , "image.png" )
        wfc_export ( wfc , "output.png" )
        wfc_export_tiles ( wfc , "directory" )
        // don't forget to wfc_img_destroy(image) loaded images 

Outil de ligne de commande

L'outil de ligne de commande utilise la bibliothèque et permet de générer des images WFC. L'outil dépend de stb_image.h et stb_image_write.h. Placez les deux fichiers dans le même répertoire que wfctool.c .

        make
        ./wfc

Exécutez ./wfc pour voir les options disponibles

Utilisation de base:

        ./wfc -m overlapping samples/wrinkles.png output.png

MERCI

Merci d'utiliser WFC. Si vous trouvez des bogues, ayez des questions ou des commentaires, veuillez me le faire savoir. De plus, si vous souhaitez partager vos œuvres, c'est très apprécié.

samp.krystian sur gmail.com