int main()
{
fprintf(stderr, "Testing image loading and saving.\n");
Log_init();
Image* myimage = Image_newFromData(reference, sizeof(reference), 4, 4, 4);
if (!Image_saveToFile(myimage, "test-image.png"))
{
fprintf(stderr, "Saving image failed.\n");
Image_delete(myimage);
return 1;
}
Image* image = Image_new();
if (!Image_loadFromFile(image, "test-image.png"))
{
fprintf(stderr, "Loading image failed.\n");
Image_delete(image);
return 1;
}
if (image->width * image->height * image->channels != image->size)
{
fprintf(stderr, "Image size incorrect.\n");
fprintf(stderr, "Image width: %i, height: %i, channels: %i, size %i \n", image->width, image->height, image->channels, image->size);
return 1;
}
int i;
int j;
int k;
for(i = 0; i < image->height; i++)
{
for(j = 0; j < image->width; j++)
{
for(k = 0; k < image->channels; k++)
{
if (image->data[(i * image->channels * image->width) + (j * image->channels) + k] != reference[(i * image->channels * image->width) + (j * image->channels) + k])
{
fprintf(stderr, "Image loaded is not the same as refrence at (%i, %i, %i)\n", i, j, k);
return 1;
}
}
}
}
Image_delete(image);
Log_terminate();
return 0;
}
void Image_loadFromFile_works(CuTest* tc)
{
Image* image = Image_new();
BOOL result = Image_loadFromFile(image, "res/test.png");
CuAssert(tc, "Could not load image.", result == TRUE);
Image_delete(image);
}
void Image_saveToFile_works(CuTest* tc)
{
Image* image = Image_newFromData(reference, sizeof(reference), 4, 4, TRUE);
BOOL result = Image_saveToFile(image, "test-image.png");
CuAssert(tc, "Could not save image.", result == TRUE);
Image_delete(image);
}
void Image_newFromData_shouldNotDeleteAlphaValues(CuTest* tc)
{
Image* image = Image_newFromData(reference, sizeof(reference), 4, 4, FALSE);
CuAssertTrue(tc, image->channels = 3);
CuAssert(tc, "Image contents incorrect.", memcmp(reference, image->data, 4*4*4) == 0);
Image_delete(image);
}
void Image_loadFromFile_shouldYieldCorrectImage(CuTest* tc)
{
Image* image = Image_new();
Image_loadFromFile(image, "res/test.png");
CuAssert(tc, "Image contents incorrect.", memcmp(testImage, image->data, 6*8*4) == 0);
Image_delete(image);
}
void Image_loadFromFile_shouldYieldRightDimensions(CuTest* tc)
{
Image* image = Image_new();
Image_loadFromFile(image, "res/test.png");
CuAssert(tc, "Image dimensions incorrect.", image->width == 6 && image->height == 8);
CuAssertTrue(tc, image->channels == 3);
CuAssertTrue(tc, image->bpp == 4);
CuAssert(tc, "Image size incorrect.", 6*8*4 == image->size);
Image_delete(image);
}
void Image_fillOut_shouldYieldCorrectImageFillingWidthAndHeight(CuTest* tc)
{
Image* image = Image_newFromData(reference, sizeof(reference), 4, 4, TRUE);
Image_fillOut(image, 5, 5);
CuAssertTrue(tc, image->width == 5);
CuAssertTrue(tc, image->height == 5);
CuAssertTrue(tc, image->channels == 4);
CuAssertTrue(tc, image->size == 100);
CuAssert(tc, "Image contents incorrect.", memcmp(referenceFilledOutHW, image->data, 100) == 0);
Image_delete(image);
}
void Image_fillOut_shouldYieldCorrectImageInTrivialCase(CuTest* tc)
{
Image* image = Image_newFromData(reference, sizeof(reference), 4, 4, TRUE);
Image_fillOut(image, 4, 4);
CuAssertTrue(tc, image->height == 4);
CuAssertTrue(tc, image->width == 4);
CuAssertTrue(tc, image->channels == 4);
CuAssertTrue(tc, image->size == 64);
CuAssert(tc, "Image contents incorrect.", memcmp(reference, image->data, 64) == 0);
Image_delete(image);
}
void Image_newFromData_works(CuTest* tc)
{
Image* image = Image_newFromData(reference, sizeof(reference), 4, 4, TRUE);
CuAssert(tc, "Could not create image on the fly.", image != NULL);
CuAssertTrue(tc, image->width == 4);
CuAssertTrue(tc, image->height == 4);
CuAssertTrue(tc, image->channels == 4);
CuAssertTrue(tc, image->bpp == 4);
CuAssertTrue(tc, image->size == 4*4*4);
CuAssertTrue(tc, image->file == NULL);
CuAssertTrue(tc, image->data != NULL);
CuAssert(tc, "Image contents incorrect.", memcmp(reference, image->data, 4*4*4) == 0);
Image_delete(image);
}
void convolution(int argc, char *argv[])
{
if (argc != 3) {
printf("Invalid number of arguments.\n");
return;
}
Image *input_image;
Image *output_image;
int error;
if ((error = TGA_readImage(argv[0], &input_image)) != 0) {
printf("Error when opening image: %d\n", error);
return;
}
if ((error = Image_new(input_image->width,
input_image->height,
input_image->channels,
&output_image)) != 0) {
printf("Error when creating output image : %d\n", error);
Image_delete(input_image);
return;
}
Kernel kernel;
if ((error = get_kernel(argv[1], &kernel)) != 0) {
printf("Error when opening kernel : %d\n", error);
Image_delete(input_image);
Image_delete(output_image);
return;
}
int radius_x, radius_y;
int x, y, c;
radius_x = (kernel.width - 1) / 2;
radius_y = (kernel.height - 1) / 2;
Benchmark bench;
start_benchmark(&bench);
for (c = 0; c < input_image->channels; ++c) {
uint8_t *out_data = output_image->data[c];
for (y = 0; y < input_image->height; ++y) {
for (x = 0; x < input_image->width; ++x) {
int kx, ky;
float *kernel_data = kernel.data;
float sum = 0;
for (ky = -radius_y; ky <= radius_y; ++ky) {
for (kx = -radius_x; kx <= radius_x; ++kx) {
int xx = clip(x + kx, 0, input_image->width - 1);
int yy = clip(y + ky, 0, input_image->height - 1);
sum += Image_getPixel(input_image, xx, yy, c) * *kernel_data++;
}
}
sum /= kernel.sum;
*out_data++ = clip(sum, 0, 255);
}
}
}
end_benchmark(&bench);
printf("%lu ", bench.elapsed_ticks);
printf("%lf\n", bench.elapsed_time);
if ((error = TGA_writeImage(argv[2], output_image)) != 0) {
printf("Error when writing image: %d\n", error);
}
Image_delete(input_image);
Image_delete(output_image);
kernel_delete(kernel);
}
void erosion(int argc, char *argv[])
{
if (argc != 3) {
printf("Invalid number of arguments.\n");
return;
}
Image *input_image;
Image *output_image;
int error;
int radius;
radius = (int) atoi(argv[1]);
if (radius < 1) {
printf("Invalid erosion radius value.\n");
return;
}
if ((error = TGA_readImage(argv[0], &input_image)) != 0) {
printf("Error when opening image: %d\n", error);
return;
}
if ((error = Image_copy(input_image, &output_image)) != 0) {
printf("Error when copying image: %d\n", error);
Image_delete(input_image);
return;
}
int c, i, size, x, y;
int line_offset;
uint8_t *in_data, *out_data;
uint8_t current_min;
line_offset = input_image->width;
size = input_image->width * input_image->height;
Benchmark bench;
start_benchmark(&bench);
for (c = 0; c < input_image->channels; ++c) {
in_data = input_image->data[c];
out_data = output_image->data[c];
for (i = 0; i < size; ++i) {
x = i % input_image->width;
y = i / input_image->width;
current_min = 0xff;
int x1 = max(0, x - radius);
int x2 = min(input_image->width - 1, x + radius);
int y1 = max(0, y - radius);
int y2 = min(input_image->height - 1, y + radius);
int xx, yy;
uint8_t *region = in_data + Image_getOffset(input_image, x1, y1);
for (yy = y1; yy <= y2; ++yy) {
for (xx = x1; xx <= x2; ++xx) {
current_min = min(current_min, *region);
++region;
}
region += line_offset - (x2 - x1 + 1);
}
*out_data++ = current_min;
}
}
end_benchmark(&bench);
printf("%lu ", bench.elapsed_ticks);
printf("%lf\n", bench.elapsed_time);
if ((error = TGA_writeImage(argv[2], output_image)) != 0) {
printf("Error when writing image: %d\n", error);
}
Image_delete(input_image);
Image_delete(output_image);
}
