CODE:

#ifndef IMAGE_IO_H_GUARD_90CC3F77_8D6C_4A20_BF33_B292BC9E017A
#define IMAGE_IO_H_GUARD_90CC3F77_8D6C_4A20_BF33_B292BC9E017A

#include 

struct rgb_t {
	uint8_t r, g, b;
};

struct image_t {
	uint32_t width, height;
	struct rgb_t* data;
};

struct image_t read_png(const char* file_name);
int write_png(struct image_t image, const char* file_name);

#endif

CODE:

#include 
#include 
#include 
#include "image_io.h"

struct image_t read_png(const char* file_name) {
	struct image_t result = {0, 0, NULL};
	png_structp png_ptr;
	png_infop info_ptr;
	png_bytepp row_pointers;
	png_uint_32 width, height;
	int bit_depth, color_type;
	uint32_t i, j;
	FILE* fp;
	png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
	if (png_ptr == NULL) {
		fputs("png_create_read_struct error\n", stderr);
		return result;
	}
	info_ptr = png_create_info_struct(png_ptr);
	if (info_ptr == NULL) {
		png_destroy_read_struct(&png_ptr, NULL, NULL);
		fputs("png_create_info_struct error\n", stderr);
		return result;
	}
	if ((fp = fopen(file_name, "rb")) == NULL) {
		png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
		fputs("file open error\n", stderr);
		return result;
	}
	if (setjmp(png_jmpbuf(png_ptr))) {
		png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
		fclose(fp);
		fputs("error in libpng\n", stderr);
		return result;
	}
	png_init_io(png_ptr, fp);
	png_read_png(png_ptr, info_ptr,
		PNG_TRANSFORM_SCALE_16 | PNG_TRANSFORM_STRIP_ALPHA | PNG_TRANSFORM_PACKING |
		PNG_TRANSFORM_EXPAND | PNG_TRANSFORM_GRAY_TO_RGB, NULL);
	row_pointers = png_get_rows(png_ptr, info_ptr);
	png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, NULL, NULL, NULL);
	if (width > SIZE_MAX / sizeof(struct rgb_t) || height > SIZE_MAX / (sizeof(struct rgb_t) * width)) {
		png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
		fclose(fp);
		fputs("image too large\n", stderr);
		return result;
	}
	result.data = malloc(sizeof(*result.data) * width * height);
	if (result.data == NULL) {
		png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
		fclose(fp);
		fputs("error in libpng\n", stderr);
		return result;
	}
	result.width = width;
	result.height = height;
	for (i = 0; i r = row_pointers[i][j * 3];
			current->g = row_pointers[i][j * 3 + 1];
			current->b = row_pointers[i][j * 3 + 2];
		}
	}
	png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
	fclose(fp);
	return result;
}

