Modularizáció: forráskód szervezése, függvénykönyvtárak, linkelés¶

Adott több képmanipuláló program. Első körben ezeket szét kell választani három részre: programok, képreprezentáció, képmanipuláció. Ezután a képreprezentáció és képmanipuláció elemeit külön függvénykönyvtárakba is ki kell szervezni, majd a programokat a függvénykönyvtárak segítségével kell megvalósítani.

A modularizáció témához tartozó összes forrás egyben itt tölthető le.

PNM fájlok¶

A feladathoz tartozó programok PNM formátumú (pontosabban a PNM formátumcsaládba tartozó) képekkel dolgoznak. Néhány mintakép:

Színes mintaképek (PPM)

Szürkeárnyalatos mintaképek (PGM)

Fekete-fehér mintaképek (PBM)

Az egyik önálló, monolit program: `pnm-info`¶

Ez a program fog egy PNM formátumú képet, és mindenféle információt ír róla a konzolra. A program teljes forrása tömörítve innen letölthető.

A program egyetlen C forrásban van megírva, ami önmagában még teljesen rendben van.

A program forráskódja

pnm-monolit-info.c:

/*
 * Szegedi Tudományegyetem
 * Informatikai Tanszékcsoport
 * Szoftverfejlesztés Tanszék
 */

#include <malloc.h>
#include <stdio.h>

#define UNUSED(X) (void)(X)

typedef unsigned short int rgbpic_monochrome_pixel_t;
typedef unsigned short int rgbpic_picture_size_t;

typedef struct {
    rgbpic_monochrome_pixel_t red;
    rgbpic_monochrome_pixel_t green;
    rgbpic_monochrome_pixel_t blue;
} rgbpic_pixel_t;

typedef struct {
    rgbpic_monochrome_pixel_t maxpixvalue;
    rgbpic_picture_size_t width;
    rgbpic_picture_size_t height;
    rgbpic_pixel_t *pixelvalues;
} rgbpic_t;

int rgbpic_coord(rgbpic_t *pic, rgbpic_picture_size_t x, rgbpic_picture_size_t y) {
    return  y * pic->width + x;
}

void rgbpic_delete(rgbpic_t *pic) {
    if (pic) {
        free(pic->pixelvalues);
        free(pic);
    }
}

rgbpic_t *rgbpic_load_PBM(const char *fname) {
    FILE *file;
    rgbpic_t *pic = NULL;
    if (!(file = fopen(fname, "r"))) {
        return NULL;
    }
    if ((fgetc(file) != 'P') || (fgetc(file) != '1')) {
        goto error_handling;
    }
    pic = (rgbpic_t*)malloc(sizeof(rgbpic_t));
    if (!pic) {
        goto error_handling;
    }
    *pic = (rgbpic_t){0, 0, 0, NULL};
    if (fscanf(file, "%hd %hd", &(pic->width), &(pic->height)) != 2) {
        goto error_handling;
    }
    pic->maxpixvalue = 1;
    pic->pixelvalues = (rgbpic_pixel_t*)malloc(pic->width * pic->height * sizeof(rgbpic_pixel_t));
    if (! pic->pixelvalues) {
        goto error_handling;
    }
    unsigned int n, i;
    rgbpic_monochrome_pixel_t v;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        if (fscanf(file, "%hd", &v) != 1) {
            goto error_handling;
        }
        pic->pixelvalues[i].red   = 1 - v;
        pic->pixelvalues[i].green = 1 - v;
        pic->pixelvalues[i].blue  = 1 - v;
    }
    fclose(file);
    return pic;
  error_handling:
    fclose(file);
    rgbpic_delete(pic);
    return NULL;
}

rgbpic_t *rgbpic_load_PGM(const char *fname) {
    FILE *file;
    rgbpic_t *pic = NULL;
    if (!(file = fopen(fname, "r"))) {
        return NULL;
    }
    if ((fgetc(file) != 'P') || (fgetc(file) != '2')) {
        goto error_handling;
    }
    pic = (rgbpic_t*)malloc(sizeof(rgbpic_t));
    if (!pic) {
        goto error_handling;
    }
    *pic = (rgbpic_t){0, 0, 0, NULL};
    if (fscanf(file, "%hd %hd %hd", &(pic->width), &(pic->height), &(pic->maxpixvalue)) != 3) {
        goto error_handling;
    }
    pic->pixelvalues = (rgbpic_pixel_t*)malloc(pic->width * pic->height * sizeof(rgbpic_pixel_t));
    if (! pic->pixelvalues) {
        goto error_handling;
    }
    unsigned int n, i;
    rgbpic_monochrome_pixel_t v;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        if (fscanf(file, "%hd", &v) != 1) {
            goto error_handling;
        }
        pic->pixelvalues[i].red   = v;
        pic->pixelvalues[i].green = v;
        pic->pixelvalues[i].blue  = v;
    }
    fclose(file);
    return pic;
  error_handling:
    fclose(file);
    rgbpic_delete(pic);
    return NULL;
}

rgbpic_t *rgbpic_load_PPM(const char *fname) {
    FILE *file;
    rgbpic_t *pic = NULL;
    if (!(file = fopen(fname, "r"))) {
        return NULL;
    }
    if ((fgetc(file) != 'P') || (fgetc(file) != '3')) {
        goto error_handling;
    }
    pic = (rgbpic_t*)malloc(sizeof(rgbpic_t));
    if (!pic) {
        goto error_handling;
    }
    *pic = (rgbpic_t){0, 0, 0, NULL};
    if (fscanf(file, "%hd %hd %hd", &(pic->width), &(pic->height), &(pic->maxpixvalue)) != 3) {
        goto error_handling;
    }
    pic->pixelvalues = (rgbpic_pixel_t*)malloc(pic->width * pic->height * sizeof(rgbpic_pixel_t));
    if (! pic->pixelvalues) {
        goto error_handling;
    }
    unsigned int n, i;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        if (fscanf(file, "%hd %hd %hd",
              &pic->pixelvalues[i].red,
              &pic->pixelvalues[i].green,
              &pic->pixelvalues[i].blue) != 3) {
            goto error_handling;
        }
    }
    fclose(file);
    return pic;
  error_handling:
    fclose(file);
    rgbpic_delete(pic);
    return NULL;
}

rgbpic_t *rgbpic_load(const char *fname) {
    rgbpic_t *pic = NULL;
    UNUSED((pic = rgbpic_load_PBM(fname)) || (pic = rgbpic_load_PGM(fname)) || (pic = rgbpic_load_PPM(fname)));
    return pic;
}

/*
 * A main függvény.
 */
int main(int argc, char *argv[]) {
    rgbpic_t *kep;                              /* A kép (illetve a képre mutató pointer) */
    rgbpic_picture_size_t i, j;
    int szurke = 1, binary = 1;
    unsigned long long int iR = 0, iG = 0, iB = 0;
    if (argc < 2) {                                            /* Ha nincs elég paraméter */
        printf("Nincs elég paraméter!\n");
        return 1;
    }
    if (!(kep = rgbpic_load(argv[1]))) {  /* Az első paramétert input képként értelmezzük */
        printf("Nem sikerült megnyitni: %s\n", argv[1]);
        return 1;
    }
    printf("A képfájl neve: %s\n", argv[1]);
    printf("\tmérete: %hdx%hd pixel\n", kep->width, kep->height);
    for (i = 0; i < kep->height; ++i) {
        for (j = 0; j < kep->width; ++j) {
            rgbpic_monochrome_pixel_t r, g, b;
            iR += r = kep->pixelvalues[rgbpic_coord(kep, j, i)].red;
            iG += g = kep->pixelvalues[rgbpic_coord(kep, j, i)].green;
            iB += b = kep->pixelvalues[rgbpic_coord(kep, j, i)].blue;
            if (r != g || r != b) {
                szurke = binary = 0;
            }
            if (r != 0 && r != kep->maxpixvalue) {
                binary = 0;
            }
        }
    }
    if (binary) {
        printf("\tEz egy fekete-fehér bináris kép %llu%%-os átlagos szürke intenzitással.\n",
                    100llu * iR / (kep->width * kep->height * kep->maxpixvalue));
    } else if (szurke) {
        printf("\tEz egy szürkeárnyalatos kép %llu%%-os átlagos intenzitással.\n",
                    100llu * iR / (kep->width * kep->height * kep->maxpixvalue));
    } else {
        printf("\tEz egy színes kép (%llu%%, %llu%%, %llu%%)-os átlagos RGB,\n",
                    100llu * iR / (kep->width * kep->height * kep->maxpixvalue),
                    100llu * iG / (kep->width * kep->height * kep->maxpixvalue),
                    100llu * iB / (kep->width * kep->height * kep->maxpixvalue));
        printf("\tés %llu%%-os érték szerinti valamint %llu%%-os érzékelt szürke intenzitásokkal.\n",
                    100llu * (iR + iG + iB) / (3 * kep->width * kep->height * kep->maxpixvalue),
                    (30*iR + 59*iG + 11*iB) / (kep->width * kep->height * kep->maxpixvalue));
    }
    rgbpic_delete(kep);                                              /* Töröljük a képet. */
    return 0;
}

A program fordítása egyszerű, hiszen egyetlen C forrásfájlból áll.

A makefile

Makefile:

info_PROG:=pnm-info
info_SRCS:=pnm-monolit-info.c
info_OBJS:=$(patsubst %.c,%.o,$(info_SRCS))
info_DEPS:=$(patsubst %.c,%.d,$(info_SRCS))

info_CPPFLAGS:=$(CPPFLAGS)
info_CFLAGS:=$(CFLAGS) -Wall
info_LDFLAGS:=$(LDFLAGS)
info_LDLIBS:=$(LDLIBS)

all: $(info_PROG)

$(info_OBJS): %.o: %.c
    $(CC) -c $(info_CPPFLAGS) $(info_CFLAGS) $< -o $@

$(info_DEPS): %.d: %.c
    $(CC) -MM $(info_CPPFLAGS) $< -MF $@

$(info_PROG): $(info_OBJS)
    $(CC) $(info_CFLAGS) $(info_LDFLAGS) $^ $(info_LDLIBS) -o $@

clean:
    rm -rf $(info_PROG) $(info_OBJS) $(info_DEPS)

.PHONY: all clean

include $(info_DEPS)

A makefile segítségével készítsük el a programot, majd futtassuk.

make
./pnm-monolit-info torony-o.ppm
make clean

A másik önálló, monolit program: `pnm-manipulate`¶

Ez a program fog egy PNM formátumú képet, és a megadott kapcsolók szerint átalakítja azt. A program teljes forrása tömörítve innen letölthető.

A program egyetlen C forrásban van megírva, ami önmagában még rendben van, bár a hossza miatt lehet, hogy egy programozó már így is a szétdarabolását javasolná.

A program forráskódja

pnm-monolit-manipulate.c:

