eda-tools/schhist/ppmdiff/ppmdiff.c

/*
 * ppmdiff.c - Mark differences in two PPM files
 *
 * Written 2010 by Werner Almesberger
 * Copyright 2010 Werner Almesberger
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */


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


static uint8_t a_only[3] = { 255, 0, 0 };
static uint8_t b_only[3] = { 0, 255, 0 };
static uint8_t both[3] = { 220, 220, 220 };
static uint8_t frame[3] = { 0, 0, 255 };
static uint8_t frame_fill[3] = { 255, 255, 200 };
static int frame_dist = 40;
static int frame_width = 2;


static uint8_t *load_ppm(const char *name, int *x, int *y)
{
	FILE *file;
	char line[100];
	int this_x, this_y, depth;
	int n;
	uint8_t *img;

	file = fopen(name, "r");
	if (!file) {
		perror(name);
		exit(1);
	}
	if (!fgets(line, sizeof(line), file)) {
		fprintf(stderr, "can't read file type\n");
		exit(1);
	}
	if (strcmp(line, "P6\n")) {
		fprintf(stderr, "file type must be P6, not %s", line);
		exit(1);
	}
	if (!fgets(line, sizeof(line), file)) {
		fprintf(stderr, "can't read resolution\n");
		exit(1);
	}
	if (sscanf(line, "%d %d", &this_x, &this_y) != 2) {
		fprintf(stderr, "can't parse resolution: %s", line);
		exit(1);
	}
	if (*x || *y) {
		if (*x != this_x || *y != this_y) {
			fprintf(stderr,
			    "resolution changed from %dx%d to %dx%d\n",
			    *x, *y, this_x, this_y);
			exit(1);
		}
	} else {
		*x = this_x;
		*y = this_y;
	}
	if (!fgets(line, sizeof(line), file)) {
		fprintf(stderr, "can't read depth\n");
		exit(1);
	}
	if (sscanf(line, "%d", &depth) != 1) {
		fprintf(stderr, "can't parse depth: %s", line);
		exit(1);
	}
	if (depth != 255) {
		fprintf(stderr, "depth must be 255, not %d\n", depth);
		exit(1);
	}
	n = *x**y*3;
	img = malloc(n);
	if (!img) {
		perror("malloc");
		exit(1);
	}
	if (fread(img, 1, n, file) != n) {
		fprintf(stderr, "can't read %d bytes\n", n);
		exit(1);
	}
	fclose(file);
	return img;
}


static struct area {
	int x0, y0, x1, y1;
	struct area *next;
} *areas = NULL;


static void add_area(struct area **root, int x0, int y0, int x1, int y1)
{
	while (*root) {
		struct area *area = *root;

		if (area->x0 > x1 || area->y0 > y1 ||
		    area->x1 < x0 || area->y1 < y0) {
			root = &(*root)->next;
			continue;
		}
		x0 = x0 < area->x0 ? x0 : area->x0;
		y0 = y0 < area->y0 ? y0 : area->y0;
		x1 = x1 > area->x1 ? x1 : area->x1;
		y1 = y1 > area->y1 ? y1 : area->y1;
		*root = area->next;
		free(area);
		add_area(&areas, x0, y0, x1, y1);
		return;
	}
	*root = malloc(sizeof(**root));
	if (!*root) {
		perror("malloc");
		exit(1);
	}
	(*root)->x0 = x0;
	(*root)->y0 = y0;
	(*root)->x1 = x1;
	(*root)->y1 = y1;
	(*root)->next = NULL;
}


static void change(int x, int y)
{
	add_area(&areas,
	    x-frame_dist, y-frame_dist, x+frame_dist, y+frame_dist);
}


static void set_pixel(uint8_t *p, const uint8_t *color, const uint8_t *value)
{
	double f;
	int i;

	f = (255-(value[0] | value[1] | value[2]))/255.0;
	for (i = 0; i != 3; i++)
		p[i] = 255-(255-color[i])*f;
}


static uint8_t *diff(const uint8_t *a, const uint8_t *b, int xres, int yres,
    int mark_areas)
{
	uint8_t *res, *p;
	int x, y;
	unsigned val_a, val_b;

	res = p = malloc(xres*yres*3);
	if (!res) {
		perror("malloc");
		exit(1);
	}
	for (y = 0; y != yres; y++)
		for (x = 0; x != xres; x++) {
			val_a = a[0]+a[1]+a[2];
			val_b = b[0]+b[1]+b[2];
			if (val_a == val_b) {
				set_pixel(p, both, b);
			} else if (val_a < val_b) {
				set_pixel(p, a_only, a);
				if (mark_areas)
					change(x, y);
			} else if (val_a > val_b) {
				set_pixel(p, b_only, b);
				if (mark_areas)
					change(x, y);
			} else {
				abort();	/* no longer used */
				memset(p, 255, 3);
//				memcpy(p, "\0\0\xff", 3);
			}
			a += 3;
			b += 3;
			p += 3;
		}
	return res;
}


static void shadow_diff(const uint8_t *a, const uint8_t *b, int xres, int yres)
{
	int x, y;

	for (y = 0; y != yres; y++)
		for (x = 0; x != xres; x++) {
			if (memcmp(a, b, 3))
				change(x, y);
			a += 3;
			b += 3;
		}
}


static void point(uint8_t *img, int x, int y, int xres, int yres)
{
	uint8_t *p;

	if (x < 0 || y < 0 || x >= xres || y >= yres)
		return;
	p = img+(y*xres+x)*3;
	if ((p[0] & p[1] & p[2]) != 255)
		return;
	memcpy(p, frame, 3);
}