int write_png(struct image_t image, const char* file_name) {
	png_structp png_ptr;
	png_infop info_ptr;
	png_bytep image_data;
	png_bytepp row_pointers;
	FILE* fp;
	uint32_t i, j;
	png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
	if (png_ptr == NULL) {
		fputs("png_create_write_struct error\n", stderr);
		return 0;
	}
	info_ptr = png_create_info_struct(png_ptr);
	if (info_ptr == NULL) {
		png_destroy_write_struct(&png_ptr, NULL);
		fputs("png_create_info_struct error\n", stderr);
		return 0;
	}
	if ((fp = fopen(file_name, "wb")) == NULL) {
		png_destroy_write_struct(&png_ptr, &info_ptr);
		fputs("file open error\n", stderr);
		return 0;
	}
	if (setjmp(png_jmpbuf(png_ptr))) {
		png_destroy_write_struct(&png_ptr, &info_ptr);
		fclose(fp);
		fputs("error in libpng\n", stderr);
		return 0;
	}
	row_pointers = malloc(sizeof(png_bytep) * image.height);
	if (row_pointers == NULL) {
		fputs("malloc row failed\n", stderr);
		png_destroy_write_struct(&png_ptr, &info_ptr);
		fclose(fp);
		return 0;
	}
	image_data = malloc(sizeof(png_byte) * 3 * image.width * image.height);
	if (image_data == NULL) {
		fputs("malloc row failed\n", stderr);
		png_destroy_write_struct(&png_ptr, &info_ptr);
		free(row_pointers);
		fclose(fp);
		return 0;
	}
	for (i = 0; i 
#include 
#include 
#include "image_io.h"

/*
白っぽい → 通れる → 1
黒っぽい → 通れない → 0
*/
char* create_bfs_data_from_image(struct image_t image) {
	char* result = malloc(sizeof(char) * image.width * image.height);
	uint32_t i;
	if (result == NULL) return NULL;
	for (i = 0; i = 128 * 3);
	}
	return result;
}

char* bfs(const char* data, uint32_t width, uint32_t height,
uint32_t sx, uint32_t sy, uint32_t dx, uint32_t dy) {
	static const int d[4][2] = {{0, -1}, {1, 0}, {0, 1}, {-1, 0}};
	char* from = calloc(width * height, sizeof(char));
	char* result = calloc(width * height, sizeof(char));
	struct queue_t {
		uint32_t x, y;
		int from;
	}* queue = NULL;
	size_t queue_start, queue_end;
	uint32_t x, y;
	int cur_idx;
	if (width  0 ? argv[0] : "meiro-solver");
		return 1;
	}
	if (sscanf(argv[3], "%"SCNu32, &sx) != 1 || sscanf(argv[4], "%"SCNu32, &sy) != 1 ||
	sscanf(argv[5], "%"SCNu32, &dx) != 1 || sscanf(argv[6], "%"SCNu32, &dy) != 1) {
		fputs("invalid coord\n", stderr);
		return 1;
	}
	image = read_png(argv[1]);
	if (image.data == NULL) {
		fputs("PNG read failed\n", stderr);
		return 1;
	}
	if (image.width 
#include 
#include 
#include "image_io.h"

struct hindo_t {
	struct rgb_t color;
	uint32_t count;
};

int main(int argc, char* argv[]) {
	uint32_t block_size;
	uint32_t x, y, i, j;
	struct image_t image;
	struct hindo_t* hindo;
	if (argc != 4) {
		fprintf(stderr, "Usage: %s input_file output_file block_size\n",
			argc > 0 ? argv[0] : "block-painter");
		return 1;
	}
	if (sscanf(argv[3], "%"SCNu32, &block_size) != 1) {
		fputs("invalid block size\n", stderr);
		return 1;
	}
	if (block_size == 0) {
		fputs("invalid block size\n", stderr);
		return 1;
	}
	if (block_size > SIZE_MAX / sizeof(struct hindo_t) ||
	block_size > SIZE_MAX / (sizeof(struct hindo_t) * block_size)) {
		fputs("block size too large\n", stderr);
		return 1;
	}
	hindo = malloc(sizeof(struct hindo_t) * block_size * block_size);
	if (hindo == NULL) {
		fputs("hindo malloc failed\n", stderr);
		return 1;
	}
	image = read_png(argv[1]);
	if (image.data == NULL) {
		fputs("PNG read failed\n", stderr);
		free(hindo);
		return 1;
	}
	for (y = 0; y = hindo_max) {
						hindo[k].color = c;
						hindo[k].count = 0;
						hindo_max++;
					}
					hindo[k].count++;
				}
			}
			min_count = hindo[0].count;
			min_index = 0;
			for (k = 1; k  UINT32_MAX - block_size) break;
		}
		if (y > UINT32_MAX - block_size) break;
	}
	free(hindo);
	if (!write_png(image, argv[2])) {
		fputs("PNG write failed\n", stderr);
		free(image.data);
		return 1;
	}
	free(image.data);
	return 0;
}

CODE:

$ meiro-solver 犬文字迷路.png meiro-answer.png 5 5 1014 758

CODE:

$ block-painter meiro-answer.png meiro-answer-painted.png 4

CODE:

#include 
#include 
#include 
#include "image_io.h"

int main(int argc, char* argv[]) {
	uint32_t block_size;
	uint32_t x, y, i;
	struct image_t image;
	if (argc != 4) {
		fprintf(stderr, "Usage: %s input_file output_file block_size\n",
			argc > 0 ? argv[0] : "block-adjuster");
		return 1;
	}
	if (sscanf(argv[3], "%"SCNu32, &block_size) != 1) {
		fputs("invalid block size\n", stderr);
		return 1;
	}
	if (block_size == 0) {
		fputs("invalid block size\n", stderr);
		return 1;
	}
	image = read_png(argv[1]);
	if (image.data == NULL) {
		fputs("PNG read failed\n", stderr);
		return 1;
	}
	for (y = 0; y  UINT32_MAX - block_size || y + block_size > image.height) break;
		for (x = 0; x  UINT32_MAX - block_size || x + block_size > image.width) break;
			c = image.data[(y + block_size / 2) * image.width + (x + block_size / 2)];
			if (c.r == 255 && c.g == 0 && c.b == 0) {
				image.data[y * image.width + x] = white;
				image.data[(y + (block_size - 1)) * image.width + x] = white;
				image.data[y * image.width + (x + (block_size - 1))] = white;
				image.data[(y + (block_size - 1)) * image.width + (x + (block_size - 1))] = white;
				if (x == 0 || (c2 = image.data[(y + block_size / 2) * image.width + (x - block_size / 2)],
				c2.r != 255 || c2.g != 0 || c2.b != 0)) {
					for (i = 1; i = image.width ||
				(c2 = image.data[(y + block_size / 2) * image.width + (x + block_size)],
				c2.r != 255 || c2.g != 0 || c2.b != 0)) {
					for (i = 1; i = image.height ||
				(c2 = image.data[(y + block_size) * image.width + (x + block_size / 2)],
				c2.r != 255 || c2.g != 0 || c2.b != 0)) {
					for (i = 1; i < block_size - 1; i++) {
						image.data[(y + (block_size - 1)) * image.width + (x + i)] = white;
					}
				}
			}
		}
	}
	if (!write_png(image, argv[2])) {
		fputs("PNG write failed\n", stderr);
		free(image.data);
		return 1;
	}
	free(image.data);
	return 0;
}

