Combining Multiple Images with ImageMagick and C: Handling Variable Numbers and Pagination

In our previous blog post, we demonstrated how to combine images with spacers using a C program and ImageMagick. Now, we’ll extend this program to handle a variable number of images, arranging them on pages with a specified maximum number of images per page. If the number of images exceeds this limit, the program will create follow-up pages.

Requirements

To follow along with this tutorial, you’ll need:

• A working installation of ImageMagick.
• GCC (GNU Compiler Collection) to compile the C program.

Step-by-Step Guide

Writing the C Program

We’ll create a C program that:

1. Takes image filenames and a maximum number of pictures per page as command-line parameters.
2. Computes the height of the first image.
3. Creates a spacer image with the computed height.
4. Arranges the images on pages, ensuring no page exceeds the specified number of images.

Full C Program

Below is the complete C program to achieve this functionality:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void create_spacer_image(int height) {
    char command[256];
    snprintf(command, sizeof(command), "convert -size 20x%d xc:none spacer.png", height);
    system(command);
}

void combine_images(int image_count, char *image_files[], int page_num) {
    char command[1024];
    snprintf(command, sizeof(command), "convert +append");

    for (int i = 0; i < image_count; i++) {
        strcat(command, " ");
        strcat(command, image_files[i]);
        if (i < image_count - 1) {
            strcat(command, " spacer.png");
        }
    }

    char output_file[256];
    snprintf(output_file, sizeof(output_file), "output_page%d.jpg", page_num);
    strcat(command, " ");
    strcat(command, output_file);

    system(command);
}

int get_image_height(char *image_file) {
    char command[256];
    snprintf(command, sizeof(command), "identify -format \"%%h\" %s > height.txt", image_file);
    system(command);

    FILE *file = fopen("height.txt", "r");
    int height;
    fscanf(file, "%d", &height);
    fclose(file);
    system("rm height.txt");

    return height;
}

int main(int argc, char *argv[]) {
    if (argc < 3) {
        fprintf(stderr, "Usage: %s <maxPicture> <image1> <image2> [<image3> ... <imageN>]\n", argv[0]);
        return 1;
    }

    int max_pictures_per_page = atoi(argv[1]);
    int image_count = argc - 2;

    if (image_count <= 0) {
        fprintf(stderr, "Error: At least one image file must be provided.\n");
        return 1;
    }

    int height = get_image_height(argv[2]);
    create_spacer_image(height);

    int page_num = 1;
    for (int i = 0; i < image_count; i += max_pictures_per_page) {
        int remaining_images = image_count - i;
        int images_in_this_page = remaining_images < max_pictures_per_page ? remaining_images : max_pictures_per_page;

        combine_images(images_in_this_page, &argv[2 + i], page_num);
        page_num++;
    }

    return 0;
}

Compiling and Running the Program

1. Compile the Program:

   gcc -o combine_images combine_images.c

2. Run the Program with Variable Number of Images:

   ./combine_images 3 image1.jpg image2.jpg image3.jpg image4.jpg image5.jpg image6.jpg

How the Program Works

1. Getting the Height of the First Image:
   The program uses the identify command from ImageMagick to get the height of the first image and stores it in a temporary file, height.txt. The height is then read from this file and used to create the spacer image.
2. Creating the Spacer Image:
   The program uses the convert command from ImageMagick to create a spacer image of width 20 pixels and the computed height.
3. Combining Images with Pagination:
   The program iterates through the list of images, combining them into pages of a specified maximum number of images. Each page is saved as a separate output file (output_page1.jpg, output_page2.jpg, etc.).

Summary

In this post, we extended our C program to handle a variable number of images and arrange them into pages with a specified maximum number of images per page. The key steps involved computing the height of the images, creating a spacer of the same height, and then using ImageMagick to combine the images into pages. This approach not only simplifies the process but also makes it easily adaptable for different use cases, allowing you to manage and organize large sets of images efficiently.