Image *Image_newWithPath_(char *path)
{
Image *self = Image_new();
Image_path_(self, path);
Image_load(self);
return self;
}
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_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 compress_and_decompress(FILE *fp,bool lossy){
Image_T img;
img = Image_new(fp);
Image_compress(img,lossy);
Image_decompress(img,lossy);
Image_write(img, stdout);
Image_free(&img);
}
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);
}
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;
}
Image *Image_copyWithUArray_(Image *self, UArray *ba)
{
Image *image = Image_new();
Image_setExternalUArray_(image, ba);
Image_path_(image, self->path);
Image_error_(image, self->error);
image->width = self->width;
image->height = self->height;
image->componentCount = self->componentCount;
image->encodingQuality = self->encodingQuality;
image->decodingWidthHint = self->decodingWidthHint;
image->decodingHeightHint = self->decodingHeightHint;
return image;
}
void init()
{
// int glfwInit( void )
if (glfwInit() != GL_TRUE)
{
exit(EXIT_FAILURE);
}
// int glfwOpenWindow( int width, int height,
// int redbits, int greenbits, int bluebits,
// int alphabits, int depthbits, int stencilbits,
// int mode )
if (glfwOpenWindow(0, 0, 0, 0, 0, 0, 0, 0, GLFW_WINDOW) != GL_TRUE)
{
// void glfwTerminate( void )
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwSetWindowSizeCallback(windowResize);
glClearColor(0.5, 0.0, 0.5, 0.0);
console = StdoutConsole_new();
Log_init(console);
renderBatch = RenderBatch_new(4, TRUE);
image = Image_new();
Image_loadFromFile(image, "res/box.png");
texture = Texture_newFromImage(image);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glEnable(GL_TEXTURE_2D);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
const char *FileBrowsePanel_Main(SDL_Surface *screen) {
fprintf(stderr, "FileBrowsePanel_Main: Currently unsupported.\n");
return NULL;
@OLD main function stuff
// Create font
font = Static_getFont("fonts/ariblk.ttf", 20);
// Create a fileInfo type array containing content of current folder
prevClicked = 0xFFFFFFFF;
firstScreenIndex = 0;
selIndex = 0xFFFFFFFF;
// initialize screen context
Screen_init(&sc, screen, 0);
Screen_setBackground(&sc, "img/green-design-background.jpg");
sc.drag_on = false;
tblist = NULL;
getCurrentFolderContent(&tblist, &tblistCount, sc.screen, font,
FBP_FILE_INFO_BGCOLOR_UNSEL, 0x000000, fileTypes, &nameHeight,
textblock_filename_clicked);
//~ u32 i=0; for (; i < tblistCount; i++)
//~ fprintf(stderr, "widget[%u/%u] id=%u\t%s\n", i, tblistCount,
//~ tblist[i].text_block.widget.id, tblist[i].text_block.text);
u32 i;
nameHeight += 5;
char current_dir[PATH_MAX_SIZE];
getcwd(current_dir, PATH_MAX_SIZE);
// Update actual folder path
//~ TextBlock *tb_currentFolder = malloc(sizeof(TextBlock));
//~ tb_currentFolder->text = (char*) malloc(PATH_MAX_SIZE*sizeof(char));
//~ getcwd(tb_currentFolder->text, PATH_MAX_SIZE-1);
//~ TextBlock_setFont(tb_currentFolder, font);
//~ TextBlock_setBackgroundColor(tb_currentFolder, 0xD9FFAD);
//~ TextBlock_setForegroundColor(tb_currentFolder, 0x000000);
//~ TextBlock_refresh(tb_currentFolder);
//~ Widget *tb_currentFolder_widget = &(tb_currentFolder->widget);
//~ tb_currentFolder_widget->id = 4;
//~ tb_currentFolder_widget->draggable = true;
//~ tb_currentFolder_widget->mevent = true;
border_rect = malloc(sizeof(Rectangle));
Rectangle *border_rect2 = malloc(sizeof(Rectangle));
Rectangle_new(border_rect, sc.screen, 0xE2F3D3);
Rectangle_new(border_rect2, sc.screen, 0x2EAE00);
border_rectWidget = &(border_rect->widget);
border_rect2Widget = &(border_rect2->widget);
u16 height = (W_SCREEN_HEIGHT<<1)/3;
height -= (height-UPPER_RESERV)%nameHeight;
border_rectWidget->pos.y = 100;
border_rectWidget->pos.w = 850;
border_rectWidget->pos.x = 100;
border_rectWidget->pos.h = height;
border_rect2Widget->pos.y = border_rectWidget->pos.y - 5;
border_rect2Widget->pos.x = border_rectWidget->pos.x - 5;
border_rect2Widget->pos.w = border_rectWidget->pos.w + 10;
border_rect2Widget->pos.h = border_rectWidget->pos.h + 10;
Rectangle_refresh(border_rect);
Rectangle_refresh(border_rect2);
// Preview view rectangle
p_x = border_rect2Widget->maxx + 10;
p_y = border_rect2Widget->pos.y + 10;
p_w = W_SCREEN_WIDTH - border_rect2Widget->pos.w - border_rect2Widget->pos.x - 20;
p_h = border_rect2Widget->pos.h - 20;
Button *butOk = malloc(sizeof(Button));
Button *butAnuluj = malloc(sizeof(Button));
Button_new(butOk, sc.screen, "OK", true);
Widget *butOk_widget = &(butOk->widget);
butOk_widget->click_handler = button_ok_clicked;
Button_applyDefaultStyle(butOk, 879, 874, font, 50, 5);
Button_setFixedWidth(butOk, true);
Button_new(butAnuluj, sc.screen, "Anuluj", true);
Widget *butAnuluj_widget = &(butAnuluj->widget);
butAnuluj_widget->click_handler = button_anuluj_clicked;
Button_applyDefaultStyle(butAnuluj, 1061, 874, font, 33, 5);
Button_setFixedWidth(butAnuluj, true);
b8 got_event=false;
sel = false;
char *ret_path = NULL;
preview = malloc(sizeof(Image));
Image_new(preview, NULL, 0, 0); // invisible preview image
//~ border_rectWidget->pos.y = 100;
//~ border_rectWidget->pos.w = W_SCREEN_WIDTH-200;
//~ border_rect2Widget->pos.y = border_rectWidget->pos.y - 5;
//~ border_rect2Widget->pos.w = border_rectWidget->pos.w + 10;
//~ border_rectWidget->pos.x = (W_SCREEN_WIDTH-border_rectWidget->pos.w)>>1;
//~ border_rect2Widget->pos.x = border_rectWidget->pos.x - 5;
while (! sc.has_exited) {
if (sc.need_reload) {
sc.need_reload = false;
SDL_BlitSurface(sc.background->widget.surf, NULL, sc.screen, NULL);
if (preview->widget.visible) {
Widget_draw(&(preview->widget), &sc, false);
}
u16 height = (W_SCREEN_HEIGHT<<1)/3;
height -= (height-UPPER_RESERV)%nameHeight;
border_rectWidget->pos.h = height;
border_rect2Widget->pos.h = border_rectWidget->pos.h + 10;
Rectangle_refresh(border_rect);
Rectangle_refresh(border_rect2);
Widget_draw(border_rect2Widget, &sc, false);
Widget_draw(border_rectWidget, &sc, false);
Widget_draw(butOk_widget, &sc, false);
showFiles();
Widget_draw(butOk_widget, &sc, false);
Widget_draw(butAnuluj_widget, &sc, true);
}
while (SDL_WaitEvent(sc.pevent)) {
got_event = true;
switch (sc.event.type) {
case SDL_KEYDOWN: // only for testing purpouses
if (sc.event.key.keysym.sym == SDLK_ESCAPE)
sc.has_exited = true;
else {
if (sc.event.key.keysym.sym == SDLK_F2) {
fprintf(stderr, "Debug list:\n");
for (i = 0; i < tblistCount; i++) {
fprintf(stderr, "TextBlock [%u/%u] id=%u text=%s\n", i, tblistCount, tblist[i].text_block.widget.id, tblist[i].text_block.text);
}
}
}
break;
case SDL_QUIT:
sc.has_exited = true;
break;
case SDL_MOUSEBUTTONDOWN:
if (sc.event.button.button == 4) { // wheel up
if (firstScreenIndex > 0) {
firstScreenIndex--;
sc.need_reload = true;
}
break;
}
else {
if (sc.event.button.button == 5) { // wheel down
if (lastScreenIndex < tblistCount-1) {
firstScreenIndex++;
sc.need_reload = true;
}
break;
}
}
default:
Widget_mevent(butOk_widget, &sc);// if (sc.event_handled) break;
Widget_mevent(butAnuluj_widget, &sc); //if (sc.event_handled) break;
if (sc.event.type != SDL_MOUSEMOTION) {
for (i = firstScreenIndex; i <= lastScreenIndex; i++) {
Widget_mevent(&(tblist[i].text_block.widget), &sc);
//if (sc.event_handled) break;
}
}
break;
}
if (got_event) break;
}
}
to_end:
if ((sel) || (selIndex != 0xFFFFFFFF)) {
ret_path = realpath(tblist[selIndex].text_block.text, ret_path);
if (! ret_path) {
fprintf(stderr, "FileBrowsePanel_Main:FileBrowsePanel > Failed to realpath on selected path %s\n", tblist[selIndex].text_block.text);
}
}
// Remember to copy text of selected file
for (i = 0; i < tblistCount; i++) {
fprintf(stderr, "Delete TextBlock %u, %s\n", i, tblist[i].text_block.text);
delete(&(tblist[i].text_block));
}
free(tblist);
delete(&sc);
delete(butOk);
delete(butAnuluj);
delete(border_rect);
delete(border_rect2);
free(butOk);
free(butAnuluj);
free(border_rect);
free(border_rect2);
free(preview);
if (chdir(current_dir)) { // go back to previous directory
fprintf(stderr, "FileBrowsePanel_Main:FileBrowsePanel > Failed to go back to previous directory %s\n", current_dir);
}
fprintf(stderr, "FileBrowsePanel: Exiting\n");
return ret_path;
**/
}
IoImage *IoImage_proto(void *state)
{
IoObject *self = IoObject_new(state);
IoObject_tag_(self, IoImage_newTag(state));
IoObject_setDataPointer_(self, io_calloc(1, sizeof(IoImageData)));
DATA(self)->buffer = IoSeq_newWithCString_(IOSTATE, "");
DATA(self)->image = Image_new();
Image_setExternalUArray_(DATA(self)->image, IoSeq_rawUArray(DATA(self)->buffer));
IoState_registerProtoWithId_(state, self, protoId);
{
IoMethodTable methodTable[] = {
{"setDataWidthHeightComponentCount", IoImage_setDataWidthHeightComponentCount},
{"setPath", IoImage_setPath},
{"open", IoImage_open},
{"save", IoImage_save},
{"width", IoImage_width},
{"height", IoImage_height},
{"data", IoImage_data},
{"componentCount", IoImage_componentCount},
{"isGrayscale", IoImage_isL8},
{"isL8", IoImage_isL8},
{"isLA8", IoImage_isLA8},
{"isRGB8", IoImage_isRGB8},
{"isRGBA8", IoImage_isRGBA8},
{"error", IoImage_error},
{"resizedTo", IoImage_resizedTo},
{"crop", IoImage_crop},
{"addAlpha", IoImage_addAlpha},
{"removeAlpha", IoImage_removeAlpha},
{"makeRGBA8", IoImage_makeRGBA8},
{"makeL8", IoImage_makeL8},
{"makeGrayscale", IoImage_makeGrayscale},
// extras
{"setEncodingQuality", IoImage_setEncodingQuality},
{"encodingQuality", IoImage_encodingQuality},
{"setDecodingWidthHint", IoImage_setDecodingWidthHint},
{"decodingWidthHint", IoImage_decodingWidthHint},
{"setDecodingHeightHint", IoImage_setDecodingHeightHint},
{"decodingHeightHint", IoImage_decodingHeightHint},
{"flipX", IoImage_flipX},
{"flipY", IoImage_flipY},
{"baselineHeight", IoImage_baselineHeight},
{"averageColor", IoImage_averageColor},
{"histogram", IoImage_histogram},
{"equalizeHistogram", IoImage_equalizeHistogram},
{"linearContrast", IoImage_linearContrast},
{"bitPlain", IoImage_bitPlain},
{"componentPlain", IoImage_componentPlain},
{"thresholdByGradient", IoImage_thresholdByGradient},
{"thresholdByHistogram", IoImage_thresholdByHistogram},
{"thresholdByOtsu", IoImage_thresholdByOtsu},
{"filterLinear", IoImage_filterLinear},
{"filterUniformAverage", IoImage_filterUniformAverage},
{"filterGauss", IoImage_filterGauss},
{"filterKirsch", IoImage_filterKirsch},
{"filterSobel", IoImage_filterSobel},
{"filterUnsharpMask", IoImage_filterUnsharpMask},
{"filterMin", IoImage_filterMin},
{"filterMax", IoImage_filterMax},
{"filterMedian", IoImage_filterMedian},
{"filterWeightedMedian", IoImage_filterWeightedMedian},
{"bounds", IoImage_bounds},
{NULL, NULL},
};
IoObject_addMethodTable_(self, methodTable);
}
return self;
}
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);
}