/*
 * Szegedi Tudományegyetem
 * Informatikai Tanszékcsoport
 * Szoftverfejlesztés Tanszék
 */

#include <malloc.h>
#include <stdio.h>
#include <string.h>

#define UNUSED(X) (void)(X)

typedef unsigned short int rgbpic_monochrome_pixel_t;
typedef unsigned short int rgbpic_picture_size_t;

typedef struct {
    rgbpic_monochrome_pixel_t red;
    rgbpic_monochrome_pixel_t green;
    rgbpic_monochrome_pixel_t blue;
} rgbpic_pixel_t;

typedef struct {
    rgbpic_monochrome_pixel_t maxpixvalue;
    rgbpic_picture_size_t width;
    rgbpic_picture_size_t height;
    rgbpic_pixel_t *pixelvalues;
} rgbpic_t;

typedef void (*rgbpic_manipulation_fnc_t)(rgbpic_t*);

void rgbpic_delete(rgbpic_t *pic) {
    if (pic) {
        free(pic->pixelvalues);
        free(pic);
    }
}

rgbpic_t *rgbpic_load_PBM(const char *fname) {
    FILE *file;
    rgbpic_t *pic = NULL;
    if (!(file = fopen(fname, "r"))) {
        return NULL;
    }
    if ((fgetc(file) != 'P') || (fgetc(file) != '1')) {
        goto error_handling;
    }
    pic = (rgbpic_t*)malloc(sizeof(rgbpic_t));
    if (!pic) {
        goto error_handling;
    }
    *pic = (rgbpic_t){0, 0, 0, NULL};
    if (fscanf(file, "%hd %hd", &(pic->width), &(pic->height)) != 2) {
        goto error_handling;
    }
    pic->maxpixvalue = 1;
    pic->pixelvalues = (rgbpic_pixel_t*)malloc(pic->width * pic->height * sizeof(rgbpic_pixel_t));
    if (! pic->pixelvalues) {
        goto error_handling;
    }
    unsigned int n, i;
    rgbpic_monochrome_pixel_t v;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        if (fscanf(file, "%hd", &v) != 1) {
            goto error_handling;
        }
        pic->pixelvalues[i].red   = 1 - v;
        pic->pixelvalues[i].green = 1 - v;
        pic->pixelvalues[i].blue  = 1 - v;
    }
    fclose(file);
    return pic;
  error_handling:
    fclose(file);
    rgbpic_delete(pic);
    return NULL;
}

rgbpic_t *rgbpic_load_PGM(const char *fname) {
    FILE *file;
    rgbpic_t *pic = NULL;
    if (!(file = fopen(fname, "r"))) {
        return NULL;
    }
    if ((fgetc(file) != 'P') || (fgetc(file) != '2')) {
        goto error_handling;
    }
    pic = (rgbpic_t*)malloc(sizeof(rgbpic_t));
    if (!pic) {
        goto error_handling;
    }
    *pic = (rgbpic_t){0, 0, 0, NULL};
    if (fscanf(file, "%hd %hd %hd", &(pic->width), &(pic->height), &(pic->maxpixvalue)) != 3) {
        goto error_handling;
    }
    pic->pixelvalues = (rgbpic_pixel_t*)malloc(pic->width * pic->height * sizeof(rgbpic_pixel_t));
    if (! pic->pixelvalues) {
        goto error_handling;
    }
    unsigned int n, i;
    rgbpic_monochrome_pixel_t v;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        if (fscanf(file, "%hd", &v) != 1) {
            goto error_handling;
        }
        pic->pixelvalues[i].red   = v;
        pic->pixelvalues[i].green = v;
        pic->pixelvalues[i].blue  = v;
    }
    fclose(file);
    return pic;
  error_handling:
    fclose(file);
    rgbpic_delete(pic);
    return NULL;
}

rgbpic_t *rgbpic_load_PPM(const char *fname) {
    FILE *file;
    rgbpic_t *pic = NULL;
    if (!(file = fopen(fname, "r"))) {
        return NULL;
    }
    if ((fgetc(file) != 'P') || (fgetc(file) != '3')) {
        goto error_handling;
    }
    pic = (rgbpic_t*)malloc(sizeof(rgbpic_t));
    if (!pic) {
        goto error_handling;
    }
    *pic = (rgbpic_t){0, 0, 0, NULL};
    if (fscanf(file, "%hd %hd %hd", &(pic->width), &(pic->height), &(pic->maxpixvalue)) != 3) {
        goto error_handling;
    }
    pic->pixelvalues = (rgbpic_pixel_t*)malloc(pic->width * pic->height * sizeof(rgbpic_pixel_t));
    if (! pic->pixelvalues) {
        goto error_handling;
    }
    unsigned int n, i;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        if (fscanf(file, "%hd %hd %hd",
              &pic->pixelvalues[i].red,
              &pic->pixelvalues[i].green,
              &pic->pixelvalues[i].blue) != 3) {
            goto error_handling;
        }
    }
    fclose(file);
    return pic;
  error_handling:
    fclose(file);
    rgbpic_delete(pic);
    return NULL;
}

rgbpic_t *rgbpic_load(const char *fname) {
    rgbpic_t *pic = NULL;
    UNUSED((pic = rgbpic_load_PBM(fname)) || (pic = rgbpic_load_PGM(fname)) || (pic = rgbpic_load_PPM(fname)));
    return pic;
}

void rgbpic_invert(rgbpic_t *pic) {
    int n, i;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        pic->pixelvalues[i].red   = pic->maxpixvalue - pic->pixelvalues[i].red;
        pic->pixelvalues[i].green = pic->maxpixvalue - pic->pixelvalues[i].green;
        pic->pixelvalues[i].blue  = pic->maxpixvalue - pic->pixelvalues[i].blue;
    }
}

void rgbpic_invert_R(rgbpic_t *pic) {
    int n, i;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        pic->pixelvalues[i].red   = pic->maxpixvalue - pic->pixelvalues[i].red;
    }
}

void rgbpic_invert_G(rgbpic_t *pic) {
    int n, i;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        pic->pixelvalues[i].green = pic->maxpixvalue - pic->pixelvalues[i].green;
    }
}

void rgbpic_invert_B(rgbpic_t *pic) {
    int n, i;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        pic->pixelvalues[i].blue  = pic->maxpixvalue - pic->pixelvalues[i].blue;
    }
}

void rgbpic_mirror_h(rgbpic_t *pic) {
    int i, j, l, r;
    rgbpic_pixel_t temp;
    for (i = 0; i < pic->height; ++i) {
        for (j = 0; j < pic->width / 2; ++j) {
            l = (   i  * pic->width    ) + j;
            r = ((i+1) * pic->width - 1) - j;
            temp                = pic->pixelvalues[l];
            pic->pixelvalues[l] = pic->pixelvalues[r];
            pic->pixelvalues[r] = temp;
        }
    }
}

void rgbpic_mirror_v(rgbpic_t *pic) {
    int i, j, l, r;
    rgbpic_pixel_t temp;
    for (j = 0; j < pic->width; ++j) {
        for (i = 0; i < pic->height / 2; ++i) {
            l = (                   i  * pic->width) + j;
            r = ((pic->height - 1 - i) * pic->width) + j;
            temp                = pic->pixelvalues[l];
            pic->pixelvalues[l] = pic->pixelvalues[r];
            pic->pixelvalues[r] = temp;
        }
    }
}

void rgbpic_rotate_l(rgbpic_t *pic) {
    int i, j, n;
    rgbpic_pixel_t *temp;
    n = pic->width * pic->height;
    temp = (rgbpic_pixel_t*)malloc(n * sizeof(rgbpic_pixel_t));
    if (!temp) {
        return;
    }
    for (i = 0; i < pic->height; ++i) {
        for (j = 0; j < pic->width; ++j) {
            temp[(pic->width - 1 - j) * pic->height + i] =
                    pic->pixelvalues[i * pic->width  + j];
        }
    }
    n           = pic->height;
    pic->height = pic->width;
    pic->width  = n;
    free(pic->pixelvalues);
    pic->pixelvalues = temp;
}

void rgbpic_mirror_c(rgbpic_t *pic) {
    int i, n;
    rgbpic_pixel_t temp;
    n = pic->width * pic->height;
    for (i = 0; i < n / 2; ++i) {
        temp                        = pic->pixelvalues[i];
        pic->pixelvalues[i]         = pic->pixelvalues[n - i - 1];
        pic->pixelvalues[n - i - 1] = temp;
    }
}

void rgbpic_rotate_r(rgbpic_t *pic) {
    int i, j, n;
    rgbpic_pixel_t *temp;
    n = pic->width * pic->height;
    temp = (rgbpic_pixel_t*)malloc(n * sizeof(rgbpic_pixel_t));
    if (!temp) {
        return;
    }
    for (i = 0; i < pic->height; ++i) {
        for (j = 0; j < pic->width; ++j) {
            temp[j * pic->height + pic->height - 1 - i] =
                    pic->pixelvalues[i * pic->width + j];
        }
    }
    n           = pic->height;
    pic->height = pic->width;
    pic->width  = n;
    free(pic->pixelvalues);
    pic->pixelvalues = temp;
}

void rgbpic_color_RG(rgbpic_t *pic) {
    int n, i, m;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        m                         = pic->pixelvalues[i].red;
        pic->pixelvalues[i].red   = pic->pixelvalues[i].green;
        pic->pixelvalues[i].green = m;
    }
}

void rgbpic_color_GB(rgbpic_t *pic) {
    int n, i, m;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        m                         = pic->pixelvalues[i].green;
        pic->pixelvalues[i].green = pic->pixelvalues[i].blue;
        pic->pixelvalues[i].blue  = m;
    }
}

void rgbpic_color_BR(rgbpic_t *pic) {
    int n, i, m;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        m                        = pic->pixelvalues[i].blue;
        pic->pixelvalues[i].blue = pic->pixelvalues[i].red;
        pic->pixelvalues[i].red  = m;
    }
}

void rgbpic_delete_R(rgbpic_t *pic) {
    int n, i;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        pic->pixelvalues[i].red = 0;
    }
}

void rgbpic_delete_G(rgbpic_t *pic) {
    int n, i;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        pic->pixelvalues[i].green = 0;
    }
}

void rgbpic_delete_B(rgbpic_t *pic) {
    int n, i;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        pic->pixelvalues[i].blue = 0;
    }
}

void rgbpic_convert_to_grey_avg(rgbpic_t *pic) {
    unsigned int n, i;
    rgbpic_monochrome_pixel_t v;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        v = (pic->pixelvalues[i].red + pic->pixelvalues[i].green + pic->pixelvalues[i].blue) / 3;
        pic->pixelvalues[i].red   = v;
        pic->pixelvalues[i].green = v;
        pic->pixelvalues[i].blue  = v;
    }
}

