int
main(int argc, const char ** argv) {
struct cmdlineInfo cmdline;
FILE * ifP;
xel ** xels;
xel * xelrow;
xelval maxval;
int rows, cols;
int format;
unsigned int row;
pm_proginit(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
ifP = pm_openr(cmdline.inputFileName);
xels = pnm_readpnm(ifP, &cols, &rows, &maxval, &format);
pm_close(ifP);
xelrow = pnm_allocrow(cmdline.width);
pnm_writepnminit(stdout, cmdline.width, cmdline.height, maxval, format, 0);
for (row = 0; row < cmdline.height; ++row) {
unsigned int col;
for (col = 0; col < cmdline.width; ++col)
xelrow[col] = xels[row % rows][col % cols];
pnm_writepnmrow(stdout, xelrow, cmdline.width, maxval, format, 0);
}
pm_close(stdout);
return 0;
}
static void
extract_one_image(FILE *infile, const char outputfilename[]) {
FILE *outfile;
xelval maxval;
int rows, cols, format;
enum pm_check_code check_retval;
int row;
xel *xelrow;
pnm_readpnminit(infile, &cols, &rows, &maxval, &format);
pnm_check(infile, PM_CHECK_BASIC, format, cols, rows, maxval,
&check_retval);
outfile = pm_openw(outputfilename);
pnm_writepnminit(outfile, cols, rows, maxval, format, 0);
xelrow = pnm_allocrow(cols);
for (row = 0; row < rows; row++) {
pnm_readpnmrow(infile, xelrow, cols, maxval, format);
pnm_writepnmrow(outfile, xelrow, cols, maxval, format, 0);
}
pnm_freerow(xelrow);
pm_close(outfile);
}
static void
writeConvolutionImage(FILE * const cofp,
unsigned int const cols,
unsigned int const rows,
int const format) {
xelval const convmaxval = rows * cols * 2;
/* normalizing factor for our convolution matrix */
xelval const g = rows * cols + 1;
/* weight of all pixels in our convolution matrix */
int row;
xel *outputrow;
if (convmaxval > PNM_OVERALLMAXVAL)
pm_error("The convolution matrix is too large. "
"Width x Height x 2\n"
"must not exceed %d and it is %d.",
PNM_OVERALLMAXVAL, convmaxval);
pnm_writepnminit(cofp, cols, rows, convmaxval, format, 0);
outputrow = pnm_allocrow(cols);
for (row = 0; row < rows; ++row) {
unsigned int col;
for (col = 0; col < cols; ++col)
PNM_ASSIGN1(outputrow[col], g);
pnm_writepnmrow(cofp, outputrow, cols, convmaxval, format, 0);
}
pnm_freerow(outputrow);
}
static void
convertImage(FILE * const ofP,
struct cmdlineInfo const cmdline,
struct jpeg_decompress_struct * const cinfoP) {
int format;
/* The type of output file, PGM or PPM. Value is either PPM_TYPE
or PGM_TYPE, which conveniently also pass as format values
PPM_FORMAT and PGM_FORMAT.
*/
xelval maxval;
/* The maximum value of a sample (color component), both in the input
and the output.
*/
enum colorspace color_space;
/* The color space of the pixels coming out of the JPEG decompressor */
beginJpegInput(cinfoP, cmdline.verbose,
cmdline.dct_method,
cmdline.max_memory_to_use, cmdline.nosmooth);
set_color_spaces(cinfoP->jpeg_color_space, &format,
&cinfoP->out_color_space);
maxval = pm_bitstomaxval(cinfoP->data_precision);
if (cmdline.verbose)
tellDetails(*cinfoP, maxval, format);
/* Calculate output image dimensions so we can allocate space */
jpeg_calc_output_dimensions(cinfoP);
/* Start decompressor */
jpeg_start_decompress(cinfoP);
if (ofP)
/* Write pnm output header */
pnm_writepnminit(ofP, cinfoP->output_width, cinfoP->output_height,
maxval, format, FALSE);
pnmbuffer = pnm_allocrow(cinfoP->output_width);
color_space = computeColorSpace(cinfoP, cmdline.inklevel);
convertRaster(cinfoP, color_space, ofP, format, maxval);
if (cmdline.comments)
print_comments(*cinfoP);
if (cmdline.dumpexif)
dump_exif(*cinfoP);
if (cmdline.exif_filespec)
save_exif(*cinfoP, cmdline.exif_filespec);
pnm_freerow(pnmbuffer);
/* Finish decompression and release decompressor memory. */
jpeg_finish_decompress(cinfoP);
}
void
pnm_writepnm(FILE * const fileP,
xel ** const xels,
int const cols,
int const rows,
xelval const maxval,
int const format,
int const forceplain) {
unsigned int row;
pnm_writepnminit(fileP, cols, rows, maxval, format, forceplain);
for (row = 0; row < rows; ++row)
pnm_writepnmrow(fileP, xels[row], cols, maxval, format, forceplain);
}
int
main(int argc, char *argv[]) {
FILE* ifp;
xel* xelrow; /* Row from input image */
xel* output_row; /* Row of output image */
xelval maxval;
int rows, cols, format, row;
int leftcol, rightcol, toprow, bottomrow;
int output_cols; /* Width of output image */
struct cmdline_info cmdline;
pnm_init( &argc, argv );
parse_command_line(argc, argv, &cmdline);
ifp = pm_openr(cmdline.input_filespec);
pnm_readpnminit(ifp, &cols, &rows, &maxval, &format);
xelrow = pnm_allocrow(cols);
black_xel = pnm_blackxel(maxval, format);
compute_cut_bounds(cols, rows,
cmdline.left, cmdline.right,
cmdline.top, cmdline.bottom,
cmdline.width, cmdline.height,
&leftcol, &rightcol, &toprow, &bottomrow);
if (!cmdline.pad)
reject_out_of_bounds(cols, rows, leftcol, rightcol, toprow, bottomrow);
if (cmdline.verbose) {
pm_message("Image goes from Row 0, Column 0 through Row %d, Column %d",
rows-1, cols-1);
pm_message("Cutting from Row %d, Column %d through Row %d Column %d",
toprow, leftcol, bottomrow, rightcol);
}
output_cols = rightcol-leftcol+1;
output_row = pnm_allocrow(output_cols);
pnm_writepnminit(stdout, output_cols, bottomrow-toprow+1,
maxval, format, 0 );
/* Implementation note: If speed is ever an issue, we can probably
speed up significantly the non-padding case by writing a special
case loop here for the case cmdline.pad == FALSE.
*/
/* Write out top padding */
write_black_rows(stdout, 0 - toprow, output_cols, output_row,
maxval, format);
/* Read input and write out rows extracted from it */
for (row = 0; row < rows; row++) {
pnm_readpnmrow(ifp, xelrow, cols, maxval, format);
if (row >= toprow && row <= bottomrow) {
int col;
/* Put in left padding */
for (col = leftcol; col < 0; col++) {
output_row[col-leftcol] = black_xel;
}
/* Put in extracted columns */
for (col = MAX(leftcol, 0); col <= MIN(rightcol, cols-1); col++) {
output_row[col-leftcol] = xelrow[col];
}
/* Put in right padding */
for (col = MAX(cols, leftcol); col <= rightcol; col++) {
output_row[col-leftcol] = black_xel;
}
pnm_writepnmrow(stdout, output_row, output_cols,
maxval, format, 0);
}
}
/* Note that we may be tempted just to quit after reaching the bottom
of the extracted image, but that would cause a broken pipe problem
for the process that's feeding us the image.
*/
/* Write out bottom padding */
write_black_rows(stdout, bottomrow - (rows-1), output_cols, output_row,
maxval, format);
pnm_freerow(output_row);
pnm_freerow(xelrow);
pm_close(ifp);
pm_close(stdout);
exit( 0 );
}
static void
convertImage(FILE * const ofP,
struct cmdlineInfo const cmdline,
struct jpeg_decompress_struct * const cinfoP) {
int output_type;
/* The type of output file, PGM or PPM. Value is either PPM_TYPE
or PGM_TYPE, which conveniently also pass as format values
PPM_FORMAT and PGM_FORMAT.
*/
JSAMPROW jpegbuffer; /* Input buffer. Filled by jpeg_scanlines() */
unsigned int maxval;
/* The maximum value of a sample (color component), both in the input
and the output.
*/
enum colorspace color_space;
/* The color space of the pixels coming out of the JPEG decompressor */
beginJpegInput(cinfoP, cmdline.verbose,
cmdline.dct_method,
cmdline.max_memory_to_use, cmdline.nosmooth);
set_color_spaces(cinfoP->jpeg_color_space, &output_type,
&cinfoP->out_color_space);
maxval = (1 << cinfoP->data_precision) - 1;
if (cmdline.verbose)
tellDetails(*cinfoP, maxval, output_type);
/* Calculate output image dimensions so we can allocate space */
jpeg_calc_output_dimensions(cinfoP);
overflow2(cinfoP->output_width, cinfoP->output_components);
jpegbuffer = ((*cinfoP->mem->alloc_sarray)
((j_common_ptr) cinfoP, JPOOL_IMAGE,
cinfoP->output_width * cinfoP->output_components,
(JDIMENSION) 1)
)[0];
/* Start decompressor */
jpeg_start_decompress(cinfoP);
if (ofP)
/* Write pnm output header */
pnm_writepnminit(ofP, cinfoP->output_width, cinfoP->output_height,
maxval, output_type, FALSE);
pnmbuffer = pnm_allocrow(cinfoP->output_width);
color_space = computeColorSpace(cinfoP, cmdline.inklevel);
/* Process data */
while (cinfoP->output_scanline < cinfoP->output_height) {
jpeg_read_scanlines(cinfoP, &jpegbuffer, 1);
if (ofP)
copy_pixel_row(jpegbuffer, cinfoP->output_width,
cinfoP->out_color_components,
color_space, maxval, ofP, output_type);
}
if (cmdline.comments)
print_comments(*cinfoP);
if (cmdline.dumpexif)
dump_exif(*cinfoP);
if (cmdline.exif_filespec)
save_exif(*cinfoP, cmdline.exif_filespec);
pnm_freerow(pnmbuffer);
/* Finish decompression and release decompressor memory. */
jpeg_finish_decompress(cinfoP);
}
int
main(int argc, char * argv[]) {
FILE* ifp;
xel* xelrow;
xel* newxelrow;
xel bgxel;
int rows, cols, format;
int newformat, newcols;
int row;
xelval maxval, newmaxval;
double shearfac;
struct cmdline_info cmdline;
pnm_init( &argc, argv );
parse_command_line( argc, argv, &cmdline );
ifp = pm_openr( cmdline.input_filespec );
pnm_readpnminit( ifp, &cols, &rows, &maxval, &format );
xelrow = pnm_allocrow( cols );
/* Promote PBM files to PGM. */
if ( !cmdline.noantialias && PNM_FORMAT_TYPE(format) == PBM_TYPE ) {
newformat = PGM_TYPE;
newmaxval = PGM_MAXMAXVAL;
pm_message( "promoting from PBM to PGM - "
"use -noantialias to avoid this" );
} else {
newformat = format;
newmaxval = maxval;
}
shearfac = tan( cmdline.angle );
if ( shearfac < 0.0 )
shearfac = -shearfac;
if(rows * shearfac >= INT_MAX-1)
pm_error("image too large");
overflow_add(rows * shearfac, cols+1);
newcols = rows * shearfac + cols + 0.999999;
pnm_writepnminit( stdout, newcols, rows, newmaxval, newformat, 0 );
newxelrow = pnm_allocrow( newcols );
bgxel = pnm_backgroundxelrow( xelrow, cols, newmaxval, format );
for ( row = 0; row < rows; ++row ) {
double shearCols;
pnm_readpnmrow( ifp, xelrow, cols, newmaxval, format );
if ( cmdline.angle > 0.0 )
shearCols = row * shearfac;
else
shearCols = ( rows - row ) * shearfac;
shear_row(xelrow, cols, newxelrow, newcols,
shearCols, format, bgxel, !cmdline.noantialias);
pnm_writepnmrow( stdout, newxelrow, newcols, newmaxval, newformat, 0 );
}
pm_close( ifp );
pm_close( stdout );
exit( 0 );
}
static void
writeCroppedNonPbm(FILE * const ifP,
unsigned int const cols,
unsigned int const rows,
xelval const maxval,
int const format,
cropSet const crop,
xel const backgroundColor,
FILE * const ofP) {
/* In order to do cropping, padding or both at the same time, we have
a rather complicated row buffer:
xelrow[] is both the input and the output buffer. So it contains
the foreground pixels, the original border pixels, and the new
border pixels.
We're calling foreground everything that isn't being cropped out
or padded in. So the "foreground" may include some of what is really
a background border in the original image -- because the user can
choose to retain part of that border as a margin.
The foreground pixels are in the center of the
buffer, starting at Column 'foregroundLeft' and going to
'foregroundRight'.
There is space to the left of that for the larger of the input
left border and the output left border.
Similarly, there is space to the right of the foreground pixels
for the larger of the input right border and the output right
border.
We have to read an entire row, including the pixels we'll be
leaving out of the output, so we pick a starting location in
the buffer that lines up the first foreground pixel at
'foregroundLeft'.
When we output the row, we pick a starting location in the
buffer that includes the proper number of left border pixels
before 'foregroundLeft'.
That's for the middle rows. For the top and bottom, we just use
the left portion of xelrow[], starting at 0.
This is the general case. Enhancement for PBM appears below.
(Logic works for PBM).
*/
unsigned int const foregroundCols =
cols - crop.op[LEFT].removeSize - crop.op[RIGHT].removeSize;
unsigned int const outputCols =
foregroundCols + crop.op[LEFT].padSize + crop.op[RIGHT].padSize;
unsigned int const foregroundRows =
rows - crop.op[TOP].removeSize - crop.op[BOTTOM].removeSize;
unsigned int const outputRows =
foregroundRows + crop.op[TOP].padSize + crop.op[BOTTOM].padSize;
unsigned int const foregroundLeft =
MAX(crop.op[LEFT].removeSize, crop.op[LEFT].padSize);
/* Index into xelrow[] of leftmost pixel of foreground */
unsigned int const foregroundRight = foregroundLeft + foregroundCols;
/* Index into xelrow[] just past rightmost pixel of foreground */
unsigned int const allocCols =
foregroundRight + MAX(crop.op[RIGHT].removeSize,
crop.op[RIGHT].padSize);
xel * xelrow;
unsigned int i;
pnm_writepnminit(ofP, outputCols, outputRows, maxval, format, 0);
xelrow = pnm_allocrow(allocCols);
readOffBorderNonPbm(crop.op[TOP].removeSize, ifP, cols, maxval, format);
outputNewBorderNonPbm(crop.op[TOP].padSize, outputCols, backgroundColor,
ofP, maxval, format);
/* Set left border pixels */
fillRow(&xelrow[foregroundLeft - crop.op[LEFT].padSize],
crop.op[LEFT].padSize,
backgroundColor);
/* Set right border pixels */
fillRow(&xelrow[foregroundRight], crop.op[RIGHT].padSize, backgroundColor);
/* Read and output foreground rows */
for (i = 0; i < foregroundRows; ++i) {
/* Read foreground pixels */
pnm_readpnmrow(ifP,
&(xelrow[foregroundLeft - crop.op[LEFT].removeSize]),
cols, maxval, format);
pnm_writepnmrow(ofP,
&(xelrow[foregroundLeft - crop.op[LEFT].padSize]),
outputCols, maxval, format, 0);
}
readOffBorderNonPbm(crop.op[BOTTOM].removeSize, ifP, cols, maxval, format);
outputNewBorderNonPbm(crop.op[BOTTOM].padSize, outputCols,
backgroundColor,
ofP, maxval, format);
pnm_freerow(xelrow);
}
int
main(int argc,
const char ** argv) {
struct cmdlineInfo cmdline;
struct imgInfo * img; /* malloc'ed array */
xelval newmaxval;
int newformat;
unsigned int i;
unsigned int newrows, newcols;
pm_proginit(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
MALLOCARRAY_NOFAIL(img, cmdline.nfiles);
for (i = 0; i < cmdline.nfiles; ++i) {
img[i].ifP = pm_openr(cmdline.inputFilespec[i]);
pnm_readpnminit(img[i].ifP, &img[i].cols, &img[i].rows,
&img[i].maxval, &img[i].format);
}
computeOutputParms(cmdline.nfiles, cmdline.orientation, img,
&newcols, &newrows, &newmaxval, &newformat);
pnm_writepnminit(stdout, newcols, newrows, newmaxval, newformat, 0);
if (PNM_FORMAT_TYPE(newformat) == PBM_TYPE) {
switch (cmdline.orientation) {
case LEFTRIGHT:
concatenateLeftRightPbm(stdout, cmdline.nfiles,
newcols, newrows, cmdline.justification,
img, cmdline.backcolor);
break;
case TOPBOTTOM:
concatenateTopBottomPbm(stdout, cmdline.nfiles,
newcols, newrows, cmdline.justification,
img, cmdline.backcolor);
break;
}
} else {
switch (cmdline.orientation) {
case LEFTRIGHT:
concatenateLeftRightGen(stdout, cmdline.nfiles,
newcols, newrows, newmaxval, newformat,
cmdline.justification, img,
cmdline.backcolor);
break;
case TOPBOTTOM:
concatenateTopBottomGen(stdout, cmdline.nfiles,
newcols, newrows, newmaxval, newformat,
cmdline.justification, img,
cmdline.backcolor);
break;
}
}
for (i = 0; i < cmdline.nfiles; ++i)
pm_close(img[i].ifP);
free(cmdline.inputFilespec);
free(img);
pm_close(stdout);
return 0;
}
int
main(int argc, const char * argv[]) {
FILE * ifP;
xel * xelrow;
xel * newxelrow;
xel bgxel;
int rows, cols, format;
int newformat, newcols;
int row;
xelval maxval, newmaxval;
double shearfac;
struct CmdlineInfo cmdline;
pm_proginit(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
ifP = pm_openr(cmdline.inputFileName);
pnm_readpnminit(ifP, &cols, &rows, &maxval, &format);
xelrow = pnm_allocrow(cols);
/* Promote PBM files to PGM. */
if (!cmdline.noantialias && PNM_FORMAT_TYPE(format) == PBM_TYPE) {
newformat = PGM_TYPE;
newmaxval = PGM_MAXMAXVAL;
pm_message("promoting from PBM to PGM - "
"use -noantialias to avoid this");
} else {
newformat = format;
newmaxval = maxval;
}
shearfac = fabs(tan(cmdline.angle));
newcols = rows * shearfac + cols + 0.999999;
pnm_writepnminit(stdout, newcols, rows, newmaxval, newformat, 0);
newxelrow = pnm_allocrow(newcols);
for (row = 0; row < rows; ++row) {
double shearCols;
pnm_readpnmrow(ifP, xelrow, cols, newmaxval, format);
if (row == 0)
bgxel = backgroundColor(cmdline.background,
xelrow, cols, newmaxval, format);
if (cmdline.angle > 0.0)
shearCols = row * shearfac;
else
shearCols = (rows - row) * shearfac;
shearRow(xelrow, cols, newxelrow, newcols,
shearCols, format, bgxel, !cmdline.noantialias);
pnm_writepnmrow(stdout, newxelrow, newcols, newmaxval, newformat, 0);
}
pm_close(ifP);
pm_close(stdout);
return 0;
}
