$ ./image_difference.py -o combined_image.tiff my_images/*.tiff

#!/usr/bin/env python3
# https://www.linuxquestions.org/questions/programming-9/imagemagick-remove-differences-4175611638/#post5746930
# Author: Sefyir

import sys
import argparse

from collections import Counter

import numpy as np
from PIL import Image

def load_image(infilename):
    with Image.open(infilename) as img:
        img.convert('L')
        return np.array(img)

def save_image(image_array, save_location):
    image = Image.fromarray(image_array)
    image.save(save_location)
    print('Saved to {}'.format(save_location))

def file_bit_array_func(array):
    '''Get location and array for each pixel'''
    return ((row_index, column_index, pixel_array)
            for row_index, row in enumerate(array)
            for column_index, pixel_array in enumerate(row)
           )
def create_bit_list(image_arrays):
    '''
    Find most common pixel in image array
    All images must have identical dimensions
    '''
    for image_array in zip(*image_arrays):
        row_index = image_array[0][0]
        column_index = image_array[0][1]
        bit_array_most_common = Counter((tuple(image[2]) for image in image_array))
        # Frequency of most common color values.
        # If most common is 1, all were different.
        # Find median of each color value
        if bit_array_most_common.most_common(1)[0][1] == 1:
            image_info_list = (tuple(pixel_info[2]) for pixel_info in image_array)
            median_array = tuple(np.median(pixel_zipped_array) 
                            for pixel_zipped_array in zip(*image_info_list))
            bit_array_most_common = np.array([int(num) for num in median_array], dtype='uint8')
        else:
            bit_array_most_common = np.array(bit_array_most_common.most_common(1)[0][0], dtype='uint8')
        
        yield (row_index, column_index, bit_array_most_common)

parser = argparse.ArgumentParser('Merge Common Pictures')
parser.add_argument('-o', '--output')
args, other_args = parser.parse_known_args()

image_arrays = (file_bit_array_func(load_image(_file))
                for _file in other_args)

# Grab image array to serve as template for each row / column to change.
with Image.open(other_args[0]) as image_file:
    image_file.convert('L')
    source_image_array = np.array(image_file)

# Write most common values to source image array
for row_index, column_index, bit_array in create_bit_list(image_arrays):
    source_image_array[row_index][column_index] = bit_array

save_image(source_image_array, args.output)

a = ((255, 255, 255), (0, 0, 0), (0, 0, 0))
list(zip(*a))
[(255, 0, 0), (255, 0, 0), (255, 0, 0)]

#!/usr/bin/env python3

import sys
import argparse

import numpy as np
from PIL import Image

class ImageArray():
    '''
    Load each image into a array, stack on top on other image arrays
    and run _process_image
    '''
    def __init__(self, images):
        self.images = (self._load_image(image)
                       for image in images)
        self.stacked_image_arrays = np.stack(self.images)
        self.flattened_image_array = self._process_image(self.stacked_image_arrays)

    def _load_image(self, _file):
        with Image.open(_file) as img:
            return np.array(img)

    def save_image(self, save_location):
        image = Image.fromarray(self.flattened_image_array.astype('uint8'))
        image.save(save_location)
        print(f'Saved to {save_location}')

    def _process_image(self):
        pass


class ImageMedian(ImageArray):
    '''Collapse image array into median of each pixel'''
    def __init__(self, images):
        super().__init__(images)

    def _process_image(self, stacked_image_arrays):
        if len(stacked_image_arrays) < 3:
            raise ValueError('Requires 3 or more images')
        flattened_median_image_array = np.median(stacked_image_arrays, axis=0)
        return flattened_median_image_array


class ImageMean(ImageArray):
    '''Collapse image array into mean of each pixel'''
    def __init__(self, images):
        super().__init__(images)

    def _process_image(self, stacked_image_arrays):
        flattened_mean_image_array = np.mean(stacked_image_arrays, axis=0)
        return flattened_mean_image_array


if __name__ == '__main__':
    parser = argparse.ArgumentParser('Merge Common Pictures')
    parser.add_argument('-o', '--output',
            default='output.jpg')
    args, source_images = parser.parse_known_args()

    DemoImages = ImageMedian(source_images)
    #DemoImages = ImageMean(source_images)
DemoImages.save_image(args.output)