static void
writepbmrow(FILE * const fileP,
const xel * const xelrow,
unsigned int const cols,
bool const plainFormat) {
jmp_buf jmpbuf;
jmp_buf * origJmpbufP;
bit * bitrow;
bitrow = pbm_allocrow(cols);
if (setjmp(jmpbuf) != 0) {
pbm_freerow(bitrow);
pm_setjmpbuf(origJmpbufP);
pm_longjmp();
} else {
unsigned int col;
pm_setjmpbufsave(&jmpbuf, &origJmpbufP);
for (col = 0; col < cols; ++col)
bitrow[col] = PNM_GET1(xelrow[col]) == 0 ? PBM_BLACK : PBM_WHITE;
pbm_writepbmrow(fileP, bitrow, cols, plainFormat);
pm_setjmpbuf(origJmpbufP);
}
pbm_freerow(bitrow);
}
static void
writeOutput(FILE * const imageout_file,
FILE * const alpha_file,
int const cols, int const rows,
pixel * const colors, int * const data,
int transparent) {
/*----------------------------------------------------------------------------
Write the image in 'data' to open PPM file stream 'imageout_file',
and the alpha mask for it to open PBM file stream 'alpha_file',
except if either is NULL, skip it.
'data' is an array of cols * rows integers, each one being an index
into the colormap 'colors'.
Where the index 'transparent' occurs in 'data', the pixel is supposed
to be transparent. If 'transparent' < 0, no pixels are transparent.
-----------------------------------------------------------------------------*/
int row;
pixel *pixrow;
bit * alpharow;
if (imageout_file)
ppm_writeppminit(imageout_file, cols, rows, PPM_MAXMAXVAL, 0);
if (alpha_file)
pbm_writepbminit(alpha_file, cols, rows, 0);
pixrow = ppm_allocrow(cols);
alpharow = pbm_allocrow(cols);
for (row = 0; row < rows; ++row ) {
int col;
int * const datarow = data+(row*cols);
for (col = 0; col < cols; ++col) {
pixrow[col] = colors[datarow[col]];
if (datarow[col] == transparent)
alpharow[col] = PBM_BLACK;
else
alpharow[col] = PBM_WHITE;
}
if (imageout_file)
ppm_writeppmrow(imageout_file,
pixrow, cols, (pixval) PPM_MAXMAXVAL, 0);
if (alpha_file)
pbm_writepbmrow(alpha_file, alpharow, cols, 0);
}
ppm_freerow(pixrow);
pbm_freerow(alpharow);
if (imageout_file)
pm_close(imageout_file);
if (alpha_file)
pm_close(alpha_file);
}
void
pnm_writepnmrow(FILE * const fileP,
xel * const xelrow,
int const cols,
xelval const maxval,
int const format,
int const forceplain) {
bool const plainFormat = forceplain || pm_plain_output;
switch (PNM_FORMAT_TYPE(format)) {
case PPM_TYPE:
ppm_writeppmrow(fileP, (pixel*) xelrow, cols, (pixval) maxval,
plainFormat);
break;
case PGM_TYPE: {
gray* grayrow;
unsigned int col;
grayrow = pgm_allocrow(cols);
for (col = 0; col < cols; ++col)
grayrow[col] = PNM_GET1(xelrow[col]);
pgm_writepgmrow(fileP, grayrow, cols, (gray) maxval, plainFormat);
pgm_freerow( grayrow );
}
break;
case PBM_TYPE: {
bit* bitrow;
unsigned int col;
bitrow = pbm_allocrow(cols);
for (col = 0; col < cols; ++col)
bitrow[col] = PNM_GET1(xelrow[col]) == 0 ? PBM_BLACK : PBM_WHITE;
pbm_writepbmrow(fileP, bitrow, cols, plainFormat);
pbm_freerow(bitrow);
}
break;
default:
pm_error("invalid format argument received by pnm_writepnmrow(): %d"
"PNM_FORMAT_TYPE(format) must be %d, %d, or %d",
format, PBM_TYPE, PGM_TYPE, PPM_TYPE);
}
}
int
main(int argc, char *argv[]) {
struct cmdlineInfo cmdline;
FILE * ifP;
/* Parameters of input image: */
int rows, cols;
pixval maxval;
int format;
ppm_init(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
ifP = pm_openr(cmdline.inputFilename);
ppm_readppminit(ifP, &cols, &rows, &maxval, &format);
pbm_writepbminit(stdout, cols, rows, 0);
{
pixel * const inputRow = ppm_allocrow(cols);
bit * const maskRow = pbm_allocrow(cols);
unsigned int numPixelsMasked;
unsigned int row;
for (row = 0, numPixelsMasked = 0; row < rows; ++row) {
int col;
ppm_readppmrow(ifP, inputRow, cols, maxval, format);
for (col = 0; col < cols; ++col) {
if (colorIsInSet(inputRow[col], maxval, cmdline)) {
maskRow[col] = PBM_BLACK;
++numPixelsMasked;
} else
maskRow[col] = PBM_WHITE;
}
pbm_writepbmrow(stdout, maskRow, cols, 0);
}
if (cmdline.verbose)
pm_message("%u pixels found matching %u requested colors",
numPixelsMasked, cmdline.colorCount);
pbm_freerow(maskRow);
ppm_freerow(inputRow);
}
pm_close(ifP);
return 0;
}
int
main(int argc, char **argv) {
FILE *ifp;
register bit *bitrow, *bP;
int rows, cols, row, col, charcount;
unsigned char *data, mask;
pbm_init ( &argc, argv );
if ( argc > 2 )
pm_usage( "[raster obj]" );
if ( argc == 2 )
ifp = pm_openr( argv[1] );
else
ifp = stdin;
ReadATKRaster( ifp, &cols, &rows, &data );
pm_close( ifp );
pbm_writepbminit( stdout, cols, rows, 0 );
bitrow = pbm_allocrow( cols );
for ( row = 0; row < rows; ++row )
{
charcount = 0;
mask = 0x80;
for ( col = 0, bP = bitrow; col < cols; ++col, ++bP )
{
if ( charcount >= 8 )
{
++data;
charcount = 0;
mask = 0x80;
}
*bP = ( *data & mask ) ? PBM_BLACK : PBM_WHITE;
++charcount;
mask >>= 1;
}
++data;
pbm_writepbmrow( stdout, bitrow, cols, 0 );
}
pm_close( stdout );
exit( 0 );
}
int main(int argc, char** argv) {
int row;
int cols;
int rows;
int format;
bit *imageRow;
pm_init(argv[0], 0);
pbm_readpbminit(stdin, &cols, &rows, &format);
pbm_writepbminit(stdout, cols, rows, 1);
imageRow = pbm_allocrow(cols);
for (row = 0; row < rows; row++) {
if (row > 0) usleep(500000);
pbm_readpbmrow(stdin, imageRow, cols, format);
pbm_writepbmrow(stdout, imageRow, cols, 1);
fflush(stdout);
}
pgm_freerow(imageRow);
return 0;
}
