static void putPcxColorInHash(colorhash_table const cht, pixel const newPcxColor, unsigned int const newColorIndex, pixval const maxval) { pixel ppmColor; /* Same color as 'newPcxColor', but at the PPM image's color resolution: 'maxval' */ int rc; PPM_DEPTH(ppmColor, newPcxColor, PCX_MAXVAL, maxval); rc = ppm_lookupcolor(cht, &ppmColor); if (rc == -1) /* This color is not in the hash yet, so we just add it */ ppm_addtocolorhash(cht, &ppmColor, newColorIndex); else { /* This color is already in the hash. That's because the subject image has less color resolution than PCX (i.e. 'maxval' is less than PCX_MAXVAL), and two distinct colors in the standard palette are indistinguishable at subject image color resolution. So we have to figure out wether color 'newPcxColor' or 'existingPcxColor' is a better match for 'ppmColor'. */ unsigned int const existingColorIndex = rc; pixel idealPcxColor; pixel existingPcxColor; PPM_DEPTH(idealPcxColor, ppmColor, maxval, PCX_MAXVAL); PPM_ASSIGN(existingPcxColor, stdPalette[existingColorIndex].r, stdPalette[existingColorIndex].g, stdPalette[existingColorIndex].b); if (PPM_DISTANCE(newPcxColor, idealPcxColor) < PPM_DISTANCE(existingPcxColor, idealPcxColor)) { /* The new PCX color is a better match. Make it the new translation of image color 'ppmColor'. */ ppm_delfromcolorhash(cht, &ppmColor); ppm_addtocolorhash(cht, &ppmColor, newColorIndex); } } }
static void normalize_ppm(xel **pnm, int cols, int rows, int maxval) { int i, j; for (i = 0 ; i < rows; i++) for (j = 0; j < cols; j++) PPM_DEPTH(pnm[i][j], pnm[i][j], maxval, 255); }
pixel ppm_color_from_bk_color(bk_color const bkColor, pixval const maxval) { pixel const color255 = bkColorMap[bkColor]; pixel retval; if (maxval != 255) { PPM_DEPTH(retval, color255, 255, maxval); } else retval = color255; return retval; }
static void makePcxColormapFromImage(pixel ** const pixels, int const cols, int const rows, pixval const maxval, struct pcxCmapEntry ** const pcxcmapP, colorhash_table * const chtP, int * const colorsP, bool * const tooManyColorsP) { /*---------------------------------------------------------------------------- Make a colormap (palette) for the PCX header that can be used for the image described by 'pixels', 'cols', 'rows', and 'maxval'. Return it in newly malloc'ed storage and return its address as *pcxcmapP. Also return a lookup hash to relate a color in the image to the appropriate index in *pcxcmapP. Return that in newly malloc'ed storage as *chtP. Iff there are too many colors to do that (i.e. more than 256), return *tooManyColorsP == TRUE. -----------------------------------------------------------------------------*/ int colors; colorhist_vector chv; pm_message("computing colormap..."); chv = ppm_computecolorhist(pixels, cols, rows, MAXCOLORS, &colors); if (chv == NULL) *tooManyColorsP = TRUE; else { int i; struct pcxCmapEntry * pcxcmap; *tooManyColorsP = FALSE; pm_message("%d colors found", colors); moveBlackToIndex0(chv, colors); MALLOCARRAY_NOFAIL(pcxcmap, MAXCOLORS); *pcxcmapP = pcxcmap; for (i = 0; i < colors; ++i) { pixel p; PPM_DEPTH(p, chv[i].color, maxval, PCX_MAXVAL); pcxcmap[i].r = PPM_GETR(p); pcxcmap[i].g = PPM_GETG(p); pcxcmap[i].b = PPM_GETB(p); } /* Fill it out with black */ for ( ; i < MAXCOLORS; ++i) { pcxcmap[i].r = 0; pcxcmap[i].g = 0; pcxcmap[i].b = 0; } *chtP = ppm_colorhisttocolorhash(chv, colors); *colorsP = colors; ppm_freecolorhist(chv); } }
static void genCmap(colorhist_vector const chv, int const ncolors, pixval const maxval, colorhash_table const colornameHash, const char * const colornames[], bool const includeTransparent, cixel_map ** const cmapP, unsigned int * const transIndexP, unsigned int * const cmapSizeP, unsigned int * const charsPerPixelP) { /*---------------------------------------------------------------------------- Generate the XPM color map in cixel_map format (which is just a step away from the actual text that needs to be written the XPM file). The color map is defined by 'chv', which contains 'ncolors' colors which have maxval 'maxval'. Output is in newly malloc'ed storage, with its address returned as *cmapP. We return the number of entries in it as *cmapSizeP. This map includes an entry for transparency, whether the raster uses it or not. We return its index as *transIndexP. In the map, identify colors by the names given by 'colornameHash' and colornames[]. 'colornameHash' maps a color in 'pixel' form to an index into colornames[]; colornames[] contains the text to identify the color in the XPM format. The colors in 'colornameHash' have maxval 255. If a color is not in 'colornameHash', use hexadecimal notation in the output colormap. But if 'colornameHash' is null, don't use color names at all. Just use hexadecimal notation. Return as *charsPerPixel the number of characters, or digits, that will be needed in the XPM raster to form an index into this color map. -----------------------------------------------------------------------------*/ unsigned int const cmapSize = ncolors + (includeTransparent ? 1 : 0); cixel_map * cmap; /* malloc'ed */ unsigned int cmapIndex; unsigned int charsPerPixel; unsigned int xpmMaxval; MALLOCARRAY(cmap, cmapSize); if (cmapP == NULL) pm_error("Out of memory allocating %u bytes for a color map.", (unsigned)sizeof(cixel_map) * (ncolors+1)); xpmMaxval = xpmMaxvalFromMaxval(maxval); charsPerPixel = charsPerPixelForSize(cmapSize); /* * Generate the character-pixel string and the rgb name for each * colormap entry. */ for (cmapIndex = 0; cmapIndex < ncolors; ++cmapIndex) { pixel const color = chv[cmapIndex].color; pixel color255; /* The color, scaled to maxval 255 */ const char * colorname; /* malloc'ed */ /* * The character-pixel string is simply a printed number in base * MAXPRINTABLE where the digits of the number range from * printable[0] .. printable[MAXPRINTABLE-1] and the printed length * of the number is 'charsPerPixel'. */ cmap[cmapIndex].cixel = genNumstr(cmapIndex, charsPerPixel); PPM_DEPTH(color255, color, maxval, 255); if (colornameHash == NULL) colorname = NULL; else { int colornameIndex; colornameIndex = ppm_lookupcolor(colornameHash, &color255); if (colornameIndex >= 0) colorname = strdup(colornames[colornameIndex]); else colorname = NULL; } if (colorname) cmap[cmapIndex].rgbname = colorname; else { /* Color has no name; represent it in hexadecimal */ pixel scaledColor; const char * hexString; /* malloc'ed */ PPM_DEPTH(scaledColor, color, maxval, xpmMaxval); pm_asprintf(&hexString, xpmMaxval == 0x000F ? "#%X%X%X" : xpmMaxval == 0x00FF ? "#%02X%02X%02X" : xpmMaxval == 0x0FFF ? "#%03X%03X%03X" : "#%04X%04X%04X", PPM_GETR(scaledColor), PPM_GETG(scaledColor), PPM_GETB(scaledColor) ); if (hexString == NULL) pm_error("Unable to allocate storage for hex string"); cmap[cmapIndex].rgbname = hexString; } } if (includeTransparent) { /* Add the special transparency entry to the colormap */ unsigned int const transIndex = ncolors; cmap[transIndex].rgbname = strdup("None"); cmap[transIndex].cixel = genNumstr(transIndex, charsPerPixel); *transIndexP = transIndex; } *cmapP = cmap; *cmapSizeP = cmapSize; *charsPerPixelP = charsPerPixel; }