rgbpic_monochrome_pixel_t rgbpic_rgb_to_gray(rgbpic_pixel_t p) {
    return (30 * p.red + 59 * p.green + 11 * p.blue) / 100;
}

void rgbpic_convert_to_grey_lum(rgbpic_t *pic) {
    unsigned int n, i;
    rgbpic_monochrome_pixel_t v;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        v = rgbpic_rgb_to_gray(pic->pixelvalues[i]);
        pic->pixelvalues[i].red   = v;
        pic->pixelvalues[i].green = v;
        pic->pixelvalues[i].blue  = v;
    }
}

void rgbpic_convert_R_to_grey(rgbpic_t *pic) {
    int n, i;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        pic->pixelvalues[i].green = pic->pixelvalues[i].red;
        pic->pixelvalues[i].blue  = pic->pixelvalues[i].red;
    }
}

void rgbpic_convert_G_to_grey(rgbpic_t *pic) {
    int n, i;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        pic->pixelvalues[i].red  = pic->pixelvalues[i].green;
        pic->pixelvalues[i].blue = pic->pixelvalues[i].green;
    }
}

void rgbpic_convert_B_to_grey(rgbpic_t *pic) {
    int n, i;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        pic->pixelvalues[i].red   = pic->pixelvalues[i].blue;
        pic->pixelvalues[i].green = pic->pixelvalues[i].blue;
    }
}

void rgbpic_convert_to_bw_lum(rgbpic_t *pic) {
    unsigned int n, i;
    rgbpic_monochrome_pixel_t v;
    n = pic->width * pic->height;
    for (i = 0; i < n; ++i) {
        v = (rgbpic_rgb_to_gray(pic->pixelvalues[i]) > pic->maxpixvalue / 2) * pic->maxpixvalue;
        pic->pixelvalues[i].red   = v;
        pic->pixelvalues[i].green = v;
        pic->pixelvalues[i].blue  = v;
    }
}

int rgbpic_save_PBM(const char *fname, rgbpic_t *pic) {
    FILE *file;
    unsigned int n, i;
    if (!(file = fopen(fname, "w"))) {
        return 1;
    }
    n = pic->width * pic->height;
    fprintf(file, "P1\n%hd %hd\n", pic->width, pic->height);
    for (i = 0; i < n; ++i) {
        rgbpic_monochrome_pixel_t v = rgbpic_rgb_to_gray(pic->pixelvalues[i]) <= pic->maxpixvalue / 2;
        fprintf(file, "%hd%c", v, ((i + 1) % pic->width) ? ' ' : '\n');
    }
    fclose(file);
    return 0;
}

int rgbpic_save_PGM(const char *fname, rgbpic_t *pic) {
    FILE *file;
    unsigned int n, i;
    if (!(file = fopen(fname, "w"))) {
        return 1;
    }
    n = pic->width * pic->height;
    fprintf(file, "P2\n%hd %hd\n%hd\n",
            pic->width,
            pic->height,
            pic->maxpixvalue);
    for (i = 0; i < n; ++i) {
        rgbpic_monochrome_pixel_t v = rgbpic_rgb_to_gray(pic->pixelvalues[i]);
        fprintf(file, "%hd%c", v, ((i + 1) % pic->width) ? ' ' : '\n');
    }
    fclose(file);
    return 0;
}

int rgbpic_save_PPM(const char *fname, rgbpic_t *pic) {
    FILE *file;
    unsigned int n, i;
    if (!(file = fopen(fname, "w"))) {
        return 1;
    }
    n = pic->width * pic->height;
    fprintf(file, "P3\n%hd %hd\n%hd\n",
            pic->width,
            pic->height,
            pic->maxpixvalue);
    for (i = 0; i < n; ++i) {
        fprintf(file, "%hd %hd %hd%c",
                pic->pixelvalues[i].red,
                pic->pixelvalues[i].green,
                pic->pixelvalues[i].blue,
                ((i + 1) % pic->width) ? ' ' : '\n');
    }
    fclose(file);
    return 0;
}

typedef void (*modf)(rgbpic_t*);
typedef struct modparam {
    char                      *option;
    rgbpic_manipulation_fnc_t function;
} modparam;

modparam otable[] = {
    {"-i",   rgbpic_invert},
    {"-iR",  rgbpic_invert_R},
    {"-iG",  rgbpic_invert_G},
    {"-iB",  rgbpic_invert_B},
    {"-v",   rgbpic_mirror_v},
    {"-h",   rgbpic_mirror_h},
    {"-c",   rgbpic_mirror_c},
    {"-l",   rgbpic_rotate_l},
    {"-r",   rgbpic_rotate_r},
    {"-xRG", rgbpic_color_RG},
    {"-xGB", rgbpic_color_GB},
    {"-xBR", rgbpic_color_BR},
    {"-dR",  rgbpic_delete_R},
    {"-dG",  rgbpic_delete_G},
    {"-dB",  rgbpic_delete_B},
    {"-g",   rgbpic_convert_to_grey_lum},
    {"-gR",  rgbpic_convert_R_to_grey},
    {"-gG",  rgbpic_convert_G_to_grey},
    {"-gB",  rgbpic_convert_B_to_grey},
    {"-b",   rgbpic_convert_to_bw_lum},
    {NULL, NULL}
};

typedef int (*savf)(const char*, rgbpic_t*);
typedef struct savparam {
    char *option;
    savf function;
} savparam;

savparam stable[] = {
    {"-PBM", rgbpic_save_PBM},
    {"-PGM", rgbpic_save_PGM},
    {"-PPM", rgbpic_save_PPM},
    {NULL, NULL}
};

/*
 * A main függvény.
 */
int main(int argc, char *argv[]) {
    int argi;
    rgbpic_t *kep;                              /* A kép (illetve a képre mutató pointer) */
    if (argc < 4) {                                            /* Ha nincs elég paraméter */
        printf("Nincs eleg parameter!\n");
        printf("Használat: %s <inputfile>", argv[0]);
        if (stable->option) {
            savparam *sp = stable;
            printf(" %s", sp->option);
            while ((++sp)->option) {
                printf("|%s", sp->option);
            }
        }
        printf(" <outputfile>");
        if (otable->option) {
            modparam *mp = otable;
            printf(" [%s", mp->option);
            while ((++mp)->option) {
                printf(", %s", mp->option);
            }
        }
        printf("]\n");
        return 1;
    }
    if (!(kep = rgbpic_load(argv[1]))) {  /* Az első paramétert input képként értelmezzük */
        printf("Nem sikerult megnyitni: %s\n", argv[1]);
        return 1;
    }
    /*
     * A 4. paramétertől kezdve az elvégzendő műveletek kapcsolói
     * szerepelnek.
     */
    for (argi = 4; argi < argc; ++argi) {
        /*
         * Megkeressük, hogy a következő kapcsoló benne van-e az
         * előbb összeállított táblázatunkban.
         */
        for (modparam *p = otable; p->option; ++p) {
            /*
             * Ha megtaláltuk, a hozzá tartozó módosító
             * függvényt végrehajtjuk a képre, és nem
             * keressük tovább, hanem nézzük a következő
             * paramétert.
             */
            if (!strcmp(p->option, argv[argi])) {
                p->function(kep);
                break;
            }
        }
    }
    /*
     * A 2. paraméter a kiíratás formátumát adja meg, ezt is
     * megkeressük az előre megadott másik tömbünkben.
     */
    for (savparam *sp = stable; sp->option; ++sp) {
        if (!strcmp(sp->option, argv[2])) {
            /*
             * Ha megtaláltuk, akkor a hozzá tartozó
             * függvény segítségével elmentjük a képet a
             * megadott néven (3. paraméter).
             */
            if (sp->function(argv[3], kep)) {
                /* Ha a mentés nem sikerült, a program
                 * szövegesen is jelez és hibakóddal tér
                 * vissza.
                 */
                printf("Nem sikerult elmenteni: %s\n", argv[2]);
                rgbpic_delete(kep);
                return 1;
            }
            break;
        }
    }
    /* Töröljük a képet. */
    rgbpic_delete(kep);
    return 0;
}

/*
 * Némi megjegyzés a végére: a képet beolvasása során RGB formátumúra
 * konvertáljuk, és végig ezen a formátumon dolgozunk. Tehát amikor azt
 * mondjuk, hogy szürkeárnyalatos képet csinálunk belőle, a szürke
 * értékeket akkor is RGB formátumban tároljuk, és a fekete-fehérré
 * alakítással is így járunk el. Ilyen módon is igaz viszont az, hogy
 * egy szürke képet ismét szürkévé, vagy fekete-fehéret ismét fekete-
 * fehérré alakítva már semmilyen változás nem történik a képben. Tehát
 * ilyen módon nem kell megjegyeznünk, hogy az adott kép éppen milyen
 * formátumú. Kiíratásnál pedig elvégezzük a megfelelő konverziót (ha
 * kell), így a tárolt kép már a megfelelő alakú lesz mielőtt a fájlba
 * kerül.
 */

A program fordítása egyszerű, hiszen egyetlen C forrásfájlból áll.

A makefile

Makefile:

manipulate_PROG:=pnm-manipulate
manipulate_SRCS:=pnm-monolit-manipulate.c
manipulate_OBJS:=$(patsubst %.c,%.o,$(manipulate_SRCS))
manipulate_DEPS:=$(patsubst %.c,%.d,$(manipulate_SRCS))

manipulate_CPPFLAGS:=$(CPPFLAGS)
manipulate_CFLAGS:=$(CFLAGS) -Wall
manipulate_LDFLAGS:=$(LDFLAGS)
manipulate_LDLIBS:=$(LDLIBS)

all: $(manipulate_PROG)

$(manipulate_OBJS): %.o: %.c
    $(CC) -c $(manipulate_CPPFLAGS) $(manipulate_CFLAGS) $< -o $@

$(manipulate_DEPS): %.d: %.c
    $(CC) -MM $(manipulate_CPPFLAGS) $< -MF $@

$(manipulate_PROG): $(manipulate_OBJS)
    $(CC) $(manipulate_CFLAGS) $(manipulate_LDFLAGS) $^ $(manipulate_LDLIBS) -o $@

clean:
    rm -rf $(manipulate_PROG) $(manipulate_OBJS) $(manipulate_DEPS)

.PHONY: all clean

include $(manipulate_DEPS)

A makefile segítségével készítsük el a programot, majd futtassuk.

make
./pnm-monolit-manipulate torony-o.ppm -PPM inverted.ppm -i
make clean

Közös részek kiszervezése¶

Ha mindkét programra szükségünk van, akkor megtehetjük, hogy egy közös könyvtárba rakjuk őket, a makefile-jaikat pedig összegyúrjuk. A két monolit programnak viszont sok közös eleme van:

adattípusok
függvények

Nem szerencsés, hogy ezeket külön-külön többször írjuk meg (és ebbe most beleétjük azt is, hogy csak egyszer írjuk meg és utána copy-paste-tel átmásoljuk). Így ugyanis úgynevezett klónjaink, kódmásolataink lesznek, amiket hosszú távon nem olyan egyszerű kezelni (ha páldául kiderül, hogy valamit hibásan írtunk meg, több helyen kell kijavítani).

Szóval, fogjuk a forrásainkat, és szervezzük ki/át az egyes elemeket. A kiindulóállapot tömörítve innen letölthető, bár itt a Makefile már az elvárt végállapot szerint fordít.

Készítsünk másolatot a pnm-monolit-info.c-ről pnm-info.c néven.
Készítsünk másolatot a pnm-monolit-manipulate.c-ről pnm-manipulate.c néven.
Készítsünk egy pnm-type.h header fájlt, és mozgassuk át bele a pnm-info.c és pnm-manipulate.c forrásfájlokban is megtalálható közös típusdefiníciókat és azoknak a függvényeknek a deklarációit, amik a képeket betöltik/elmentik/létrehozzák/törlik.
Készítsünk egy pnm-type.c fájlt, és mozgassuk át bele a pnm-info.c és pnm-manipulate.c forrásfájlokban is megtalálható olyan függvények a definícióit, amik a képeket betöltik/elmentik/létrehozzák/törlik.
Készítsünk egy pnm-manipulation.h header fájlt, és mozgassuk át a pnm-manipulate.c forrásfáljból a típusdefiníciókat és azoknak a függvényeknek a deklarációit, amik a képeket manipulálják.
Készítsünk egy pnm-manipulation.c fájlt, és mozgassuk át a pnm-manipulate.c forrásfáljból azoknak a függvényeknek a definícióit, amik a képeket manipulálják.
Most akkor 2 header és 4 forrásfájlunk van.
Fogjuk az alábbi Makefile-t, és a segítségével próbáljuk meg elkészíteni a két programot:
1
make

A Makefile

Makefile:

info_PROG:=pnm-info
info_SRCS:=pnm-info.c
info_OBJS:=$(patsubst %.c,%.o,$(info_SRCS))
info_DEPS:=$(patsubst %.c,%.d,$(info_SRCS))

manipulate_PROG:=pnm-manipulate
manipulate_SRCS:=pnm-manipulate.c
manipulate_OBJS:=$(patsubst %.c,%.o,$(manipulate_SRCS))
manipulate_DEPS:=$(patsubst %.c,%.d,$(manipulate_SRCS))

common_SRCS:=pnm-type.c pnm-manipulation.c
common_OBJS:=$(patsubst %.c,%.o,$(common_SRCS))
common_DEPS:=$(patsubst %.c,%.d,$(common_SRCS))

CPPFLAGS:=$(CPPFLAGS)
CFLAGS:=$(CFLAGS) -Wall
info_LDFLAGS:=$(LDFLAGS)
info_LDLIBS:=$(LDLIBS)
manipulate_LDFLAGS:=$(LDFLAGS)
manipulate_LDLIBS:=$(LDLIBS)

all: $(info_PROG) $(manipulate_PROG)

$(info_OBJS) $(manipulate_OBJS) $(common_OBJS): %.o: %.c
    $(CC) -c $(CPPFLAGS) $(CFLAGS) $< -o $@

$(info_DEPS) $(manipulate_DEPS) $(common_DEPS): %.d: %.c
    $(CC) -MM $(CPPFLAGS) $< -MF $@

$(info_PROG): $(info_OBJS) $(common_OBJS)
    $(CC) $(CFLAGS) $(info_LDFLAGS) $^ $(info_LDLIBS) -o $@

$(manipulate_PROG): $(manipulate_OBJS) $(common_OBJS)
    $(CC) $(CFLAGS) $(manipulate_LDFLAGS) $^ $(manipulate_LDLIBS) -o $@

clean:
    rm -rf $(info_PROG) $(info_OBJS) $(info_DEPS) $(manipulate_PROG) $(manipulate_OBJS) $(manipulate_DEPS) $(common_OBJS) $(common_DEPS)

.PHONY: all clean

include $(info_DEPS) $(manipulate_DEPS) $(common_DEPS)

