static void processMapFile(const char * const mapFileName, struct pam * const outpamCommonP, tupletable * const colormapP, unsigned int * const colormapSizeP, tuple * const firstColorP) { /*---------------------------------------------------------------------------- Read a color map from the file named 'mapFileName'. It's a map that associates each color in that file with a unique whole number. Return the map as *colormapP, with the number of entries in it as *colormapSizeP. Also determine the first color (top left) in the map file and return that as *firstColorP. -----------------------------------------------------------------------------*/ FILE * mapfile; struct pam mappam; tuple ** maptuples; tuple firstColor; mapfile = pm_openr(mapFileName); maptuples = pnm_readpam(mapfile, &mappam, PAM_STRUCT_SIZE(tuple_type)); pm_close(mapfile); computeColorMapFromMap(&mappam, maptuples, colormapP, colormapSizeP); firstColor = pnm_allocpamtuple(&mappam); pnm_assigntuple(&mappam, firstColor, maptuples[0][0]); *firstColorP = firstColor; pnm_freepamarray(maptuples, &mappam); *outpamCommonP = mappam; outpamCommonP->file = stdout; }
static void termPatternPixel(outGenerator * const outGenP) { struct patternPixelState * const stateP = outGenP->stateP; pnm_freepamarray(stateP->patTuples, &stateP->patPam); }
int main(int argc, char *argv[]) { struct cmdlineInfo cmdline; FILE * ifP; tuple ** tuples; struct pam pam; int ncolors; tupletable chv; tuplehash cht; struct ImageHeader tgaHeader; enum TGAbaseImageType baseImgType; bool withAlpha; const char *outName; pnm_init( &argc, argv ); parseCommandLine(argc, argv, &cmdline); ifP = pm_openr(cmdline.inputFilespec); computeOutName(cmdline, &outName); tuples = pnm_readpam(ifP, &pam, PAM_STRUCT_SIZE(tuple_type)); pm_close(ifP); computeImageType_cht(&pam, cmdline, tuples, &baseImgType, &withAlpha, &chv, &cht, &ncolors); /* Do the Targa header */ computeTgaHeader(&pam, baseImgType, withAlpha, !cmdline.norle, ncolors, 0, outName, &tgaHeader); writeTgaHeader(tgaHeader); if (baseImgType == TGA_MAP_TYPE) { /* Write out the Targa colormap. */ int i; for (i = 0; i < ncolors; ++i) putMapEntry(&pam, chv[i]->tuple, tgaHeader.CoSize); } writeTgaRaster(&pam, tuples, cht, baseImgType, withAlpha, !cmdline.norle, 0); if (cht) pnm_destroytuplehash(cht); if (chv) pnm_freetupletable(&pam, chv); releaseTgaHeader(tgaHeader); strfree(outName); pnm_freepamarray(tuples, &pam); return 0; }
int main(int argc, const char ** argv) { struct cmdlineInfo cmdline; FILE * ifP; tuple ** outTuples; /* Output image */ scaler * scalerP; struct pam inpam; struct pam outpam; pm_proginit(&argc, argv); parseCommandLine(argc, argv, &cmdline); ifP = pm_openr(cmdline.inputFileName); pnm_readpaminit(ifP, &inpam, PAM_STRUCT_SIZE(allocation_depth)); pnm_setminallocationdepth(&inpam, 3); outpam.size = sizeof(outpam); outpam.len = PAM_STRUCT_SIZE(tuple_type); outpam.file = stdout; outpam.width = inpam.width; outpam.height = inpam.height; outpam.depth = 3; outpam.maxval = pm_lcm(cmdline.colorRes.c[RED]-1, cmdline.colorRes.c[GRN]-1, cmdline.colorRes.c[BLU]-1, PPM_MAXMAXVAL); outpam.bytes_per_sample = inpam.bytes_per_sample; STRSCPY(outpam.tuple_type, "RGB"); outpam.format = RPPM_FORMAT; outpam.plainformat = false; scaler_create(outpam.maxval, cmdline.colorRes, &scalerP); ditherImage(&inpam, scalerP, cmdline.dim, cmdline.colorRes, &outpam, &outTuples); pnm_writepam(&outpam, outTuples); scaler_destroy(scalerP); pnm_freepamarray(outTuples, &outpam); pm_close(ifP); return 0; }
int main(int argc, char *argv[]) { FILE * const rlefile = stdout; struct cmdlineInfo cmdline; FILE *ifP; /* Input (Netpbm) file */ struct pam pam; /* Description of the image */ tuple ** tupleArray; /* The image raster */ tupletable colormap; /* List of all of the colors used */ unsigned int numColors; /* Number of unique colors in the color map */ tuplehash colorhash; /* Mapping from color to index into colormap[] */ tuple transcolor; /* Color that should be considered transparent */ pnm_init (&argc, argv); parseCommandLine(argc, argv, &cmdline); ifP = pm_openr(cmdline.inputFilespec); tupleArray = pnm_readpam(ifP, &pam, PAM_STRUCT_SIZE(tuple_type)); transcolor = pnm_parsecolor(cmdline.transparent, pam.maxval); computeColorMap(&pam, tupleArray, &numColors, &colormap, &colorhash, cmdline.showcolormap); makeDjvurleHeader(rlefile, &pam, numColors, colormap); /* Write the raster */ { unsigned int row; for (row = 0; row < pam.height; ++row) writeDjvurleRow(rlefile, &pam, tupleArray[row], colorhash, transcolor); } /* Clean up */ pnm_freepamarray(tupleArray, &pam); pnm_freetupletable(&pam, colormap); pnm_destroytuplehash(colorhash); pnm_freepamtuple(transcolor); pm_close(ifP); return 0; }
int main(int argc, char * argv[] ) { struct cmdlineInfo cmdline; FILE * ifP; int format; struct pam colormapPam; struct pam outpam; tuple ** colormapRaster; tupletable2 colormap; pnm_init(&argc, argv); parseCommandLine(argc, argv, &cmdline); ifP = pm_openr(cmdline.inputFilespec); computeColorMapFromInput(ifP, cmdline.allcolors, cmdline.newcolors, cmdline.methodForLargest, cmdline.methodForRep, &format, &colormapPam, &colormap); pm_close(ifP); colormapToImage(format, &colormapPam, colormap, cmdline.sort, cmdline.square, &outpam, &colormapRaster); if (cmdline.verbose) pm_message("Generating %u x %u image", outpam.width, outpam.height); outpam.file = stdout; pnm_writepam(&outpam, colormapRaster); pnm_freetupletable2(&colormapPam, colormap); pnm_freepamarray(colormapRaster, &outpam); pm_close(stdout); return 0; }
int main(int argc, const char ** const argv) { struct CmdlineInfo cmdline; struct pam inpam; FILE * ifP; struct pam lookuppam; tuple ** lookup; tuplehash lookupHash; pm_proginit(&argc, argv); parseCommandLine(argc, argv, &cmdline); ifP = pm_openr(cmdline.inputFileName); pnm_readpaminit(ifP, &inpam, PAM_STRUCT_SIZE(tuple_type)); getLookup(cmdline.lookupfile, &lookup, &lookuppam); if (inpam.depth != lookuppam.depth) pm_error("The lookup image has depth %u, but the input image " "has depth %u. They must be the same", lookuppam.depth, inpam.depth); if (!streq(inpam.tuple_type, lookuppam.tuple_type)) pm_error("The lookup image has tupel type '%s', " "but the input image " "has tuple type '%s'. They must be the same", lookuppam.tuple_type, inpam.tuple_type); makeReverseLookupHash(&lookuppam, lookup, &lookupHash); doUnlookup(&inpam, lookupHash, lookuppam.width-1, stdout); pm_close(ifP); pnm_destroytuplehash(lookupHash); pnm_freepamarray(lookup, &lookuppam); return 0; }
static void wipeoutTb(FILE * const ifP, FILE * const ofP) { /* top-bottom we have to read the full image */ struct pam inpam, outpam; tuple ** tuples; tuples = pnm_readpam(ifP, &inpam, PAM_STRUCT_SIZE(tuple_type)); outpam = inpam; outpam.file = ofP; wipeImgByRow(inpam, tuples); pnm_writepam(&outpam, tuples); pnm_freepamarray(tuples, &inpam); }
static void doHilbert(FILE * const ifP, unsigned int const clumpSize) { /*---------------------------------------------------------------------------- Use hilbert space filling curve dithering -----------------------------------------------------------------------------*/ /* * This is taken from the article "Digital Halftoning with * Space Filling Curves" by Luiz Velho, proceedings of * SIGRAPH '91, page 81. * * This is not a terribly efficient or quick version of * this algorithm, but it seems to work. - Graeme Gill. * [email protected] * */ struct pam graypam; struct pam bitpam; tuple ** grays; tuple ** bits; int end; int *x,*y; int sum; grays = pnm_readpam(ifP, &graypam, PAM_STRUCT_SIZE(tuple_type)); bitpam = makeOutputPam(graypam.width, graypam.height); bits = pnm_allocpamarray(&bitpam); MALLOCARRAY(x, clumpSize); MALLOCARRAY(y, clumpSize); if (x == NULL || y == NULL) pm_error("out of memory"); initHilbert(graypam.width, graypam.height); sum = 0; end = clumpSize; while (end == clumpSize) { unsigned int i; /* compute the next cluster co-ordinates along hilbert path */ for (i = 0; i < end; i++) { if (hilbert(&x[i],&y[i])==0) end = i; /* we reached the end */ } /* sum levels */ for (i = 0; i < end; i++) sum += grays[y[i]][x[i]][0]; /* dither half and half along path */ for (i = 0; i < end; i++) { unsigned int const row = y[i]; unsigned int const col = x[i]; if (sum >= graypam.maxval) { bits[row][col][0] = 1; sum -= graypam.maxval; } else bits[row][col][0] = 0; } } pnm_writepam(&bitpam, bits); pnm_freepamarray(bits, &bitpam); pnm_freepamarray(grays, &graypam); }
int main(int argc, char **argv) { struct cmdlineInfo cmdline; FILE * ifP; tuplen ** tuplenarray; struct pam inpam; struct pam mappam; tuple ** map; int row; float * sharpness; pnm_init(&argc, argv); parseCommandLine(argc, argv, &cmdline); ifP = pm_openr(cmdline.inputFilespec); tuplenarray = pnm_readpamn(ifP, &inpam, sizeof(inpam)); mappam = inpam; mappam.file = stdout; mappam.maxval = 255; MALLOCARRAY_NOFAIL(sharpness, inpam.depth); map = pnm_allocpamarray(&mappam); makeBlackRown(&inpam, tuplenarray[0]); for (row = 1; row < inpam.height-1; ++row) { int col; makeBlackTuplen(&inpam, tuplenarray[row][0]); for (col = 1; col < inpam.width-1; ++col) { int dy; unsigned int plane; for (plane = 0; plane < inpam.depth; ++plane) sharpness[plane] = 0.0; for (dy = -1; dy <= 1; ++dy) { int dx; for (dx = -1; dx <= 1; ++dx) { if (dx != 0 || dy != 0) { unsigned int plane; for (plane = 0; plane < inpam.depth; ++plane) { samplen const sampleval = tuplenarray[row][col][plane]; samplen const sampleval2 = tuplenarray[row+dy][col+dx][plane]; sharpness[plane] += fabs(sampleval - sampleval2); } } } } makeSharpnessPixel(&mappam, sharpness, map[row][col]); } makeBlackTuplen(&inpam, tuplenarray[row][inpam.width-1]); } makeBlackRown(&inpam, tuplenarray[inpam.height-1]); free(sharpness); pnm_writepam(&mappam, map); pnm_freepamarray(map, &mappam); pnm_freepamarrayn(tuplenarray, &inpam); return 0; }