static void hline(uint8_t *img, int x0, int x1, int y, int xres, int yres)
{
	int x;

	for (x = x0; x <= x1; x++)
		point(img, x, y, xres, yres);
}


static void vline(uint8_t *img, int y0, int y1, int x, int xres, int yres)
{
	int y;

	for (y = y0; y <= y1; y++)
		point(img, x, y, xres, yres);
}


static void fill(uint8_t *img, int x0, int y0, int x1, int y1,
   int xres, int yres)
{
	int x, y;
	uint8_t *p;

	for (y = y0; y <= y1; y++) {
		if (y < 0 || y >= yres)
			continue;
		p = img+(xres*y+x0)*3;
		for (x = x0; x <= x1; x++) {
			if (x >= 0 && x < xres && (p[0] & p[1] & p[2]) == 255)
				memcpy(p, frame_fill, 3);
			p += 3;
		}
	}
}


static void mark_areas(uint8_t *img, int x, int y)
{
	const struct area *area;
	int r1 = 0, r2 = 0, i;

	if (frame_width) {
		r1 = (frame_width-1)/2;
		r2 = (frame_width-1)-r1;
	}
	for (area = areas; area; area = area->next) {
		if (frame_width)
			for (i = -r1; i <= r2; i++) {
				hline(img, area->x0-r1, area->x1+r2, area->y0+i,
				    x, y);
				hline(img, area->x0-r1, area->x1+r2, area->y1+i,
				    x, y);
				vline(img, area->y0+r1, area->y1-r2, area->x0+i,
				    x, y);
				vline(img, area->y0+r1, area->y1-r2, area->x1+i,
				    x, y);
			}
		fill(img,
		    area->x0+r1, area->y0+r1, area->x1-r2, area->y1-r2, x, y);
	}
}


static void usage(const char *name)
{
	fprintf(stderr,
"usage: %s [-f] [-a color] [-b color] [-c color] [-d pixels]\n"
"%6s %*s [-m color] [-n color] [-w pixels] file_a.ppm file_b.ppm\n"
"%6s %*s [file_a'.ppm file_b'.ppm] [out.ppm]\n\n"
"  file_a.ppm and file_b.ppm   are two input images\n"
"  file_a'.ppm and file_b'.ppm if present, are searched for changes as well\n"
"  out.ppm                     output file (default: standard output)\n\n"
"  -f         generate output (and return success) even if there is no change\n"
"  -a color   color of items only in image A\n"
"  -b color   color of items only in image B\n"
"  -c color   color of items in both images\n"
"  -d pixels  distance between change and marker box. 0 disables markers.\n"
"  -m color   color of the frame of the marker box.\n"
"  -n color   color of the background of the marker box\n"
"  -w pixels  width of the frame of the marker box. 0 disables frames.\n\n"
"  color is specified as R,B,G with each component as a floating-point\n"
"  value from 0 to 1. E.g., 1,1,1 is white.\n\n"
"  The images are expected to have dark colors on a perfectly white\n"
"  background.\n"
	    , name, "", (int) strlen(name), "", "", (int) strlen(name), "");
	exit(1);
}


static void parse_color(uint8_t *c, const char *s, const char *name)
{
	float r, g, b;

	if (sscanf(s, "%f,%f,%f", &r, &g, &b) != 3)
		usage(name);
	c[0] = 255*r;
	c[1] = 255*g;
	c[2] = 255*b;
}


int main(int argc, char *const *argv)
{
	int force = 0;
	int x = 0, y = 0;
	uint8_t *old, *new, *d, *a, *b;
	char *shadow_old = NULL, *shadow_new = NULL, *out_name = NULL;
	FILE *out;
	char *end;
	int c;

	while ((c = getopt(argc, argv, "a:b:c:d:fm:n:w:")) != EOF)
		switch (c) {
		case 'a':
			parse_color(a_only, optarg, *argv);
			break;
		case 'b':
			parse_color(b_only, optarg, *argv);
			break;
		case 'c':
			parse_color(both, optarg, *argv);
			break;
		case 'd':
			frame_dist = strtoul(optarg, &end, 0);
			if (*end)
				usage(*argv);
			break;
		case 'f':
			force = 1;
			break;
		case 'm':
			parse_color(frame, optarg, *argv);
			break;
		case 'n':
			parse_color(frame_fill, optarg, *argv);
			break;
		case 'w':
			frame_width = strtoul(optarg, &end, 0);
			if (*end)
				usage(*argv);
			break;
		default:
			usage(*argv);
		}
	switch (argc-optind) {
	case 2:
		break;
	case 3:
		out_name = argv[optind+2];
		break;
	case 5:
		out_name = argv[optind+4];
		/* fall through */
	case 4:
		shadow_old = argv[optind+2];
		shadow_new = argv[optind+3];
		break;
	default:
		usage(*argv);
	}

	old = load_ppm(argv[optind], &x, &y);
	new = load_ppm(argv[optind+1], &x, &y);
	if (shadow_old) {
		a = load_ppm(shadow_old, &x, &y);
		b = load_ppm(shadow_new, &x, &y);
		if (!force && !memcmp(a, b, x*y*3))
			return 1;
		shadow_diff(a, b, x, y);
	}
	if (!force && !areas && !memcmp(old, new, x*y*3))
		return 1;
	d = diff(old, new, x, y, !shadow_old);
	if (frame_dist)
		mark_areas(d, x, y);

	if (out_name) {
		out = fopen(out_name, "w");
		if (!out) {
			perror(out_name);
			exit(1);
		}
	} else {
		out = stdout;
	}
	fprintf(out, "P6\n%d %d\n255\n", x, y);
	fwrite(d, 1, x*y*3, out);
	if (fclose(out) == EOF) {
		perror("fclose");
		exit(1);
	}
	return 0;
}