Ez elsőre nem fog menni, mert az át/kiszervezések miatt lesznek hibák (hiányzó típusok, függvénydeklarációk). Javítsuk ezeket:
- Include-oljuk a pnm-type.h headert a pnm-info.c-ben (sajátként, nem #include <...> hanem #include "...").
- Include-oljuk a pnm-type.h headert a pnm-manipulation.h-ban.
- Include-oljuk a pnm-type.h és pnm-manipulation.h header fájlokat a pnm-manipulate.c-ben.
- Védjük le a header fájljainkat a többszörös include ellen (#ifndef XXX_H / #define XXX_H / #endif).
Próbáljuk ismét a make parancsot.
Korrigáljuk a maradék hibákat, amíg nem lesz sikeres a make futása.
Optimalizáljunk kicsit. Fogjuk a rgbpic_coord() és rgbpic_rgb_to_gray() függvényeket, és vigyük át őket a pnm-type.c-ből a pnm-type.h-ba, és tegyük őket static inline-ná.

Mi az a static inline?

Egyrészt ez a két függvény nagyon egyszerű, tulajdonképpen jobban járnánk, ha nem is függvényként használnánk őket, hanem az eredményüket kiszámoló kifejezéseket mindenhol behelyettesítenénk a függvényhívás helyén. (Megspórolnánk a függvényhívást előkészítő és visszatérését kezelő gépi utasításokat, és így a végrehajtás is gyorsabb lenne.) Az inline pont azt mondja a fordítónak, hogy ha úgy látja, ezt tegye meg. Ehhez viszont az kell, hogy már fordítási időben rendelkezésre álljon a függvény kódja (definíciója) is, ezért lett ez a két függvény a header-ben definiálva.

Mivel a header fájlokat több forrás is include-olja és ezeknek a függvényeknek most a definíciója van a header-ben, ha több ilyen forrásból készült object-eket szeretnénk összepakolni (márpedig pont ezt fogjuk csinálni), akkor ezek a definíciók csúnyán összevesznének a linkelésnél (még akkor is, ha a függvény inline, mert ez "csak egy ajánlás" a fordító számára, és a biztonság kedvéért megtartja a függvényt külön függvényként is). A static itt (a globális scope-ban) azt jelenti, hogy az adott elem (jelen esetben függvény) csak az adott forrásfájlból készült object-ben lesz látható. Így tehát hiába lesz benne több forrásban és így több objectben is, az összerakott object-ek ezeket "nem teszik be a közösbe", hanem megtartják maguknak (mindenki a saját definícióját), így nem lesz min összeveszni.

Korrigáljuk a maradék hibákat, amíg nem lesz sikeres a make futása. Az eredmény valami ilyesmi lesz:

A pnm-type headerje és forráskódja

pnm-type.h:

/*
 * Szegedi Tudományegyetem
 * Informatikai Tanszékcsoport
 * Szoftverfejlesztés Tanszék
 */

#ifndef PNM_TYPE_H
#define PNM_TYPE_H

typedef unsigned short int rgbpic_monochrome_pixel_t;
typedef unsigned short int rgbpic_picture_size_t;

typedef struct {
    rgbpic_monochrome_pixel_t red;
    rgbpic_monochrome_pixel_t green;
    rgbpic_monochrome_pixel_t blue;
} rgbpic_pixel_t;

typedef struct {
    rgbpic_monochrome_pixel_t maxpixvalue;
    rgbpic_picture_size_t width;
    rgbpic_picture_size_t height;
    rgbpic_pixel_t *pixelvalues;
} rgbpic_t;

static inline int rgbpic_coord(rgbpic_t *pic, rgbpic_picture_size_t x, rgbpic_picture_size_t y) {
    return  y * pic->width + x;
}

static inline rgbpic_monochrome_pixel_t rgbpic_rgb_to_gray(rgbpic_pixel_t p) {
    return (30 * p.red + 59 * p.green + 11 * p.blue) / 100;
}

rgbpic_t *rgbpic_load(const char*);
rgbpic_t *rgbpic_load_PBM(const char*);
rgbpic_t *rgbpic_load_PGM(const char*);
rgbpic_t *rgbpic_load_PPM(const char*);

int rgbpic_save_PBM(const char*, rgbpic_t*);
int rgbpic_save_PGM(const char*, rgbpic_t*);
int rgbpic_save_PPM(const char*, rgbpic_t*);

rgbpic_t *rgbpic_create(rgbpic_picture_size_t width, rgbpic_picture_size_t height, rgbpic_monochrome_pixel_t max);
void rgbpic_delete(rgbpic_t*);

#endif // PNM_TYPE_H

pnm-type.c:

/*
 * Szegedi Tudományegyetem
 * Informatikai Tanszékcsoport
 * Szoftverfejlesztés Tanszék
 */

#include "pnm-type.h"

#include <stdio.h>
#include <string.h>
#include <malloc.h>

#define UNUSED(X) (void)(X)
#define FORALLPIXELS(P,I) for (unsigned int I = 0, __pxcnt = P->width * P->height; I < __pxcnt; ++I)

rgbpic_t *rgbpic_load(const char *fname) {
    rgbpic_t *pic = NULL;
    UNUSED((pic = rgbpic_load_PBM(fname)) || (pic = rgbpic_load_PGM(fname)) || (pic = rgbpic_load_PPM(fname)));
    return pic;
}

rgbpic_t *rgbpic_load_PBM(const char *fname) {
    FILE *file;
    rgbpic_t *pic = NULL;
    if (!(file = fopen(fname, "r"))) {
        return NULL;
    }
    if ((fgetc(file) != 'P') || (fgetc(file) != '1')) {
        goto error_handling;
    }
    pic = (rgbpic_t*)malloc(sizeof(rgbpic_t));
    if (!pic) {
        goto error_handling;
    }
    *pic = (rgbpic_t){0, 0, 0, NULL};
    if (fscanf(file, "%hd %hd", &(pic->width), &(pic->height)) != 2) {
        goto error_handling;
    }
    pic->maxpixvalue = 1;
    pic->pixelvalues = (rgbpic_pixel_t*)malloc(pic->width * pic->height * sizeof(rgbpic_pixel_t));
    if (! pic->pixelvalues) {
        goto error_handling;
    }
    rgbpic_monochrome_pixel_t v;
    FORALLPIXELS(pic, i) {
        if (fscanf(file, "%hd", &v) != 1) {
            goto error_handling;
        }
        pic->pixelvalues[i].red   = 1 - v;
        pic->pixelvalues[i].green = 1 - v;
        pic->pixelvalues[i].blue  = 1 - v;
    }
    fclose(file);
    return pic;
  error_handling:
    fclose(file);
    rgbpic_delete(pic);
    return NULL;
}

rgbpic_t *rgbpic_load_PGM(const char *fname) {
    FILE *file;
    rgbpic_t *pic = NULL;
    if (!(file = fopen(fname, "r"))) {
        return NULL;
    }
    if ((fgetc(file) != 'P') || (fgetc(file) != '2')) {
        goto error_handling;
    }
    pic = (rgbpic_t*)malloc(sizeof(rgbpic_t));
    if (!pic) {
        goto error_handling;
    }
    *pic = (rgbpic_t){0, 0, 0, NULL};
    if (fscanf(file, "%hd %hd %hd", &(pic->width), &(pic->height), &(pic->maxpixvalue)) != 3) {
        goto error_handling;
    }
    pic->pixelvalues = (rgbpic_pixel_t*)malloc(pic->width * pic->height * sizeof(rgbpic_pixel_t));
    if (! pic->pixelvalues) {
        goto error_handling;
    }
    rgbpic_monochrome_pixel_t v;
    FORALLPIXELS(pic, i) {
        if (fscanf(file, "%hd", &v) != 1) {
            goto error_handling;
        }
        pic->pixelvalues[i].red   = v;
        pic->pixelvalues[i].green = v;
        pic->pixelvalues[i].blue  = v;
    }
    fclose(file);
    return pic;
  error_handling:
    fclose(file);
    rgbpic_delete(pic);
    return NULL;
}

rgbpic_t *rgbpic_load_PPM(const char *fname) {
    FILE *file;
    rgbpic_t *pic = NULL;
    if (!(file = fopen(fname, "r"))) {
        return NULL;
    }
    if ((fgetc(file) != 'P') || (fgetc(file) != '3')) {
        goto error_handling;
    }
    pic = (rgbpic_t*)malloc(sizeof(rgbpic_t));
    if (!pic) {
        goto error_handling;
    }
    *pic = (rgbpic_t){0, 0, 0, NULL};
    if (fscanf(file, "%hd %hd %hd", &(pic->width), &(pic->height), &(pic->maxpixvalue)) != 3) {
        goto error_handling;
    }
    pic->pixelvalues = (rgbpic_pixel_t*)malloc(pic->width * pic->height * sizeof(rgbpic_pixel_t));
    if (! pic->pixelvalues) {
        goto error_handling;
    }
    FORALLPIXELS(pic, i) {
        if (fscanf(file, "%hd %hd %hd",
              &pic->pixelvalues[i].red,
              &pic->pixelvalues[i].green,
              &pic->pixelvalues[i].blue) != 3) {
            goto error_handling;
        }
    }
    fclose(file);
    return pic;
  error_handling:
    fclose(file);
    rgbpic_delete(pic);
    return NULL;
}

int rgbpic_save_PBM(const char *fname, rgbpic_t *pic) {
    FILE *file;
    if (!(file = fopen(fname, "w"))) {
        return 1;
    }
    fprintf(file, "P1\n%hd %hd\n", pic->width, pic->height);
    FORALLPIXELS(pic, i) {
        rgbpic_monochrome_pixel_t v = rgbpic_rgb_to_gray(pic->pixelvalues[i]) <= pic->maxpixvalue / 2;
        fprintf(file, "%hd%c", v, ((i + 1) % pic->width) ? ' ' : '\n');
    }
    fclose(file);
    return 0;
}

int rgbpic_save_PGM(const char *fname, rgbpic_t *pic) {
    FILE *file;
    if (!(file = fopen(fname, "w"))) {
        return 1;
    }
    fprintf(file, "P2\n%hd %hd\n%hd\n",
            pic->width,
            pic->height,
            pic->maxpixvalue);
    FORALLPIXELS(pic, i) {
        rgbpic_monochrome_pixel_t v = rgbpic_rgb_to_gray(pic->pixelvalues[i]);
        fprintf(file, "%hd%c", v, ((i + 1) % pic->width) ? ' ' : '\n');
    }
    fclose(file);
    return 0;
}

int rgbpic_save_PPM(const char *fname, rgbpic_t *pic) {
    FILE *file;
    if (!(file = fopen(fname, "w"))) {
        return 1;
    }
    fprintf(file, "P3\n%hd %hd\n%hd\n",
            pic->width,
            pic->height,
            pic->maxpixvalue);
    FORALLPIXELS(pic, i) {
        fprintf(file, "%hd %hd %hd%c",
                pic->pixelvalues[i].red,
                pic->pixelvalues[i].green,
                pic->pixelvalues[i].blue,
                ((i + 1) % pic->width) ? ' ' : '\n');
    }
    fclose(file);
    return 0;
}

rgbpic_t *rgbpic_create(rgbpic_picture_size_t width, rgbpic_picture_size_t height, rgbpic_monochrome_pixel_t max) {
    rgbpic_t *pic = (rgbpic_t*)malloc(sizeof(rgbpic_t));
    if (!pic) {
        return NULL;
    }
    *pic = (rgbpic_t){max, width, height, (rgbpic_pixel_t*)malloc(width * height * sizeof(rgbpic_pixel_t))};
    if (! pic->pixelvalues) {
        rgbpic_delete(pic);
        return NULL;
    }
    memset(pic->pixelvalues, 0, width * height * sizeof(rgbpic_pixel_t));
    return pic;
}

void rgbpic_delete(rgbpic_t *pic) {
    if (pic) {
        free(pic->pixelvalues);
        free(pic);
    }
}

A pnm-manipulation headerje és forráskódja

pnm-manipulation.h:

/*
 * Szegedi Tudományegyetem
 * Informatikai Tanszékcsoport
 * Szoftverfejlesztés Tanszék
 */

#ifndef PNM_MANIPULATION_H
#define PNM_MANIPULATION_H

#include "pnm-type.h"

typedef void (*rgbpic_manipulation_fnc_t)(rgbpic_t*);

void rgbpic_invert(rgbpic_t*);
void rgbpic_invert_R(rgbpic_t*);
void rgbpic_invert_G(rgbpic_t*);
void rgbpic_invert_B(rgbpic_t*);
void rgbpic_mirror_h(rgbpic_t*);
void rgbpic_mirror_v(rgbpic_t*);
void rgbpic_rotate_l(rgbpic_t*);
void rgbpic_mirror_c(rgbpic_t*);
void rgbpic_rotate_r(rgbpic_t*);
void rgbpic_color_RG(rgbpic_t*);
void rgbpic_color_GB(rgbpic_t*);
void rgbpic_color_BR(rgbpic_t*);
void rgbpic_delete_R(rgbpic_t*);
void rgbpic_delete_G(rgbpic_t*);
void rgbpic_delete_B(rgbpic_t*);
void rgbpic_convert_to_grey_avg(rgbpic_t*);
void rgbpic_convert_to_grey_lum(rgbpic_t*);
void rgbpic_convert_R_to_grey(rgbpic_t*);
void rgbpic_convert_G_to_grey(rgbpic_t*);
void rgbpic_convert_B_to_grey(rgbpic_t*);
void rgbpic_convert_to_bw_avg(rgbpic_t*);
void rgbpic_convert_to_bw_lum(rgbpic_t*);

#endif // PNM_MANIPULATION_H

pnm-manipulation.c:

/*
 * Szegedi Tudományegyetem
 * Informatikai Tanszékcsoport
 * Szoftverfejlesztés Tanszék
 */

#include "pnm-manipulation.h"

#include <malloc.h>

#define FORALLPIXELS(P,I) for (unsigned int I = 0, __pxcnt = P->width * P->height; I < __pxcnt; ++I)

void rgbpic_invert(rgbpic_t *pic) {
    FORALLPIXELS(pic, i) {
        pic->pixelvalues[i].red   = pic->maxpixvalue - pic->pixelvalues[i].red;
        pic->pixelvalues[i].green = pic->maxpixvalue - pic->pixelvalues[i].green;
        pic->pixelvalues[i].blue  = pic->maxpixvalue - pic->pixelvalues[i].blue;
    }
}

void rgbpic_invert_R(rgbpic_t *pic) {
    FORALLPIXELS(pic, i) {
        pic->pixelvalues[i].red   = pic->maxpixvalue - pic->pixelvalues[i].red;
    }
}

void rgbpic_invert_G(rgbpic_t *pic) {
    FORALLPIXELS(pic, i) {
        pic->pixelvalues[i].green = pic->maxpixvalue - pic->pixelvalues[i].green;
    }
}

void rgbpic_invert_B(rgbpic_t *pic) {
    FORALLPIXELS(pic, i) {
        pic->pixelvalues[i].blue  = pic->maxpixvalue - pic->pixelvalues[i].blue;
    }
}

void rgbpic_mirror_h(rgbpic_t *pic) {
    int i, j, l, r;
    rgbpic_pixel_t temp;
    for (i = 0; i < pic->height; ++i) {
        for (j = 0; j < pic->width / 2; ++j) {
            l = rgbpic_coord(pic, j, i);
            r = rgbpic_coord(pic, pic->width - j - 1, i);
            temp                = pic->pixelvalues[l];
            pic->pixelvalues[l] = pic->pixelvalues[r];
            pic->pixelvalues[r] = temp;
        }
    }
}

void rgbpic_mirror_v(rgbpic_t *pic) {
    int i, j, l, r;
    rgbpic_pixel_t temp;
    for (j = 0; j < pic->width; ++j) {
        for (i = 0; i < pic->height / 2; ++i) {
            l = rgbpic_coord(pic, j, i);
            r = rgbpic_coord(pic, j, pic->height - i - 1);
            temp                = pic->pixelvalues[l];
            pic->pixelvalues[l] = pic->pixelvalues[r];
            pic->pixelvalues[r] = temp;
        }
    }
}

void rgbpic_rotate_l(rgbpic_t *pic) {
    int i, j, n;
    rgbpic_pixel_t *temp;
    n = pic->width * pic->height;
    temp = (rgbpic_pixel_t*)malloc(n * sizeof(rgbpic_pixel_t));
    if (!temp) {
        return;
    }
    for (i = 0; i < pic->height; ++i) {
        for (j = 0; j < pic->width; ++j) {
            temp[(pic->width - 1 - j) * pic->height + i] =
                    pic->pixelvalues[rgbpic_coord(pic, j, i)];
        }
    }
    n           = pic->height;
    pic->height = pic->width;
    pic->width  = n;
    free(pic->pixelvalues);
    pic->pixelvalues = temp;
}

void rgbpic_mirror_c(rgbpic_t *pic) {
    int i, n;
    rgbpic_pixel_t temp;
    n = pic->width * pic->height;
    for (i = 0; i < n / 2; ++i) {
        temp                        = pic->pixelvalues[i];
        pic->pixelvalues[i]         = pic->pixelvalues[n - i - 1];
        pic->pixelvalues[n - i - 1] = temp;
    }
}

void rgbpic_rotate_r(rgbpic_t *pic) {
    int i, j, n;
    rgbpic_pixel_t *temp;
    n = pic->width * pic->height;
    temp = (rgbpic_pixel_t*)malloc(n * sizeof(rgbpic_pixel_t));
    if (!temp) {
        return;
    }
    for (i = 0; i < pic->height; ++i) {
        for (j = 0; j < pic->width; ++j) {
            temp[j * pic->height + pic->height - 1 - i] =
                    pic->pixelvalues[rgbpic_coord(pic, j, i)];
        }
    }
    n           = pic->height;
    pic->height = pic->width;
    pic->width  = n;
    free(pic->pixelvalues);
    pic->pixelvalues = temp;
}

void rgbpic_color_RG(rgbpic_t *pic) {
    FORALLPIXELS(pic, i) {
        rgbpic_monochrome_pixel_t m;
        m                         = pic->pixelvalues[i].red;
        pic->pixelvalues[i].red   = pic->pixelvalues[i].green;
        pic->pixelvalues[i].green = m;
    }
}

void rgbpic_color_GB(rgbpic_t *pic) {
    FORALLPIXELS(pic, i) {
        rgbpic_monochrome_pixel_t m;
        m                         = pic->pixelvalues[i].green;
        pic->pixelvalues[i].green = pic->pixelvalues[i].blue;
        pic->pixelvalues[i].blue  = m;
    }
}

void rgbpic_color_BR(rgbpic_t *pic) {
    FORALLPIXELS(pic, i) {
        rgbpic_monochrome_pixel_t m;
        m                        = pic->pixelvalues[i].blue;
        pic->pixelvalues[i].blue = pic->pixelvalues[i].red;
        pic->pixelvalues[i].red  = m;
    }
}

void rgbpic_delete_R(rgbpic_t *pic) {
    FORALLPIXELS(pic, i) {
        pic->pixelvalues[i].red = 0;
    }
}

void rgbpic_delete_G(rgbpic_t *pic) {
    FORALLPIXELS(pic, i) {
        pic->pixelvalues[i].green = 0;
    }
}

void rgbpic_delete_B(rgbpic_t *pic) {
    FORALLPIXELS(pic, i) {
        pic->pixelvalues[i].blue = 0;
    }
}

void rgbpic_convert_to_grey_avg(rgbpic_t *pic) {
    rgbpic_monochrome_pixel_t v;
    FORALLPIXELS(pic, i) {
        v = (pic->pixelvalues[i].red + pic->pixelvalues[i].green + pic->pixelvalues[i].blue) / 3;
        pic->pixelvalues[i].red   = v;
        pic->pixelvalues[i].green = v;
        pic->pixelvalues[i].blue  = v;
    }
}

void rgbpic_convert_to_grey_lum(rgbpic_t *pic) {
    rgbpic_monochrome_pixel_t v;
    FORALLPIXELS(pic, i) {
        v = rgbpic_rgb_to_gray(pic->pixelvalues[i]);
        pic->pixelvalues[i].red   = v;
        pic->pixelvalues[i].green = v;
        pic->pixelvalues[i].blue  = v;
    }
}

void rgbpic_convert_R_to_grey(rgbpic_t *pic) {
    FORALLPIXELS(pic, i) {
        pic->pixelvalues[i].green = pic->pixelvalues[i].red;
        pic->pixelvalues[i].blue  = pic->pixelvalues[i].red;
    }
}

void rgbpic_convert_G_to_grey(rgbpic_t *pic) {
    FORALLPIXELS(pic, i) {
        pic->pixelvalues[i].red  = pic->pixelvalues[i].green;
        pic->pixelvalues[i].blue = pic->pixelvalues[i].green;
    }
}

void rgbpic_convert_B_to_grey(rgbpic_t *pic) {
    FORALLPIXELS(pic, i) {
        pic->pixelvalues[i].red   = pic->pixelvalues[i].blue;
        pic->pixelvalues[i].green = pic->pixelvalues[i].blue;
    }
}

void rgbpic_convert_to_bw_avg(rgbpic_t *pic) {
    rgbpic_monochrome_pixel_t v;
    FORALLPIXELS(pic, i) {
        v = (2 * (pic->pixelvalues[i].red + pic->pixelvalues[i].green + pic->pixelvalues[i].blue) > 3 * pic->maxpixvalue) * pic->maxpixvalue;
        pic->pixelvalues[i].red   = v;
        pic->pixelvalues[i].green = v;
        pic->pixelvalues[i].blue  = v;
    }
}

void rgbpic_convert_to_bw_lum(rgbpic_t *pic) {
    rgbpic_monochrome_pixel_t v;
    FORALLPIXELS(pic, i) {
        v = (rgbpic_rgb_to_gray(pic->pixelvalues[i]) > pic->maxpixvalue / 2) * pic->maxpixvalue;
        pic->pixelvalues[i].red   = v;
        pic->pixelvalues[i].green = v;
        pic->pixelvalues[i].blue  = v;
    }
}

A két főprogram forráskódja

pnm-info.c:

/*
 * Szegedi Tudományegyetem
 * Informatikai Tanszékcsoport
 * Szoftverfejlesztés Tanszék
 */

#include "pnm-type.h"

#include <malloc.h>
#include <stdio.h>

/*
 * A main függvény.
 */
int main(int argc, char *argv[]) {
    rgbpic_t *kep;                              /* A kép (illetve a képre mutató pointer) */
    rgbpic_picture_size_t i, j;
    int szurke = 1, binary = 1;
    unsigned long long int iR = 0, iG = 0, iB = 0;
    if (argc < 2) {                                            /* Ha nincs elég paraméter */
        printf("Nincs elég paraméter!\n");
        return 1;
    }
    if (!(kep = rgbpic_load(argv[1]))) {  /* Az első paramétert input képként értelmezzük */
        printf("Nem sikerült megnyitni: %s\n", argv[1]);
        return 1;
    }
    printf("A képfájl neve: %s\n", argv[1]);
    printf("\tmérete: %hdx%hd pixel\n", kep->width, kep->height);
    for (i = 0; i < kep->height; ++i) {
        for (j = 0; j < kep->width; ++j) {
            rgbpic_monochrome_pixel_t r, g, b;
            iR += r = kep->pixelvalues[rgbpic_coord(kep, j, i)].red;
            iG += g = kep->pixelvalues[rgbpic_coord(kep, j, i)].green;
            iB += b = kep->pixelvalues[rgbpic_coord(kep, j, i)].blue;
            if (r != g || r != b) {
                szurke = binary = 0;
            }
            if (r != 0 && r != kep->maxpixvalue) {
                binary = 0;
            }
        }
    }
    if (binary) {
        printf("\tEz egy fekete-fehér bináris kép %llu%%-os átlagos szürke intenzitással.\n",
                    100llu * iR / (kep->width * kep->height * kep->maxpixvalue));
    } else if (szurke) {
        printf("\tEz egy szürkeárnyalatos kép %llu%%-os átlagos intenzitással.\n",
                    100llu * iR / (kep->width * kep->height * kep->maxpixvalue));
    } else {
        printf("\tEz egy színes kép (%llu%%, %llu%%, %llu%%)-os átlagos RGB,\n",
                    100llu * iR / (kep->width * kep->height * kep->maxpixvalue),
                    100llu * iG / (kep->width * kep->height * kep->maxpixvalue),
                    100llu * iB / (kep->width * kep->height * kep->maxpixvalue));
        printf("\tés %llu%%-os érték szerinti valamint %llu%%-os érzékelt szürke intenzitásokkal.\n",
                    100llu * (iR + iG + iB) / (3 * kep->width * kep->height * kep->maxpixvalue),
                    (30*iR + 59*iG + 11*iB) / (kep->width * kep->height * kep->maxpixvalue));
    }
    rgbpic_delete(kep);                                              /* Töröljük a képet. */
    return 0;
}

pnm-manipulate.c:

/*
 * Szegedi Tudományegyetem
 * Informatikai Tanszékcsoport
 * Szoftverfejlesztés Tanszék
 */

#include "pnm-manipulation.h"
#include "pnm-type.h"

#include <stdio.h>
#include <string.h>

typedef struct modparam {
    char                      *option;
    rgbpic_manipulation_fnc_t function;
} modparam;

modparam otable[] = {
    {"-i",   rgbpic_invert},
    {"-iR",  rgbpic_invert_R},
    {"-iG",  rgbpic_invert_G},
    {"-iB",  rgbpic_invert_B},
    {"-v",   rgbpic_mirror_v},
    {"-h",   rgbpic_mirror_h},
    {"-c",   rgbpic_mirror_c},
    {"-l",   rgbpic_rotate_l},
    {"-r",   rgbpic_rotate_r},
    {"-xRG", rgbpic_color_RG},
    {"-xGB", rgbpic_color_GB},
    {"-xBR", rgbpic_color_BR},
    {"-dR",  rgbpic_delete_R},
    {"-dG",  rgbpic_delete_G},
    {"-dB",  rgbpic_delete_B},
    {"-g",   rgbpic_convert_to_grey_lum},
    {"-gR",  rgbpic_convert_R_to_grey},
    {"-gG",  rgbpic_convert_G_to_grey},
    {"-gB",  rgbpic_convert_B_to_grey},
    {"-b",   rgbpic_convert_to_bw_lum},
    {NULL, NULL}
};

typedef int (*savf)(const char*, rgbpic_t*);
typedef struct savparam {
    char *option;
    savf function;
} savparam;

savparam stable[] = {
    {"-PBM", rgbpic_save_PBM},
    {"-PGM", rgbpic_save_PGM},
    {"-PPM", rgbpic_save_PPM},
    {NULL, NULL}
};

/*
 * A main függvény.
 */
int main(int argc, char *argv[]) {
    int argi;
    rgbpic_t *kep;                              /* A kép (illetve a képre mutató pointer) */
    if (argc < 4) {                                            /* Ha nincs elég paraméter */
        printf("Nincs eleg parameter!\n");
        printf("Használat: %s <inputfile>", argv[0]);
        if (stable->option) {
            savparam *sp = stable;
            printf(" %s", sp->option);
            while ((++sp)->option) {
                printf("|%s", sp->option);
            }
        }
        printf(" <outputfile>");
        if (otable->option) {
            modparam *mp = otable;
            printf(" [%s", mp->option);
            while ((++mp)->option) {
                printf(", %s", mp->option);
            }
        }
        printf("]\n");
        return 1;
    }
    if (!(kep = rgbpic_load(argv[1]))) {  /* Az első paramétert input képként értelmezzük */
        printf("Nem sikerult megnyitni: %s\n", argv[1]);
        return 1;
    }
    /*
     * A 4. paramétertől kezdve az elvégzendő műveletek kapcsolói
     * szerepelnek.
     */
    for (argi = 4; argi < argc; ++argi) {
        /*
         * Megkeressük, hogy a következő kapcsoló benne van-e az
         * előbb összeállított táblázatunkban.
         */
        for (modparam *p = otable; p->option; ++p) {
            /*
             * Ha megtaláltuk, a hozzá tartozó módosító
             * függvényt végrehajtjuk a képre, és nem
             * keressük tovább, hanem nézzük a következő
             * paramétert.
             */
            if (!strcmp(p->option, argv[argi])) {
                p->function(kep);
                break;
            }
        }
    }
    /*
     * A 2. paraméter a kiíratás formátumát adja meg, ezt is
     * megkeressük az előre megadott másik tömbünkben.
     */
    for (savparam *sp = stable; sp->option; ++sp) {
        if (!strcmp(sp->option, argv[2])) {
            /*
             * Ha megtaláltuk, akkor a hozzá tartozó
             * függvény segítségével elmentjük a képet a
             * megadott néven (3. paraméter).
             */
            if (sp->function(argv[3], kep)) {
                /* Ha a mentés nem sikerült, a program
                 * szövegesen is jelez és hibakóddal tér
                 * vissza.
                 */
                printf("Nem sikerult elmenteni: %s\n", argv[2]);
                rgbpic_delete(kep);
                return 1;
            }
            break;
        }
    }
    /* Töröljük a képet. */
    rgbpic_delete(kep);
    return 0;
}

Futtassuk az elkészített programokat.

make
./pnm-monolit-info ../torony-o.ppm
./pnm-monolit-manipulate ../torony-o.ppm -PPM inverted.ppm -i
make clean

Készítsünk statikus könyvtárat¶

A object fájlok közvetlen linkelése helyett először készítsünk library-t a közös fájlokból az alábbi Makefile segítségével. A programok forrásai és a Makefile egyben tömörítve innen letölthető.

A Makefile

Makefile:

info_PROG:=pnm-info
info_SRCS:=pnm-info.c
info_OBJS:=$(patsubst %.c,%.o,$(info_SRCS))
info_DEPS:=$(patsubst %.c,%.d,$(info_SRCS))

manipulate_PROG:=pnm-manipulate
manipulate_SRCS:=pnm-manipulate.c
manipulate_OBJS:=$(patsubst %.c,%.o,$(manipulate_SRCS))
manipulate_DEPS:=$(patsubst %.c,%.d,$(manipulate_SRCS))

libpnm_LIB:=libpnm.a
libpnm_SRCS:=pnm-type.c pnm-manipulation.c
libpnm_OBJS:=$(patsubst %.c,%.o,$(libpnm_SRCS))
libpnm_DEPS:=$(patsubst %.c,%.d,$(libpnm_SRCS))

CPPFLAGS:=$(CPPFLAGS)
CFLAGS:=$(CFLAGS) -Wall
info_LDFLAGS:=-L. $(LDFLAGS)
info_LDLIBS:= -lpnm $(LDLIBS)
manipulate_LDFLAGS:=-L. $(LDFLAGS)
manipulate_LDLIBS:= -lpnm $(LDLIBS)
ARFLAGS:=$(ARFLAGS)

all: $(info_PROG) $(manipulate_PROG)

$(info_OBJS) $(manipulate_OBJS) $(libpnm_OBJS): %.o: %.c
    $(CC) -c $(CPPFLAGS) $(CFLAGS) $< -o $@

$(info_DEPS) $(manipulate_DEPS) $(libpnm_DEPS): %.d: %.c
    $(CC) -MM $(CPPFLAGS) $< -MF $@

$(info_PROG): $(info_OBJS) $(libpnm_LIB)
    $(CC) $(CFLAGS) $(info_LDFLAGS) $< $(info_LDLIBS) -o $@

$(manipulate_PROG): $(manipulate_OBJS) $(libpnm_LIB)
    $(CC) $(CFLAGS) $(manipulate_LDFLAGS) $< $(manipulate_LDLIBS) -o $@

$(libpnm_LIB): $(libpnm_OBJS)
    $(AR) $(ARFLAGS) $@ $^

clean:
    rm -rf $(info_PROG) $(info_OBJS) $(info_DEPS) $(manipulate_PROG) $(manipulate_OBJS) $(manipulate_DEPS) $(libpnm_LIB) $(libpnm_OBJS) $(libpnm_DEPS)

.PHONY: all clean

include $(info_DEPS) $(manipulate_DEPS) $(libpnm_DEPS)

Látható, hogy most ahelyett, hogy a két programot közvetlenül az (egyes programokhoz szükséges) object fájlokból gyúrnánk össze, először az ar (archiver) program segítségével létrehozunk egy libpnm.a függvénykönyvtárat a közös részekből, majd a programok szerkesztésénél a -lpnm kapcsolóval azt mondjuk a linkernek, hogy ezt a függvénykönyvtárat is nézze át, amikor a függvények megvalósítását keresi.

A két program így is előáll, és szépen működik is.

make
./pnm-monolit-info ../torony-o.ppm
./pnm-monolit-manipulate ../torony-o.ppm -PPM inverted.ppm -i
make clean

Most nézzük meg, hogy mely függvények kerültek be a programokba amikor object-eket linkeltünk, és amikor a library-t használtunk.

make
make -C ../03-objects
ls -l pnm-info ../03-objects/pnm-info
nm pnm-info
nm ../03-objects/pnm-info
ls -l pnm-manipulate ../03-objects/pnm-manipulate
nm pnm-manipulate
nm ../03-objects/pnm-manipulate
make clean
make -C ../03-objects clean

Látható, hogy a library-ből a linker csak azokat az object-eket szerkesztette hozzá a programokhoz, amikre valóban szükség volt, míg ha közvetlenül az object-ekből linkeltünk, akkor minden megadott object belekerült a programokba. Ezt onnan látjuk, hogy a pnm-info esetében a képátalakító függvények hiányoznak a library-s verzióból.

Mely függvények kerülnek be a programba egy library-ből?

A linker alapvetően fordítási egységeket képes "összeragasztani", ha egy objectben sok függvény van, akkor azok egyszerre kerülnek -- vagy nem kerülnek -- bele a programba. A library pedig nem más, mint ilyen object-ek gyűjteménye.

Források kiszervezése alkönyvtárakba¶

Ahelyett, hogy az összes forrásunk egyetlen könyvtárban lenne (ami pár fájl esetén nem akkora gond, de ha már százas nagyságrendben vannak forrásfájljaink, akkor kezelhetetlen), az egyes modulokhoz tartozó forrásokat szervezzük ki alkönyvtárakba.

A kiszervezés során a gyökérben is hagyunk egy Makefile-t, de ennek csak annyi szerepe lesz, hogy minden alkönyvtárban lefuttatja a make-et parancsot a megadott target-re. Az új hierarchia és a Makefile-ok egyben tömörítve innen tölthető le.

A központi makefile

Makefile:

SUBDIRS:=libpnm pnm-info pnm-manipulate pnm-fuzz

all clean:
    @for subdir in $(SUBDIRS); do $(MAKE) -C $$subdir $@; done

.PHONY: all clean

A libpnm alkönyvtár

libpnm/Makefile:

LIB:=libpnm.a
SRCS:=pnm-type.c pnm-manipulation.c
OBJS:=$(patsubst %.c,%.o,$(SRCS))
DEPS:=$(patsubst %.c,%.d,$(SRCS))

CPPFLAGS:=$(CPPFLAGS)
CFLAGS:=$(CFLAGS) -Wall
ARFLAGS:=$(ARFLAGS)

all: $(LIB)

$(OBJS): %.o: %.c
    $(CC) -c $(CPPFLAGS) $(CFLAGS) $< -o $@

$(DEPS): %.d: %.c
    $(CC) -MM $(CPPFLAGS) $< -MF $@

$(LIB): $(OBJS)
    $(AR) $(ARFLAGS) $@ $^

clean:
    rm -rf $(LIB) $(OBJS) $(DEPS)

.PHONY: all clean

include $(DEPS)

A pnm-info alkönyvtár

pnm-info/Makefile:

PROG:=pnm-info
SRCS:=pnm-info.c
OBJS:=$(patsubst %.c,%.o,$(SRCS))
DEPS:=$(patsubst %.c,%.d,$(SRCS))

CPPFLAGS:=-I../libpnm $(CPPFLAGS)
CFLAGS:=$(CFLAGS) -Wall
LDFLAGS:=-L../libpnm $(LDFLAGS)
LDLIBS:=-lpnm $(LDLIBS)

all: $(PROG)

$(OBJS): %.o: %.c
    $(CC) -c $(CPPFLAGS) $(CFLAGS) $< -o $@

$(DEPS): %.d: %.c
    $(CC) -MM $(CPPFLAGS) $< -MF $@

$(PROG): $(OBJS)
    $(CC) $(CFLAGS) $(LDFLAGS) $< $(LDLIBS) -o $@

clean:
    rm -rf $(PROG) $(OBJS) $(DEPS)

.PHONY: all clean

include $(DEPS)

A pnm-manipulate alkönyvtár

pnm-manipulate/Makefile:

PROG:=pnm-manipulate
SRCS:=pnm-manipulate.c
OBJS:=$(patsubst %.c,%.o,$(SRCS))
DEPS:=$(patsubst %.c,%.d,$(SRCS))

CPPFLAGS:=-I../libpnm $(CPPFLAGS)
CFLAGS:=$(CFLAGS) -Wall
LDFLAGS:=-L../libpnm $(LDFLAGS)
LDLIBS:=-lpnm $(LDLIBS)

all: $(PROG)

$(OBJS): %.o: %.c
    $(CC) -c $(CPPFLAGS) $(CFLAGS) $< -o $@

$(DEPS): %.d: %.c
    $(CC) -MM $(CPPFLAGS) $< -MF $@

$(PROG): $(OBJS)
    $(CC) $(CFLAGS) $(LDFLAGS) $< $(LDLIBS) -o $@

clean:
    rm -rf $(PROG) $(OBJS) $(DEPS)

.PHONY: all clean

include $(DEPS)

Ezeken felül hozzáadtunk még egy programot, ami szintén a pnm függvénykönyvtárat használja.

A pnm-fuzz alkönyvtár

pnm-fuzz/Makefile:

PROG:=pnm-fuzz
SRCS:=pnm-fuzz.c
OBJS:=$(patsubst %.c,%.o,$(SRCS))
DEPS:=$(patsubst %.c,%.d,$(SRCS))

CPPFLAGS:=-I../libpnm $(CPPFLAGS)
CFLAGS:=$(CFLAGS) -Wall
LDFLAGS:=-L../libpnm $(LDFLAGS)
LDLIBS:=-lpnm $(LDLIBS)

all: $(PROG)

$(OBJS): %.o: %.c
    $(CC) -c $(CPPFLAGS) $(CFLAGS) $< -o $@

$(DEPS): %.d: %.c
    $(CC) -MM $(CPPFLAGS) $< -MF $@

$(PROG): $(OBJS)
    $(CC) $(CFLAGS) $(LDFLAGS) $< $(LDLIBS) -o $@

clean:
    rm -rf $(PROG) $(OBJS) $(DEPS)

.PHONY: all clean

include $(DEPS)

pnm-fuzz/pnm-fuzz.c:

/*
 * Szegedi Tudományegyetem
 * Informatikai Tanszékcsoport
 * Szoftverfejlesztés Tanszék
 */

#include "pnm-manipulation.h"
#include "pnm-type.h"

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

#define TRANSFERLUM(PIX,TF,TW,FF,FW,MAX) while (PIX->FF > TW && PIX->TF < MAX - FW) { PIX->FF -= TW; PIX->TF += FW; }

void fuzz_rg(rgbpic_pixel_t *p, rgbpic_monochrome_pixel_t m) {
    TRANSFERLUM(p,red,30,green,59,m)
}

void fuzz_rb(rgbpic_pixel_t *p, rgbpic_monochrome_pixel_t m) {
    TRANSFERLUM(p,red,30,blue,11,m)
}

void fuzz_gr(rgbpic_pixel_t *p, rgbpic_monochrome_pixel_t m) {
    TRANSFERLUM(p,green,59,red,30,m)
}

void fuzz_gb(rgbpic_pixel_t *p, rgbpic_monochrome_pixel_t m) {
    TRANSFERLUM(p,green,59,blue,11,m)
}

void fuzz_br(rgbpic_pixel_t *p, rgbpic_monochrome_pixel_t m) {
    TRANSFERLUM(p,blue,11,red,30,m)
}

void fuzz_bg(rgbpic_pixel_t *p, rgbpic_monochrome_pixel_t m) {
    TRANSFERLUM(p,blue,11,green,59,m)
}


typedef void (*fuzz_t)(rgbpic_pixel_t*, rgbpic_monochrome_pixel_t);
fuzz_t fuzz[] = {
    fuzz_rg,
    fuzz_rb,
    fuzz_gr,
    fuzz_gb,
    fuzz_br,
    fuzz_bg,
    NULL
};

/*
 * A main függvény.
 */
int main(int argc, char *argv[])
{
    rgbpic_t *kep;
    if (argc < 2) {
        printf("Nincs eleg parameter!\n");
        return 1;
    }
    if (!(kep = rgbpic_load_PPM(argv[1]))) {
        printf("Nem sikerult megnyitni: %s\n", argv[1]);
        return 1;
    }
    srand(time(0));
    int fuzz_size;
    for (fuzz_size = 0; fuzz[fuzz_size]; ++fuzz_size);
    int n = kep->width * kep->height;
    for (int iter = 1024; iter ; --iter) {
        rgbpic_picture_size_t x, y, dx, dy;
        x  = random() % kep->width;
        y  = random() % kep->height;
        dx = (kep->width / 32) + random() % (kep->width / 8);
        dy = (kep->height / 32) + random() % (kep->height / 8);
        fuzz_t f = fuzz[random() % fuzz_size];
        int idx = 0;
        for (rgbpic_picture_size_t i = y; i < y + dy && idx < n; ++i) {
            idx = rgbpic_coord(kep, x, i);
            for (rgbpic_picture_size_t j = x; j < x + dx && idx < n ; ++j, ++idx) {
                if (idx < n) {
                    f(kep->pixelvalues + idx, kep->maxpixvalue);
                }
            }
        }
    }
    if (rgbpic_save_PPM(argv[2], kep)) {
            printf("Nem sikerult elmenteni: %s\n", argv[2]);
            rgbpic_delete(kep);
            return 1;
    }
    rgbpic_delete(kep);
    return 0;
}

Fordítsunk, és próbáljuk ki az egyes programokat.

make
pushd pnm-info
./pnm-monolit-info ../../torony-o.ppm
popd
pushd pnm-monolit-manipulate
./pnm-monolit-manipulate ../../torony-o.ppm -PPM inverted.ppm -i
popd
pushd pnm-fuzz
./pnm-fuzz ../../torony-o.ppm fuzzed.ppm
popd
make clean

Teljesen statikus linkelés¶

A modern operációs rendszereken a linkelés kétféleképpen oldható meg: statikusan és dinamikusan (illetve vegyesen, mint látni fogjuk).

A statikus linkelés azt jelenti, hogy a linker a megfelelő függvényeket tartalmazó object-eket fizikailag hozzáragasztja a programhoz, így a program tulajdonképpen tartalmazza ezen függvények megvalósítását. Így amikor futtatás előtt a program kódja betöltődik a memóriába, ezek a függvények is betöltődnek, vagyis (ezek miatt legalábbis) semilyen extra dologra nincs szükség a futtatáshoz.

A dinamikus linkelés során ezzel szemben a linker nem pakolja bele a függvények kódját a programba. Csak azt az infót teszi bele, hogy melyik függvények vannak meghívva, és azok melyik (shared) object fájlban találhatók. Amikor az operációs rendszer betölti a programot a memóriába, akkor a linker által berakott információ alapján megkeresi a megfelelő (shared) object fájlokat, és azokat is ugyanúgy betölti, és a memóriában hozzáköti a programhoz. Így válik betöltés után teljessé és futtathatóvá a program.

Jó, de akkor mi a dinamikus linkelés előnye?

Egyelőre röviden: ha sokan használják ugyanazokat a függvényeket, akkor nincs mindenkinek "saját" példánya, hanem rendszer szinten osztoznak egy példányon. Ez helyfoglalás szempontjából eléggé előnyös tud lenni, és nem csak a háttértáron tárolt programok mérete, de az egész rendszer memóriafelhasználása is kedvezőbb lesz (erről később).

A modern operációs rendszerekre, és így az ezekre programot készítő linkerekre a dinamikus linkelés jellemző (bár verziózási és kompatibilitási problémák miatt van egy ezzel ellentétes tendencia is). Vagyis amit nem mi írtunk, csak felhasználtunk a programban, azt alapvetően dinamikusan teszi hozzá, a saját kódot pedig statikusan szerkeszti össze. (Vagyis valójában vegyes linkelés folyik.) A linkert viszont rá lehet venni, hogy teljesen statikusan linkeljen.

Az alábbi Makefile-ok segítségével próbáljuk ki a teljesen statikus linkelést. A teljes csomag tömörítve innen tölthető le. A központi és a libpnm Makefile-okban nincs változás.

A pnm-info alkönyvtár

pnm-info/Makefile:

PROG:=pnm-info
SRCS:=pnm-info.c
OBJS:=$(patsubst %.c,%.o,$(SRCS))
DEPS:=$(patsubst %.c,%.d,$(SRCS))

CPPFLAGS:=-I../libpnm $(CPPFLAGS)
CFLAGS:=$(CFLAGS) -Wall
LDFLAGS:= -static -L../libpnm $(LDFLAGS)
LDLIBS:=-lpnm $(LDLIBS)

all: $(PROG)

$(OBJS): %.o: %.c
    $(CC) -c $(CPPFLAGS) $(CFLAGS) $< -o $@

$(DEPS): %.d: %.c
    $(CC) -MM $(CPPFLAGS) $< -MF $@

$(PROG): $(OBJS)
    $(CC) $(CFLAGS) $(LDFLAGS) $< $(LDLIBS) -o $@

clean:
    rm -rf $(PROG) $(OBJS) $(DEPS)

.PHONY: all clean

include $(DEPS)

A pnm-manipulate alkönyvtár

pnm-manipulate/Makefile:

PROG:=pnm-manipulate
SRCS:=pnm-manipulate.c
OBJS:=$(patsubst %.c,%.o,$(SRCS))
DEPS:=$(patsubst %.c,%.d,$(SRCS))

CPPFLAGS:=-I../libpnm $(CPPFLAGS)
CFLAGS:=$(CFLAGS) -Wall
LDFLAGS:=-static -L../libpnm $(LDFLAGS)
LDLIBS:=-lpnm $(LDLIBS)

all: $(PROG)

$(OBJS): %.o: %.c
    $(CC) -c $(CPPFLAGS) $(CFLAGS) $< -o $@

$(DEPS): %.d: %.c
    $(CC) -MM $(CPPFLAGS) $< -MF $@

$(PROG): $(OBJS)
    $(CC) $(CFLAGS) $(LDFLAGS) $< $(LDLIBS) -o $@

clean:
    rm -rf $(PROG) $(OBJS) $(DEPS)

.PHONY: all clean

include $(DEPS)

A pnm-fuzz alkönyvtár

pnm-fuzz/Makefile:

PROG:=pnm-fuzz
SRCS:=pnm-fuzz.c
OBJS:=$(patsubst %.c,%.o,$(SRCS))
DEPS:=$(patsubst %.c,%.d,$(SRCS))

CPPFLAGS:=-I../libpnm $(CPPFLAGS)
CFLAGS:=$(CFLAGS) -Wall
LDFLAGS:=-static -L../libpnm $(LDFLAGS)
LDLIBS:=-lpnm $(LDLIBS)

all: $(PROG)

$(OBJS): %.o: %.c
    $(CC) -c $(CPPFLAGS) $(CFLAGS) $< -o $@

$(DEPS): %.d: %.c
    $(CC) -MM $(CPPFLAGS) $< -MF $@

$(PROG): $(OBJS)
    $(CC) $(CFLAGS) $(LDFLAGS) $< $(LDLIBS) -o $@

clean:
    rm -rf $(PROG) $(OBJS) $(DEPS)

.PHONY: all clean

include $(DEPS)

A futtatás során látunk-e különbséget a programok működésében?

make
pushd pnm-info
./pnm-monolit-info ../../torony-o.ppm
popd
pushd pnm-monolit-manipulate
./pnm-monolit-manipulate ../../torony-o.ppm -PPM inverted.ppm -i
popd
pushd pnm-fuzz
./pnm-fuzz ../../torony-o.ppm fuzzed.ppm
popd
make clean

Most akkor ellenőrizzük le, mekkorák is ezek a programok?

make
make -C ../05-static-library-subdirs
ls -l pnm-fuzz/pnm-fuzz ../05-static-library-subdirs/pnm-fuzz/pnm-fuzz
ls -l pnm-info/pnm-info ../05-static-library-subdirs/pnm-info/pnm-info
make clean
make -C ../05-static-library-subdirs clean

Látható, hogy a teljesen statikus linkelés jócskán megnöveli a program méretét, cserébe olyan rendszeren is futtatható lesz, ahol valamilyen szükséges komponens nincs előre telepítve.

Utolsó frissítés: 2023-02-01 11:01:06

Modularizáció: forráskód szervezése, függvénykönyvtárak, linkelés¶

PNM fájlok¶

Az egyik önálló, monolit program: pnm-info¶

A másik önálló, monolit program: pnm-manipulate¶

Közös részek kiszervezése¶

Készítsünk statikus könyvtárat¶

Források kiszervezése alkönyvtárakba¶

Teljesen statikus linkelés¶

Az egyik önálló, monolit program: `pnm-info`¶

A másik önálló, monolit program: `pnm-manipulate`¶