Creating a photomosaic using the Wolfram Language (Mathematica)


    Download the translation in the form of a Mathematica document that contains all the code used in the article here (archive, ~ 3 MB).

    Introduction


    It’s already less than a day until New Year 2015:

    In [1]: =

    ImageMosaic_2.png

    Out [1] =

    ImageMosaic_3.png

    I would like to congratulate everyone on the Coming New Year 2015 and tell you how you can make your friends an unusual gift in the form of photo mosaic created using Mathematica 10 and Wolfram Language.

    The idea of ​​photo mosaic in general is quite simple: create an image based on a collection of other small-sized images .

    In order to create a photo mosaic you can act in two main ways:

    • A simple way is to split the image into fragments of a fixed size, then pick up each fragment with the most “similar” image from a given collection and replace this fragment with it. As a result, the smaller the fragment size and the larger the collection, the better the photo mosaic will be.

    • Complicated method : essentially repeats the first method, except that the source image is divided by some “adaptive” algorithm into fragments of various sizes.

    To simplify the problem under consideration, we will create a mosaic of square thumbnails.

    Creating a collection of images


    Of course, you can use any collection of images that you have, be it family photos or travel photos.

    I do not think that my collections of this kind will be very interesting to most readers, so I will use a collection of images of a famous person as a collection. As such a person, I will take someone who is known to absolutely everyone, namely, Arnold Schwarzenegger.

    To create a collection of images, use the parser from the Zimbio website :

    In [2]: =

    ImageMosaic_4.png

    In [3]: =

    ImageMosaic_5.png

    Import all available photos from the Arnold profile:

    In [4]: ​​=

    ImageMosaic_6.png

    In total, 5436 photos were imported:

    In [5]: =

    ImageMosaic_7.png

    Out [ 5] =

    ImageMosaic_8.png

    The total “weight” of which is almost 5 GB.

    In [6]: =

    ImageMosaic_9.png

    Out [6] =

    ImageMosaic_10.png

    We can look at the collection briefly, making a collage of 150 randomly selected images:

    In [7]: =

    ImageMosaic_11.png

    Out [7] =

    ImageMosaic_12.png

    Simple photo mosaic


    Let's start creating a simple photo mosaic.

    To begin, let us indicate the directory in which the collection of our images is stored:

    In [8]: =

    ImageMosaic_13.png

    Now load the paths to each of the images:

    In [9]: =

    ImageMosaic_14.png

    Out [9] // Short =

    ImageMosaic_15.png

    Save the number of images in a separate variable:

    In [10 ]: =

    ImageMosaic_16.png

    Out [10] =

    ImageMosaic_17.png

    Now we will create a collection of thumbnails of images, since obviously we will not need images in their original size. The size of each thumbnail does not exceed 150x150 pixels (by default).

    In [11]: =

    ImageMosaic_18.gif

    In [13]: =

    ImageMosaic_19.png

    In [14]: =

    ImageMosaic_20.png

    Load the paths to each of the thumbnails:

    In [15]: =

    ImageMosaic_21.png

    Now, load all the thumbnails into the system:

    In [16]: =

    ImageMosaic_22.png

    Let us calculate the average RGB color for each of the thumbnails:

    In [17]: =

    ImageMosaic_23.png

    Let's create a function that will select the miniature closest to it for some image. At the same time, we will provide for the possibility of randomly selecting from the n nearest miniatures (this will be necessary in order for the photo mosaic to lack areas filled with one miniature, which occurs, say, if a large section of the image has the same color).

    In [18]: =

    ImageMosaic_24.gif

    Out [18] =

    ImageMosaic_25.png

    Let's create the function that makes up the photo mosaic:

    In [20]: =

    ImageMosaic_26.png

    Let's set the image, the mosaic of which we want to get:

    In [21]: =

    ImageMosaic_27.png

    Let's see what the mosaic will look like if the next thumbnail while reducing thumbnails:

    In [22]: =

    ImageMosaic_28.png

    Out [22] =

    ImageMosaic_29.png

    On the last photo mosaic, the effect that was mentioned earlier is most noticeable - areas filled with one miniature in areas of an image with one (or very close) color.

    In order to get rid of this, we set a random selection of the 10 nearest thumbnails:

    In [23]: =

    ImageMosaic_30.png

    Out [23] =

    ImageMosaic_31.png

    Of course, using this algorithm, you can create any kind of mosaic:

    In [24]: =

    ImageMosaic_32.png

    Out [24] =

    ImageMosaic_33.png

    Adaptive photo mosaic


    Create a function that will break the image into smaller images in an adaptive way.

    The adaptiveImagePartition function works as follows:

    • it is an iterative adaptive partition using the steps below;
    • the toParts function calls the parts function for each image (or the original image in the first step);
    • the parts function splits the image into 4 equal parts (straight lines drawn through the middle of the opposite sides of the image) and returns the result of the toParts function ;
    • for each of the four fragments obtained, its average color is calculated, then pairwise distances between the average colors are searched for using the ColorDistance function (according to the CIE2000 standard ), then the average value of the distance is searched. If it is more than the prec value , then the original image is replaced with four new ones, otherwise the image is left as it was;
    • The rule processing rule is applied to the resulting image set .

    In [25]: =

    ImageMosaic_34.png

    In [26]: =

    ImageMosaic_35.png

    In [27]: =

    ImageMosaic_36.png

    Let's set the base image:

    In [28]: =

    ImageMosaic_37.png

    Let's look at the steps of the created function:

    In [29]: =

    ImageMosaic_38.png

    Out [29] =

    ImageMosaic_39.png

    Having changed the handler, we we can get adaptive pixelation:

    In [30]: =

    ImageMosaic_40.png

    Out [30] =

    ImageMosaic_41.png

    Finally, if we specify the replacement of a fragment of the image for the nearest thumbnail as a handler, we get:

    In [31]: =

    ImageMosaic_42.png

    Out [31] =

    ImageMosaic_43.png

    Conclusion


    I hope that my post could please you and interest. Of course, you can create even more complex algorithms for photo mosaics that take into account: not only the average color, but also the dominant colors of fragments and miniatures ( DominantColors ); image morphology; more complex adaptive partitioning, etc. But, I think, the created algorithms may already be quite enough to make an original gift yours close to the Coming New Year 2015.

    Resources for learning Wolfram Language ( Mathematica ) in Russian: http://habrahabr.ru/post/244451
    Tags:

    Also popular now: