static void
ppmTo256ColorPcx(pixel ** const pixels,
int const cols,
int const rows,
struct pcxCmapEntry const pcxcmap[],
int const colors,
colorhash_table const cht,
unsigned int const xPos,
unsigned int const yPos) {
int row;
unsigned int i;
unsigned char *rawrow;
rawrow = (unsigned char *)pm_allocrow(cols, sizeof(unsigned char));
/* 8 bits per pixel, 1 plane */
write_header(stdout, cols, rows, 8, 1, NULL, xPos, yPos);
for (row = 0; row < rows; ++row) {
int col;
for (col = 0; col < cols; ++col)
rawrow[col] = indexOfColor(cht, pixels[row][col]);
PCXEncode(stdout, rawrow, cols);
}
Putbyte(PCX_256_COLORS, stdout);
for (i = 0; i < MAXCOLORS; ++i) {
Putbyte(pcxcmap[i].r, stdout);
Putbyte(pcxcmap[i].g, stdout);
Putbyte(pcxcmap[i].b, stdout);
}
pm_freerow((void*)rawrow);
}
static void
ppmToTruecolorPcx(pixel ** const pixels,
int const cols,
int const rows,
pixval const maxval,
unsigned int const xPos,
unsigned int const yPos) {
unsigned char *redrow, *greenrow, *bluerow;
int col, row;
redrow = (unsigned char *)pm_allocrow(cols, sizeof(unsigned char));
greenrow = (unsigned char *)pm_allocrow(cols, sizeof(unsigned char));
bluerow = (unsigned char *)pm_allocrow(cols, sizeof(unsigned char));
/* 8 bits per pixel, 3 planes */
write_header(stdout, cols, rows, 8, 3, NULL, xPos, yPos);
for( row = 0; row < rows; row++ ) {
register pixel *pP = pixels[row];
for( col = 0; col < cols; col++, pP++ ) {
if( maxval != PCX_MAXVAL ) {
redrow[col] = (long)PPM_GETR(*pP) * PCX_MAXVAL / maxval;
greenrow[col] = (long)PPM_GETG(*pP) * PCX_MAXVAL / maxval;
bluerow[col] = (long)PPM_GETB(*pP) * PCX_MAXVAL / maxval;
}
else {
redrow[col] = PPM_GETR(*pP);
greenrow[col] = PPM_GETG(*pP);
bluerow[col] = PPM_GETB(*pP);
}
}
PCXEncode(stdout, redrow, cols);
PCXEncode(stdout, greenrow, cols);
PCXEncode(stdout, bluerow, cols);
}
pm_freerow((void*)bluerow);
pm_freerow((void*)greenrow);
pm_freerow((void*)redrow);
}
void
pm_freearray(char ** const rowIndex,
int const rows) {
void * const rowheap = rowIndex[rows];
if (rowheap != NULL)
free(rowheap);
else {
unsigned int row;
for (row = 0; row < rows; ++row)
pm_freerow(rowIndex[row]);
}
free(rowIndex);
}
int
main(int argc,
char * argv[]) {
struct cmdlineInfo cmdline;
FILE * ifP;
int cols, rows;
int median;
enum medianMethod medianMethod;
pgm_init(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
ifP = pm_openr(cmdline.inputFileName);
ccolso2 = cmdline.width / 2;
crowso2 = cmdline.height / 2;
pgm_readpgminit(ifP, &cols, &rows, &maxval, &format);
pgm_writepgminit(stdout, cols, rows, maxval, forceplain);
/* Allocate space for number of rows in mask size. */
grays = pgm_allocarray(cols, cmdline.height);
grayrow = pgm_allocrow(cols);
/* Allocate pointers to mask row buffer. */
rowptr = (gray **) pm_allocrow(cmdline.height, sizeof(gray *));
/* Read in and write out initial rows that won't get changed. */
for (row = 0; row < cmdline.height - 1; ++row) {
pgm_readpgmrow(ifP, grays[row], cols, maxval, format);
/* Write out the unchanged row. */
if (row < crowso2)
pgm_writepgmrow(stdout, grays[row], cols, maxval, forceplain);
}
median = (cmdline.height * cmdline.width) / 2;
/* Choose which sort to run. */
if (cmdline.type == MEDIAN_UNSPECIFIED) {
if ((maxval / ((cmdline.width * cmdline.height) - 1)) < cmdline.cutoff)
medianMethod = HISTOGRAM_SORT_MEDIAN;
else
medianMethod = SELECT_MEDIAN;
} else
medianMethod = cmdline.type;
switch (medianMethod) {
case SELECT_MEDIAN:
select_median(ifP, cmdline.width, cmdline.height, cols, rows, median);
break;
case HISTOGRAM_SORT_MEDIAN:
histogram_sort_median(ifP, cmdline.width, cmdline.height,
cols, rows, median);
break;
case MEDIAN_UNSPECIFIED:
pm_error("INTERNAL ERROR: median unspecified");
}
pm_close(ifP);
pm_close(stdout);
pgm_freearray(grays, cmdline.height);
pgm_freerow(grayrow);
pm_freerow(rowptr);
return 0;
}
static void
histogram_sort_median(FILE * const ifp,
int const ccols,
int const crows,
int const cols,
int const rows,
int const median) {
int const histmax = maxval + 1;
int *hist;
int mdn, ltmdn;
gray *left_col, *right_col;
hist = (int *) pm_allocrow( histmax, sizeof( int ) );
left_col = pgm_allocrow( crows );
right_col = pgm_allocrow( crows );
/* Apply median to main part of image. */
for ( ; row < rows; ++row ) {
int col;
int temprow;
int rownum;
int irow;
int i;
/* initialize hist[] */
for ( i = 0; i < histmax; ++i )
hist[i] = 0;
temprow = row % crows;
pgm_readpgmrow( ifp, grays[temprow], cols, maxval, format );
/* Rotate pointers to rows, so rows can be accessed in order. */
temprow = ( row + 1 ) % crows;
rownum = 0;
for ( irow = temprow; irow < crows; ++rownum, ++irow )
rowptr[rownum] = grays[irow];
for ( irow = 0; irow < temprow; ++rownum, ++irow )
rowptr[rownum] = grays[irow];
for ( col = 0; col < cols; ++col ) {
if ( col < ccolso2 || col >= cols - ccolso2 )
grayrow[col] = rowptr[crowso2][col];
else if ( col == ccolso2 ) {
int crow;
int const leftcol = col - ccolso2;
i = 0;
for ( crow = 0; crow < crows; ++crow ) {
int ccol;
gray * const temprptr = rowptr[crow] + leftcol;
for ( ccol = 0; ccol < ccols; ++ccol ) {
gray const g = *( temprptr + ccol );
++hist[g];
++i;
}
}
ltmdn = 0;
for ( mdn = 0; ltmdn <= median; ++mdn )
ltmdn += hist[mdn];
mdn--;
if ( ltmdn > median )
ltmdn -= hist[mdn];
grayrow[col] = mdn;
} else {
int crow;
int const subcol = col - ( ccolso2 + 1 );
int const addcol = col + ccolso2;
for ( crow = 0; crow < crows; ++crow ) {
left_col[crow] = *( rowptr[crow] + subcol );
right_col[crow] = *( rowptr[crow] + addcol );
}
for ( crow = 0; crow < crows; ++crow ) {
{
gray const g = left_col[crow];
hist[(int) g]--;
if ( (int) g < mdn )
ltmdn--;
}
{
gray const g = right_col[crow];
hist[(int) g]++;
if ( (int) g < mdn )
ltmdn++;
}
}
if ( ltmdn > median )
do {
mdn--;
ltmdn -= hist[mdn];
} while ( ltmdn > median );
else {
/* This one change from Pitas algorithm can reduce run
** time by up to 10%.
*/
while ( ltmdn <= median ) {
ltmdn += hist[mdn];
mdn++;
}
mdn--;
if ( ltmdn > median )
ltmdn -= hist[mdn];
}
grayrow[col] = mdn;
}
}
pgm_writepgmrow( stdout, grayrow, cols, maxval, forceplain );
}
{
/* Write out remaining unchanged rows. */
int irow;
for ( irow = crowso2 + 1; irow < crows; ++irow )
pgm_writepgmrow( stdout, rowptr[irow], cols, maxval, forceplain );
}
pm_freerow( (char *) hist );
pgm_freerow( left_col );
pgm_freerow( right_col );
}
static void
select_median(FILE * const ifp,
int const ccols,
int const crows,
int const cols,
int const rows,
int const median) {
int ccol, col;
int crow;
int rownum, irow, temprow;
gray *temprptr;
int i, leftcol;
int num_values;
gray *garray;
int *parray;
int addcol;
int *subcol;
int tsum;
/* Allocate storage for array of the current gray values. */
garray = pgm_allocrow( crows * ccols );
num_values = crows * ccols;
parray = (int *) pm_allocrow( crows * ccols, sizeof(int) );
subcol = (int *) pm_allocrow( cols, sizeof(int) );
for ( i = 0; i < cols; ++i )
subcol[i] = ( i - (ccolso2 + 1) ) % ccols;
/* Apply median to main part of image. */
for ( ; row < rows; ++row ) {
temprow = row % crows;
pgm_readpgmrow( ifp, grays[temprow], cols, maxval, format );
/* Rotate pointers to rows, so rows can be accessed in order. */
temprow = ( row + 1 ) % crows;
rownum = 0;
for ( irow = temprow; irow < crows; ++rownum, ++irow )
rowptr[rownum] = grays[irow];
for ( irow = 0; irow < temprow; ++rownum, ++irow )
rowptr[rownum] = grays[irow];
for ( col = 0; col < cols; ++col ) {
if ( col < ccolso2 || col >= cols - ccolso2 ) {
grayrow[col] = rowptr[crowso2][col];
} else if ( col == ccolso2 ) {
leftcol = col - ccolso2;
i = 0;
for ( crow = 0; crow < crows; ++crow ) {
temprptr = rowptr[crow] + leftcol;
for ( ccol = 0; ccol < ccols; ++ccol ) {
garray[i] = *( temprptr + ccol );
parray[i] = i;
++i;
}
}
select_489( garray, parray, num_values, median );
grayrow[col] = garray[parray[median]];
} else {
addcol = col + ccolso2;
for (crow = 0, tsum = 0; crow < crows; ++crow, tsum += ccols)
garray[tsum + subcol[col]] = *(rowptr[crow] + addcol );
select_489( garray, parray, num_values, median );
grayrow[col] = garray[parray[median]];
}
}
pgm_writepgmrow( stdout, grayrow, cols, maxval, forceplain );
}
/* Write out remaining unchanged rows. */
for ( irow = crowso2 + 1; irow < crows; ++irow )
pgm_writepgmrow( stdout, rowptr[irow], cols, maxval, forceplain );
pgm_freerow( garray );
pm_freerow( (char *) parray );
pm_freerow( (char *) subcol );
}
