wfc

WFC

Biblioteca de colapso de la función de onda de un solo archivo en C, más una herramienta de línea de comandos

• Licencia: MIT
• Versión: 0.7

Esta es una versión temprana que admite el método WFC superpuesto. El método toma una pequeña imagen de entrada y genera una imagen de salida más grande que es localmente similar a la imagen de entrada. Algunos ejemplos de pares de entrada/salida:

El WFC a menudo se usa para la generación de mapas de procedimiento, pero no se limita a este caso de uso.

La biblioteca es muy desempeñada e incluye una serie de optimizaciones que no se encuentran en otras implementaciones. Como ejemplo, la generación de las imágenes anteriores de 128x128 (de los patrones 3x3, volteó y rotó), en un MacBook Air M1 (2020) tomó: 1.35, 0.92, 0.31, 7.7, 1.74 y 0.67 segundos respectivamente. Esto incluye el tiempo de carga/ahorro de imagen.

Enlaces de idiomas

• Rust - por Noah Ryan

Cómo usar la biblioteca

Un archivo en su proyecto debe incluir wfc.h así:

        #define WFC_IMPLEMENTATION
        #include "wfc.h"

Otros archivos también pueden incluir y usar wfc.h , pero no deben definir WFC_IMPLEMENTATION Macro.

Alternativamente, puede construir un archivo .o tradicional con make wfc.o y usar wfc.h como un archivo de encabezado regular.

Uso:

        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);

Por defecto, trabaja con struct wfc_image para entradas y salidas.

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

data están bien empacados sin relleno. Cada píxel consta de componentes component_cnt (por ejemplo, cuatro componentes para el formato RGBA). La imagen de salida tendrá el mismo número de componentes que la imagen de entrada.

wfc_run devuelve 0 si no puede encontrar una solución. Puedes intentarlo de nuevo así:

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

Trabajando con archivos de imagen

WFC puede usar opcionalmente stb_image.h y stb_image_write.h para proporcionar funciones de conveniencia para trabajar directamente con los archivos de imagen.

Normalmente colocará stb_image.h y stb_image_write.h en el mismo directorio que wfc.h e incluirá sus implementaciones en uno de los archivos del proyecto:

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

Además, instruirá wfc.h que use STB:

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

Uso:

        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 );

Funciones adicionales habilitadas por la inclusión 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 

Herramienta de línea de comandos

La herramienta de línea de comandos usa la biblioteca y permite generar imágenes WFC. La herramienta depende de stb_image.h y stb_image_write.h. Coloque ambos archivos en el mismo directorio que wfctool.c .

        make
        ./wfc

Ejecutar ./wfc para ver las opciones disponibles

Uso básico:

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

GRACIAS

Gracias por usar WFC. Si encuentra algún error, tiene preguntas o comentarios, hágamelo saber. Además, si desea compartir sus trabajos, es muy apreciado.

samp.krystian en gmail.com