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;
}