static void
computeOutputParms(unsigned int const nfiles,
enum orientation const orientation,
struct imgInfo const img[],
unsigned int * const newcolsP,
unsigned int * const newrowsP,
xelval * const newmaxvalP,
int * const newformatP) {
double newcols, newrows;
int newformat;
xelval newmaxval;
unsigned int i;
newcols = 0;
newrows = 0;
for (i = 0; i < nfiles; ++i) {
const struct imgInfo * const imgP = &img[i];
if (i == 0) {
newmaxval = imgP->maxval;
newformat = imgP->format;
} else {
if (PNM_FORMAT_TYPE(imgP->format) > PNM_FORMAT_TYPE(newformat))
newformat = imgP->format;
if (imgP->maxval > newmaxval)
newmaxval = imgP->maxval;
}
switch (orientation) {
case LEFTRIGHT:
newcols += imgP->cols;
if (imgP->rows > newrows)
newrows = imgP->rows;
break;
case TOPBOTTOM:
newrows += imgP->rows;
if (imgP->cols > newcols)
newcols = imgP->cols;
break;
}
}
/* Note that while 'double' is not in general a precise numerical type,
in the case of a sum of integers which is less than INT_MAX, it
is exact, because double's precision is greater than int's.
*/
if (newcols > INT_MAX)
pm_error("Output width too large: %.0f.", newcols);
if (newrows > INT_MAX)
pm_error("Output height too large: %.0f.", newrows);
*newrowsP = (unsigned int)newrows;
*newcolsP = (unsigned int)newcols;
*newmaxvalP = newmaxval;
*newformatP = newformat;
}
static void
makeNewXel(xel * const outputXelP, xel const curXel, xel const prevXel,
double const fracnew0, double const omfracnew0, int const format) {
/*----------------------------------------------------------------------------
Create an output xel as *outputXel, which is part curXel and part
prevXel, the part given by the fractions omfracnew0 and fracnew0,
respectively. These fraction values are the numerator of a fraction
whose denominator is SCALE.
The format of the pixel is 'format'.
-----------------------------------------------------------------------------*/
switch ( PNM_FORMAT_TYPE(format) ) {
case PPM_TYPE:
PPM_ASSIGN( *outputXelP,
( fracnew0 * PPM_GETR(prevXel)
+ omfracnew0 * PPM_GETR(curXel)
+ HALFSCALE ) / SCALE,
( fracnew0 * PPM_GETG(prevXel)
+ omfracnew0 * PPM_GETG(curXel)
+ HALFSCALE ) / SCALE,
( fracnew0 * PPM_GETB(prevXel)
+ omfracnew0 * PPM_GETB(curXel)
+ HALFSCALE ) / SCALE );
break;
default:
PNM_ASSIGN1( *outputXelP,
( fracnew0 * PNM_GET1(prevXel)
+ omfracnew0 * PNM_GET1(curXel)
+ HALFSCALE ) / SCALE );
break;
}
}
static void
cropOneImage(struct cmdlineInfo const cmdline,
FILE * const ifP,
FILE * const bdfP,
FILE * const ofP) {
/*----------------------------------------------------------------------------
Crop the image to which the stream *ifP is presently positioned
and write the results to *ofP. If bdfP is non-null, use the image
to which stream *bdfP is presently positioned as the borderfile
(the file that tells us where the existing borders are in the input
image). Leave *ifP and *bdfP positioned after the image.
Both files are seekable.
-----------------------------------------------------------------------------*/
xelval maxval, bmaxval;
int format, bformat;
int rows, cols, brows, bcols;
bool hasBorders;
borderSet oldBorder;
/* The sizes of the borders in the input image */
cropSet crop;
/* The crops we have to do on each side */
xel background;
pnm_readpnminit(ifP, &cols, &rows, &maxval, &format);
if (bdfP)
pnm_readpnminit(bdfP, &bcols, &brows, &bmaxval, &bformat);
if (bdfP)
analyzeImage(bdfP, bcols, brows, bmaxval, bformat, cmdline.background,
FILEPOS_END,
&background, &hasBorders, &oldBorder);
else
analyzeImage(ifP, cols, rows, maxval, format, cmdline.background,
FILEPOS_BEG,
&background, &hasBorders, &oldBorder);
if (cmdline.verbose) {
pixel const backgroundPixel = pnm_xeltopixel(background, format);
pm_message("Background color is %s",
ppm_colorname(&backgroundPixel, maxval, TRUE /*hexok*/));
}
if (!hasBorders)
pm_error("The image is entirely background; "
"there is nothing to crop.");
determineCrops(cmdline, &oldBorder, &crop);
validateComputableSize(cols, rows, crop);
if (cmdline.verbose)
reportCroppingParameters(crop);
if (PNM_FORMAT_TYPE(format) == PBM_TYPE)
writeCroppedPBM(ifP, cols, rows, format, crop, background, ofP);
else
writeCroppedNonPbm(ifP, cols, rows, maxval, format, crop,
background, ofP);
}
void
pnm_writepnminit(FILE * const fileP,
int const cols,
int const rows,
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_writeppminit(fileP, cols, rows, (pixval) maxval, plainFormat);
break;
case PGM_TYPE:
pgm_writepgminit(fileP, cols, rows, (gray) maxval, plainFormat);
break;
case PBM_TYPE:
pbm_writepbminit(fileP, cols, rows, plainFormat);
break;
default:
pm_error("invalid format argument received by pnm_writepnminit(): %d"
"PNM_FORMAT_TYPE(format) must be %d, %d, or %d",
format, PBM_TYPE, PGM_TYPE, PPM_TYPE);
}
}
int
main(int argc, const char ** argv) {
struct cmdlineInfo cmdline;
FILE * ifP;
int cols, rows;
xelval maxval;
int format;
unsigned int histWidth;
unsigned int range;
unsigned int hmax;
xelval startval, endval;
pm_proginit(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
ifP = pm_openr(cmdline.inputFilespec);
pnm_readpnminit(ifP, &cols, &rows, &maxval, &format);
startval = cmdline.lval;
endval = MIN(maxval, cmdline.rval) + 1;
range = endval - startval;
if (cmdline.widthSpec)
histWidth = cmdline.width;
else
histWidth = range;
reportScale(histWidth, range, cmdline.verbose);
if (cmdline.nmaxSpec)
hmax = cols * rows / histWidth * cmdline.nmax;
switch (PNM_FORMAT_TYPE(format)) {
case PPM_TYPE:
ppmHist(ifP, cols, rows, maxval, format,
cmdline.dots, cmdline.white, cmdline.black,
cmdline.colorWanted,
cmdline.verbose, startval, endval,
histWidth, cmdline.height, cmdline.nmaxSpec, hmax);
break;
case PGM_TYPE:
pgmHist(ifP, cols, rows, maxval, format,
cmdline.dots, cmdline.white, cmdline.black,
cmdline.verbose, startval, endval,
histWidth, cmdline.height, cmdline.nmaxSpec, hmax);
break;
case PBM_TYPE:
pm_error("Cannot do a histogram of a a PBM file");
break;
}
pm_close(ifP);
return 0;
}
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);
}
}
static void
remap(xel ** const xels,
unsigned int const cols,
unsigned int const rows,
xelval const maxval,
int const format,
bool const monoOnly,
const gray * const lumamap) {
/*----------------------------------------------------------------------------
Update the array 'xels' to have the new intensities.
-----------------------------------------------------------------------------*/
switch (PNM_FORMAT_TYPE(format)) {
case PPM_TYPE: {
unsigned int row;
for (row = 0; row < rows; ++row) {
unsigned int col;
for (col = 0; col < cols; ++col) {
xel const thisXel = xels[row][col];
if (monoOnly && PPM_ISGRAY(thisXel)) {
/* Leave this pixel alone */
} else {
struct hsv hsv;
xelval iv;
hsv = ppm_hsv_from_color(thisXel, maxval);
iv = MIN(maxval, ROUNDU(hsv.v * maxval));
hsv.v = MIN(1.0,
((double) lumamap[iv]) / ((double) maxval));
xels[row][col] = ppm_color_from_hsv(hsv, maxval);
}
}
}
}
break;
case PBM_TYPE:
case PGM_TYPE: {
unsigned int row;
for (row = 0; row < rows; ++row) {
unsigned int col;
for (col = 0; col < cols; ++col)
PNM_ASSIGN1(xels[row][col],
lumamap[PNM_GET1(xels[row][col])]);
}
}
break;
}
}
static void
cutOneImage(FILE * const ifP,
struct cmdlineInfo const cmdline,
FILE * const ofP) {
int leftcol, rightcol, toprow, bottomrow;
struct pam inpam; /* Input PAM image */
struct pam outpam; /* Output PAM image */
pnm_readpaminit(ifP, &inpam, PAM_STRUCT_SIZE(tuple_type));
computeCutBounds(inpam.width, inpam.height,
cmdline.left, cmdline.right,
cmdline.top, cmdline.bottom,
cmdline.width, cmdline.height,
&leftcol, &rightcol, &toprow, &bottomrow);
rejectOutOfBounds(inpam.width, inpam.height, leftcol, rightcol,
toprow, bottomrow, cmdline.pad);
if (cmdline.verbose) {
pm_message("Image goes from Row 0, Column 0 through Row %u, Column %u",
inpam.height-1, inpam.width-1);
pm_message("Cutting from Row %d, Column %d through Row %d Column %d",
toprow, leftcol, bottomrow, rightcol);
}
outpam = inpam; /* Initial value -- most fields should be same */
outpam.file = ofP;
outpam.width = rightcol - leftcol + 1;
outpam.height = bottomrow - toprow + 1;
pnm_writepaminit(&outpam);
if (PNM_FORMAT_TYPE(outpam.format) == PBM_TYPE)
extractRowsPBM(&inpam, &outpam, leftcol, rightcol, toprow, bottomrow);
else
extractRowsGen(&inpam, &outpam, leftcol, rightcol, toprow, bottomrow);
}
static void
convertRaster(FILE * const ifP,
int const format,
xelval const maxval,
unsigned int const cols,
unsigned int const rows,
FILE * const ofP,
unsigned int const bytesPerLine) {
unsigned char * data;
unsigned char * p;
MALLOCARRAY(data, bytesPerLine);
if (data == NULL)
pm_error("Couldn't allocate %u-byte line buffer", bytesPerLine);
p = data; /* initial value */
switch (PNM_FORMAT_TYPE(format)) {
case PBM_TYPE:
convertPbmRaster(ifP, format, cols, rows, ofP, bytesPerLine, data);
break;
case PGM_TYPE:
convertPgmRaster(ifP, format, maxval, cols, rows, ofP, bytesPerLine,
data);
break;
case PPM_TYPE:
convertPpmRaster(ifP, format, maxval, cols, rows, ofP, bytesPerLine,
data);
break;
default:
pm_error("INTERNAL ERROR: impossible format value");
}
free(data);
}
static void convert_image(const char *filename, const char *name)
{
FILE *fp;
xel **pnm;
xelval maxval;
int cols, rows, fmt, clut_len = 0, size;
const char *type;
// Load the image
if (!strcmp(filename, "-"))
fp = stdin;
else {
fp = fopen(filename, "r");
if (!fp) {
fprintf(stderr, "Cannot open file %s: %s\n", filename,
strerror(errno));
exit(1);
}
}
pnm = pnm_readpnm(fp, &cols, &rows, &maxval, &fmt);
if (!pnm) {
fprintf(stderr, "Error reading PNM file: %s\n", strerror(errno));
exit(1);
}
switch (PNM_FORMAT_TYPE(fmt)) {
case PPM_TYPE:
normalize_ppm(pnm, cols, rows, maxval);
clut_len = fill_clut(pnm, cols, rows);
if (clut_len > 0 && clut_len <= 256) {
type = "CLUT256";
size = cols*rows;
} else {
type = "RGB888";
size = cols*rows*3;
}
break;
case PGM_TYPE:
type = "GREY256";
size = cols*rows;
break;
case PBM_TYPE:
type = "BW";
size = (cols+7)/8*rows;
break;
default:
fprintf(stderr, "Unknown PNM format %d\n", PNM_FORMAT_TYPE(fmt));
exit(1);
}
// Print header
printf(" /*\n");
printf(" * Image %s\n", name);
printf(" */\n\n");
printf("#include \"image.h\"\n\n");
// Print forward declarations
printf("static const unsigned char %s_data[];\n", name);
if (clut_len > 0 && clut_len <= 256)
printf("static const unsigned char %s_clut[];\n", name);
printf("\n");
// Print image structure
printf("const struct image %s = {\n", name);
printf(" width:\t%d,\n", cols);
printf(" height:\t%d,\n", rows);
printf(" type:\tIMAGE_%s,\n", type);
printf(" data:\t%s_data,\n", name);
if (clut_len > 0 && clut_len <= 256) {
printf(" clut_len:\t%d,\n", clut_len);
printf(" clut:\t%s_clut\n", name);
}
printf("};\n\n");
// Print image data
printf("static const unsigned char %s_data[%d] = {\n", name, size);
switch (PNM_FORMAT_TYPE(fmt)) {
case PPM_TYPE:
if (clut_len > 0 && clut_len <= 256)
print_clut256_data(pnm, cols, rows, clut_len);
else
print_rgb888_data(pnm, cols, rows);
break;
case PGM_TYPE:
print_grey256_data(pnm, cols, rows, maxval);
break;
case PBM_TYPE:
print_bw_data(pnm, cols, rows);
break;
}
printf("};\n\n");
// Print image clut
if (clut_len > 0 && clut_len <= 256) {
printf("static const unsigned char %s_clut[%d] = {\n", name,
clut_len*3);
print_image_clut(clut_len);
printf("};\n\n");
}
// Free temporary data
ppm_freearray(pnm, rows);
}
static void
computeLuminosityHistogram(xel * const * const xels,
unsigned int const rows,
unsigned int const cols,
xelval const maxval,
int const format,
bool const monoOnly,
unsigned int ** const lumahistP,
xelval * const lminP,
xelval * const lmaxP,
unsigned int * const pixelCountP) {
/*----------------------------------------------------------------------------
Scan the image and build the luminosity histogram. If the input is
a PPM, we calculate the luminosity of each pixel from its RGB
components.
-----------------------------------------------------------------------------*/
xelval lmin, lmax;
unsigned int pixelCount;
unsigned int * lumahist;
MALLOCARRAY(lumahist, maxval + 1);
if (lumahist == NULL)
pm_error("Out of storage allocating array for %u histogram elements",
maxval + 1);
{
unsigned int i;
/* Initialize histogram to zeroes everywhere */
for (i = 0; i <= maxval; ++i)
lumahist[i] = 0;
}
lmin = maxval; /* initial value */
lmax = 0; /* initial value */
switch (PNM_FORMAT_TYPE(format)) {
case PGM_TYPE:
case PBM_TYPE: {
/* Compute intensity histogram */
unsigned int row;
pixelCount = rows * cols;
for (row = 0; row < rows; ++row) {
unsigned int col;
for (col = 0; col < cols; ++col) {
xelval const l = PNM_GET1(xels[row][col]);
lmin = MIN(lmin, l);
lmax = MAX(lmax, l);
++lumahist[l];
}
}
}
break;
case PPM_TYPE: {
unsigned int row;
for (row = 0, pixelCount = 0; row < rows; ++row) {
unsigned int col;
for (col = 0; col < cols; ++col) {
xel const thisXel = xels[row][col];
if (!monoOnly || PPM_ISGRAY(thisXel)) {
xelval const l = PPM_LUMIN(thisXel);
lmin = MIN(lmin, l);
lmax = MAX(lmax, l);
++lumahist[l];
++pixelCount;
}
}
}
}
break;
default:
pm_error("invalid input format format");
}
*lumahistP = lumahist;
*pixelCountP = pixelCount;
*lminP = lmin;
*lmaxP = lmax;
}
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 );
}
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, char *argv[])
{
FILE *ifd;
FILE *ofd;
int rows, cols;
xelval maxval;
int format;
const char * const usage = "[-resolution x y] [pnmfile [ddiffile]]";
int i, j;
char *outfile;
int argn;
int hor_resolution = 75;
int ver_resolution = 75;
imageparams ip;
unsigned char *data, *p;
pnm_init(&argc, argv);
for (argn = 1;argn < argc && argv[argn][0] == '-';argn++) {
int arglen = strlen(argv[argn]);
if (!strncmp (argv[argn],"-resolution", arglen)) {
if (argn + 2 < argc) {
hor_resolution = atoi(argv[argn+1]);
ver_resolution = atoi(argv[argn+2]);
argn += 2;
continue;
} else {
pm_usage(usage);
}
} else {
pm_usage(usage);
}
}
if (hor_resolution <= 0 || ver_resolution <= 0) {
fprintf(stderr,"Unreasonable resolution values: %d x %d\n",
hor_resolution,ver_resolution);
exit(1);
}
if (argn == argc - 2) {
ifd = pm_openr(argv[argn]);
outfile = argv[argn+1];
if (!(ofd = fopen(outfile,"wb"))) {
perror(outfile);
exit(1);
}
} else if (argn == argc - 1) {
ifd = pm_openr(argv[argn]);
ofd = stdout;
} else {
ifd = stdin;
ofd = stdout;
}
pnm_readpnminit(ifd, &cols, &rows, &maxval, &format);
ip.width = cols;
ip.height = rows;
ip.h_res = hor_resolution;
ip.v_res = ver_resolution;
switch (PNM_FORMAT_TYPE(format)) {
case PBM_TYPE:
ip.bits_per_pixel = 1;
ip.bytes_per_line = (cols + 7) / 8;
ip.spectral = 2;
ip.components = 1;
ip.bits_per_component = 1;
ip.polarity = 1;
break;
case PGM_TYPE:
ip.bytes_per_line = cols;
ip.bits_per_pixel = 8;
ip.spectral = 2;
ip.components = 1;
ip.bits_per_component = 8;
ip.polarity = 2;
break;
case PPM_TYPE:
ip.bytes_per_line = 3 * cols;
ip.bits_per_pixel = 24;
ip.spectral = 5;
ip.components = 3;
ip.bits_per_component = 8;
ip.polarity = 2;
break;
default:
fprintf(stderr, "Unrecognized PBMPLUS format %d\n", format);
exit(1);
}
if (!write_header(ofd,&ip)) {
perror("Writing header");
exit(1);
}
if (!(p = data = (unsigned char*) malloc(ip.bytes_per_line))) {
perror("allocating line buffer");
exit(1);
}
switch (PNM_FORMAT_TYPE(format)) {
case PBM_TYPE:
{
bit *pixels;
int mask;
int k;
pixels = pbm_allocrow(cols);
for (i = 0; i < rows; i++) {
pbm_readpbmrow(ifd, pixels, cols, format);
mask = 0;
p = data;
for (j = 0, k = 0; j < cols; j++) {
if (pixels[j] == PBM_BLACK) {
mask |= 1 << k;
}
if (k == 7) {
*p++ = mask;
mask = 0;
k = 0;
} else {
k++;
}
}
if (k != 7) { /* Flush the rest of the column */
*p = mask;
}
if (fwrite(data,1,ip.bytes_per_line,ofd) != ip.bytes_per_line) {
perror("Writing image data\n");
exit(1);
}
}
}
break;
case PGM_TYPE:
{
gray *pixels = pgm_allocrow(cols);
for (i = 0; i < rows; i++) {
p = data;
pgm_readpgmrow(ifd, pixels, cols, maxval, format);
for (j = 0; j < cols; j++) {
*p++ = (unsigned char) pixels[j];
}
if (fwrite(data,1,ip.bytes_per_line,ofd) != ip.bytes_per_line) {
perror("Writing image data\n");
exit(1);
}
}
pgm_freerow(pixels);
}
break;
case PPM_TYPE:
{
pixel *pixels = ppm_allocrow(cols);
for (i = 0; i < rows; i++) {
p = data;
ppm_readppmrow(ifd, pixels, cols, maxval, format);
for (j = 0; j < cols; j++) {
*p++ = PPM_GETR(pixels[j]);
*p++ = PPM_GETG(pixels[j]);
*p++ = PPM_GETB(pixels[j]);
}
if (fwrite(data,1,ip.bytes_per_line,ofd) != ip.bytes_per_line) {
perror("Writing image data\n");
exit(1);
}
}
ppm_freerow(pixels);
}
break;
}
pm_close(ifd);
free(data);
if (!write_trailer(ofd)) {
perror("Writing trailer");
exit(1);
}
if (fclose(ofd) == EOF) {
perror("Closing output file");
exit(1);
};
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;
}
int
main(int argc, char *argv[]) {
FILE *ifd;
FILE *ofd;
int rows, cols;
xelval maxval;
int format;
const char * const usage = "[-resolution x y] [pnmfile [ddiffile]]";
char *outfile;
int argn;
int hor_resolution = 75;
int ver_resolution = 75;
imageparams ip;
pnm_init(&argc, argv);
for (argn = 1;argn < argc && argv[argn][0] == '-';argn++) {
int arglen = strlen(argv[argn]);
if (!strncmp (argv[argn],"-resolution", arglen)) {
if (argn + 2 < argc) {
hor_resolution = atoi(argv[argn+1]);
ver_resolution = atoi(argv[argn+2]);
argn += 2;
continue;
} else {
pm_usage(usage);
}
} else {
pm_usage(usage);
}
}
if (hor_resolution <= 0 || ver_resolution <= 0) {
fprintf(stderr,"Unreasonable resolution values: %d x %d\n",
hor_resolution,ver_resolution);
exit(1);
}
if (argn == argc - 2) {
ifd = pm_openr(argv[argn]);
outfile = argv[argn+1];
if (!(ofd = fopen(outfile,"wb"))) {
perror(outfile);
exit(1);
}
} else if (argn == argc - 1) {
ifd = pm_openr(argv[argn]);
ofd = stdout;
} else {
ifd = stdin;
ofd = stdout;
}
pnm_readpnminit(ifd, &cols, &rows, &maxval, &format);
ip.width = cols;
ip.height = rows;
ip.h_res = hor_resolution;
ip.v_res = ver_resolution;
switch (PNM_FORMAT_TYPE(format)) {
case PBM_TYPE:
ip.bits_per_pixel = 1;
ip.bytes_per_line = (cols + 7) / 8;
ip.spectral = 2;
ip.components = 1;
ip.bits_per_component = 1;
ip.polarity = 1;
break;
case PGM_TYPE:
ip.bytes_per_line = cols;
ip.bits_per_pixel = 8;
ip.spectral = 2;
ip.components = 1;
ip.bits_per_component = 8;
ip.polarity = 2;
break;
case PPM_TYPE:
ip.bytes_per_line = 3 * cols;
ip.bits_per_pixel = 24;
ip.spectral = 5;
ip.components = 3;
ip.bits_per_component = 8;
ip.polarity = 2;
break;
default:
fprintf(stderr, "Unrecognized PBMPLUS format %d\n", format);
exit(1);
}
if (!write_header(ofd,&ip)) {
perror("Writing header");
exit(1);
}
convertRaster(ifd, format, maxval, cols, rows, ofd, ip.bytes_per_line);
pm_close(ifd);
if (!write_trailer(ofd)) {
perror("Writing trailer");
exit(1);
}
if (fclose(ofd) == EOF) {
perror("Closing output file");
exit(1);
};
return(0);
}