CODE:

$ block-adjuster meiro-answer-painted.png meiro-answer-adjusted.png 4

CODE:

#include 
#include 
#include 
#include 
#include "image_io.h"

/*
白っぽい → 通れる → 1
黒っぽい → 通れない → 0
*/
char* create_bfs_data_from_image(struct image_t image) {
	char* result = malloc(sizeof(char) * image.width * image.height);
	uint32_t i;
	if (result == NULL) return NULL;
	for (i = 0; i = 128 * 3);
	}
	return result;
}

uint32_t* bfs(const char* data, uint32_t width, uint32_t height,
uint32_t sx, uint32_t sy, uint32_t dx, uint32_t dy) {
	static const int d[4][2] = {{0, -1}, {1, 0}, {0, 1}, {-1, 0}};
	char* from = calloc(width * height, sizeof(char));
	uint32_t* result = calloc(width * height, sizeof(uint32_t));
	struct queue_t {
		uint32_t x, y;
		uint32_t cost;
		int from;
	}* queue = NULL;
	size_t queue_start, queue_end;
	uint32_t x, y, cost;
	int cur_idx;
	if (width  1) pos = 1;
	result.r = c1.r * (1.0 - pos) + c2.r * pos;
	result.g = c1.g * (1.0 - pos) + c2.g * pos;
	result.b = c1.b * (1.0 - pos) + c2.b * pos;
	return result;
}

int main(int argc, char* argv[]) {
	uint32_t sx, sy, dx, dy;
	struct image_t image;
	size_t i;
	char* bfs_data;
	uint32_t* bfs_result;
	uint32_t max_cost;
	uint32_t speed;
	if (argc != 7 && argc != 8) {
		fprintf(stderr, "Usage: %s input_file output_file sx dy dx dy [speed]\n",
			argc > 0 ? argv[0] : "meiro-solver-grad");
		return 1;
	}
	if (sscanf(argv[3], "%"SCNu32, &sx) != 1 || sscanf(argv[4], "%"SCNu32, &sy) != 1 ||
	sscanf(argv[5], "%"SCNu32, &dx) != 1 || sscanf(argv[6], "%"SCNu32, &dy) != 1) {
		fputs("invalid coord\n", stderr);
		return 1;
	}
	if (argc == 8) {
		if (sscanf(argv[7], "%"SCNu32, &speed) != 1 || speed == 0) {
			fputs("invalid speed\n", stderr);
			return 1;
		}
	} else {
		speed = 1;
	}
	image = read_png(argv[1]);
	if (image.data == NULL) {
		fputs("PNG read failed\n", stderr);
		return 1;
	}
	if (image.width  1) {
				image.data[i] = get_color(fmod((bfs_result[i] - 1.0) / (max_cost - 1.0) * speed, 1.0));
			} else {
				image.data[i] = get_color(1.0);
			}
		}
	}
	if (!write_png(image, argv[2])) {
		fputs("PNG write failed\n", stderr);
		free(image.data);
		return 1;
	}
	free(image.data);
	return 0;
}

CODE:

$ meiro-solver-grad 犬文字迷路.png meiro-answer-grad.png 5 5 1014 758
$ block-painter meiro-answer-grad.png meiro-answer-grad-painted.png 4

CODE:

$ meiro-solver-grad 犬文字迷路.png meiro-answer-grad10.png 5 5 1014 758 10
$ block-painter meiro-answer-grad10.png meiro-answer-grad10-painted.png 4

CODE:

$ meiro-solver-grad 犬文字迷路.png meiro-answer-grad17.png 5 5 1014 758 17
$ block-painter meiro-answer-grad17.png meiro-answer-grad17-painted.png 4