/*
Convert a portable pixmap to an AutoCAD slide or DXB file
Author:
John Walker
Autodesk SA
Avenue des Champs-Montants 14b
CH-2074 MARIN
Switzerland
Usenet: kelvin@Autodesk.com
Fax: 038/33 88 15
Voice: 038/33 76 33
Permission to use, copy, modify, and distribute this software and
its documentation for any purpose and without fee is hereby
granted, without any conditions or restrictions. This software is
provided "as is" without express or implied warranty.
*/
#include <stdio.h>
#include "pm_c_util.h"
#include "ppm.h"
#define EOS '\0'
#define MAXHIST 32767 /* Color histogram maximum size */
static pixel **pixels; /* Input pixel map */
static colorhash_table cht; /* Color hash table */
static int curcol = -1; /* Current slide output color */
static int polymode = FALSE; /* Output filled polygons ? */
static int dxbmode = FALSE; /* Output .dxb format ? */
static int bgcol = -1; /* Screen background color */
static double aspect = 1.0; /* Pixel aspect ratio correction */
static int gamut = 256; /* Output color gamut */
#include "autocad.h" /* AutoCAD standard color assignments */
/* prototypes */
static void outrun ARGS((int color, int ysize, int y, int xstart, int xend));
static void slideout ARGS((int xdots, int ydots, int ncolors,
unsigned char *red, unsigned char *green, unsigned char *blue));
/* OUTRUN -- Output a run of pixels. */
static void outrun(color, ysize, y, xstart, xend)
int color, ysize, y, xstart, xend;
{
if (color == 0) {
return; /* Let screen background handle this */
}
if (curcol != color) {
if (dxbmode) {
putchar((char)136);
(void) pm_writelittleshort(stdout, color);
} else {
(void) pm_writelittleshort(stdout, (short) 0xFF00 | color);
}
curcol = color;
}
if (polymode) {
int v, yb = (ysize - y) + 1, yspan = 1;
/* Since we're emitting filled polygons, let's scan downward
in the pixmap and see if we can extend the run on this line
vertically as well. If so, emit a polygon that handles
both the horizontal and vertical run and clear the pixels
in the subsequent lines to the background color. */
for (v = y + 1; v <= ysize; v++) {
int j, mismatch = FALSE;
for (j = xstart; j <= xend; j++) {
if (PPM_GETR(pixels[y][j]) != PPM_GETR(pixels[v][j])) {
mismatch = TRUE;
break;
}
}
if (mismatch) {
break;
}
for (j = xstart; j <= xend; j++) {
PPM_ASSIGN(pixels[v][j], 0, 0, 0);
}
}
yspan = v - y;
if (dxbmode) {
putchar(11); /* Solid */
(void) pm_writelittleshort(
stdout, (int) (xstart * aspect + 0.4999));
(void) pm_writelittleshort(stdout, yb);
(void) pm_writelittleshort(
stdout, (int) ((xend + 1) * aspect + 0.4999));
(void) pm_writelittleshort(stdout, yb);
(void) pm_writelittleshort(
stdout, (int) (xstart * aspect + 0.4999));
(void) pm_writelittleshort(stdout, yb - yspan);
(void) pm_writelittleshort(
stdout, (int) ((xend + 1) * aspect + 0.4999));
(void) pm_writelittleshort(stdout, yb - yspan);
} else {
(void) pm_writelittleshort(stdout, (short) 0xFD00);
/* Solid fill header */
(void) pm_writelittleshort(stdout, 4);
/* Vertices to follow */
(void) pm_writelittleshort(stdout, -2); /* Fill type */
(void) pm_writelittleshort(stdout, (short)0xFD00);
/* Solid fill vertex */
(void) pm_writelittleshort(stdout, xstart);
(void) pm_writelittleshort(stdout, yb);
(void) pm_writelittleshort(stdout, (short) 0xFD00);
/* Solid fill vertex */
(void) pm_writelittleshort(stdout, xend + 1);
(void) pm_writelittleshort(stdout, yb);
(void) pm_writelittleshort(stdout, (short) 0xFD00);
/* Solid fill vertex */
(void) pm_writelittleshort(stdout, xend + 1);
(void) pm_writelittleshort(stdout, yb - yspan);
(void) pm_writelittleshort(stdout, (short) 0xFD00);
/* Solid fill vertex */
(void) pm_writelittleshort(stdout, xstart);
(void) pm_writelittleshort(stdout, yb - yspan);
(void) pm_writelittleshort(stdout, (short) 0xFD00);
/* Solid fill trailer */
(void) pm_writelittleshort(stdout, 4); /* Vertices that precede */
(void) pm_writelittleshort(stdout, -2); /* Fill type */
}
} else {
(void) pm_writelittleshort(stdout, xstart); /* Vector: From X */
(void) pm_writelittleshort(stdout, ysize - y); /* From Y */
(void) pm_writelittleshort(stdout, xend); /* To X */
(void) pm_writelittleshort(stdout, ysize - y); /* To Y */
}
}
/* SLIDEOUT -- Write an AutoCAD slide. */
static void slideout(xdots, ydots, ncolors, red, green, blue)
int xdots, ydots, ncolors;
unsigned char *red, *green, *blue;
{
static char sldhead[18] = "AutoCAD Slide\r\n\32";
static char dxbhead[20] = "AutoCAD DXB 1.0\r\n\32";
unsigned char *acadmap;
int i, xsize, ysize;
/* If the user has specified a non-black screen background color,
swap the screen background color into color index zero and
move black into the slot previously occupied by the background
color. */
if (bgcol > 0) {
acadcol[0][0] = acadcol[bgcol][0];
acadcol[0][1] = acadcol[bgcol][1];
acadcol[0][2] = acadcol[bgcol][2];
acadcol[bgcol][0] = acadcol[bgcol][1] = acadcol[bgcol][2] = 0;
}
acadmap = (unsigned char *) pm_allocrow(ncolors, sizeof(unsigned char));
xsize = polymode ? xdots : (xdots - 1);
ysize = polymode ? ydots : (ydots - 1);
if (dxbmode) {
fwrite(dxbhead, 19, 1, stdout); /* DXB file header */
putchar((char)135); /* Number mode */
(void) pm_writelittleshort(stdout, 0); /* ...short integers */
} else {
fwrite(sldhead, 17, 1, stdout); /* Slide file header */
putchar(86); /* Number format indicator */
putchar(2); /* File level number */
(void) pm_writelittleshort(stdout, xsize); /* Max X co-ordinate value */
(void) pm_writelittleshort(stdout, ysize); /* Max Y co-ordinate value */
/* Aspect ratio indicator */
(void) pm_writelittlelong(
stdout, (long) ((((double) xsize) / ysize) * aspect * 1E7));
(void) pm_writelittleshort(stdout, 2); /* Polygon fill type */
(void) pm_writelittleshort(stdout, 0x1234); /* Byte order indicator */
}
/* Now build a mapping from the image's computed color map
indices to the closest representation of each color within
AutoCAD's color repertoire. */
for (i = 0; i < ncolors; i++) {
int best, j;
long dist = 3 * 256 * 256;
for (j = 0; j < gamut; j++) {
long dr = red[i] - acadcol[j][0],
dg = green[i] - acadcol[j][1],
db = blue[i] - acadcol[j][2];
long tdist = dr * dr + dg * dg + db * db;
if (tdist < dist) {
dist = tdist;
best = j;
}
}
acadmap[i] = best;
}
/* Swoop over the entire map and replace each RGB pixel with its
closest AutoCAD color representation. We do this in a
separate pass since it avoids repetitive mapping of pixels as
we examine them for compression. */
for (i = 0; i < ydots; i++) {
int x;
for (x = 0; x < xdots; x++) {
PPM_ASSIGN(pixels[i][x],
acadmap[ppm_lookupcolor(cht, &pixels[i][x])], 0 ,0);
}
}
/* Output a run-length encoded expression of the pixmap as AutoCAD
vectors. */
for (i = 0; i < ydots; i++) {
int x, rx, rpix = -1, nrun = 0;
for (x = 0; x < xdots; x++) {
int pix = PPM_GETR(pixels[i][x]);
if (pix != rpix) {
if (nrun > 0) {
if (rpix > 0) {
outrun(rpix, ydots - 1, i, rx, x - 1);
}
}
rpix = pix;
rx = x;
nrun = 1;
}
}
if ((nrun > 0) && (rpix > 0)) {
outrun(rpix, ydots - 1, i, rx, xdots - 1);
}
}
if (dxbmode) {
putchar(0); /* DXB end sentinel */
} else {
(void) pm_writelittleshort(stdout, (short) 0xFC00);
/* End of file marker */
}
pm_freerow((char *) acadmap);
}
/* Main program. */
int main(argc, argv)
int argc;
char* argv[];
{
FILE *ifp;
int argn, rows, cols, ncolors, i;
int aspectspec = FALSE;
pixval maxval;
colorhist_vector chv;
unsigned char *Red, *Green, *Blue;
const char * const usage =
"[-poly] [-dxb] [-white] [-background <col>]\n\
[-aspect <f>] [-8] [ppmfile]";
ppm_init(&argc, argv);
argn = 1;
while (argn < argc && argv[argn][0] == '-' && argv[argn][1] != EOS) {
if (pm_keymatch(argv[argn], "-dxb", 2)) {
dxbmode = polymode = TRUE;
} else if (pm_keymatch(argv[argn], "-poly", 2)) {
polymode = TRUE;
} else if (pm_keymatch(argv[argn], "-white", 2)) {
if (bgcol >= 0) {
pm_error("already specified a background color");
}
bgcol = 7;
} else if (pm_keymatch(argv[argn], "-background", 2)) {
if (bgcol >= 0) {
pm_error("already specified a background color");
}
argn++;
if ((argn == argc) || (sscanf(argv[argn], "%d", &bgcol) != 1))
pm_usage(usage);
if (bgcol < 0) {
pm_error("background color must be >= 0 and <= 255");
}
} else if (pm_keymatch(argv[argn], "-aspect", 2)) {
if (aspectspec) {
pm_error("already specified an aspect ratio");
}
argn++;
if ((argn == argc) || (sscanf(argv[argn], "%lf", &aspect) != 1))
pm_usage(usage);
if (aspect <= 0.0) {
pm_error("aspect ratio must be greater than 0");
}
aspectspec = TRUE;
} else if (pm_keymatch(argv[argn], "-8", 2)) {
gamut = 8;
} else {
pm_usage(usage);
}
argn++;
}
if (argn < argc) {
ifp = pm_openr(argv[argn]);
argn++;
} else {
ifp = stdin;
}
if (argn != argc) {
pm_usage(usage);
}
pixels = ppm_readppm(ifp, &cols, &rows, &maxval);
pm_close(ifp);
/* Figure out the colormap. Logic for squeezing depth to limit the
number of colors in the image was swiped from ppmquant.c. */
while (TRUE) {
int row, col;
pixval newmaxval;
pixel *pP;
pm_message("computing colormap...");
chv = ppm_computecolorhist(pixels, cols, rows, MAXHIST, &ncolors);
if (chv != (colorhist_vector) 0)
break;
newmaxval = maxval / 2;
pm_message(
"scaling colors from maxval=%d to maxval=%d to improve clustering...",
maxval, newmaxval );
for (row = 0; row < rows; ++row) {
for (col = 0, pP = pixels[row]; col < cols; ++col, ++pP) {
PPM_DEPTH(*pP, *pP, maxval, newmaxval);
}
}
maxval = newmaxval;
}
pm_message("%d colors found", ncolors);
/* Scale the color map derived for the PPM file into one compatible
with AutoCAD's convention of 8 bit intensities. */
if (maxval != 255) {
pm_message("maxval is not 255 - automatically rescaling colors");
}
Red = (unsigned char *) pm_allocrow(ncolors, sizeof(unsigned char));
Green = (unsigned char *) pm_allocrow(ncolors, sizeof(unsigned char));
Blue = (unsigned char *) pm_allocrow(ncolors, sizeof(unsigned char));
for (i = 0; i < ncolors; ++i) {
if ( maxval == 255 ) {
Red[i] = PPM_GETR(chv[i].color);
Green[i] = PPM_GETG(chv[i].color);
Blue[i] = PPM_GETB( chv[i].color );
} else {
Red[i] = ((int) PPM_GETR(chv[i].color) * 255) / maxval;
Green[i] = ((int) PPM_GETG(chv[i].color) * 255) / maxval;
Blue[i] = ((int) PPM_GETB(chv[i].color) * 255) / maxval;
}
}
/* And make a hash table for fast lookup. */
cht = ppm_colorhisttocolorhash(chv, ncolors);
ppm_freecolorhist(chv);
slideout(cols, rows, ncolors, Red, Green, Blue);
pm_freerow((char *) Red);
pm_freerow((char *) Green);
pm_freerow((char *) Blue);
exit(0);
}