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