833 lines
24 KiB
Diff
833 lines
24 KiB
Diff
diff -up netpbm-10.47.05/editor/pnmmontage.c.pnmmontagefix netpbm-10.47.05/editor/pnmmontage.c
|
|
--- netpbm-10.47.05/editor/pnmmontage.c.pnmmontagefix 2009-12-10 08:34:32.000000000 +0100
|
|
+++ netpbm-10.47.05/editor/pnmmontage.c 2010-03-16 20:47:38.000000000 +0100
|
|
@@ -10,136 +10,19 @@
|
|
* implied warranty.
|
|
*/
|
|
|
|
-#define _BSD_SOURCE /* Make sure strdup() is in <string.h> */
|
|
-#include <assert.h>
|
|
#include <limits.h>
|
|
#include <string.h>
|
|
|
|
-#include "pm_c_util.h"
|
|
-#include "mallocvar.h"
|
|
-#include "nstring.h"
|
|
-#include "shhopt.h"
|
|
#include "pam.h"
|
|
+#include "shhopt.h"
|
|
+#include "nstring.h"
|
|
+#include "mallocvar.h"
|
|
|
|
+typedef struct { int f[sizeof(int) * 8 + 1]; } factorset;
|
|
+typedef struct { int x; int y; } coord;
|
|
|
|
-
|
|
-struct cmdlineInfo {
|
|
- const char * header;
|
|
- const char * data;
|
|
- const char * prefix;
|
|
- unsigned int quality;
|
|
- unsigned int quality2;
|
|
- unsigned int nFiles;
|
|
- const char ** inFileName;
|
|
-};
|
|
-
|
|
-
|
|
-
|
|
-static void
|
|
-parseCommandLine(int argc, const char ** argv,
|
|
- struct cmdlineInfo * const cmdlineP) {
|
|
-/*----------------------------------------------------------------------------
|
|
- parse program command line described in Unix standard form by argc
|
|
- and argv. Return the information in the options as *cmdlineP.
|
|
-
|
|
- If command line is internally inconsistent (invalid options, etc.),
|
|
- issue error message to stderr and abort program.
|
|
-
|
|
- Note that the strings we return are stored in the storage that
|
|
- was passed to us as the argv array. We also trash *argv.
|
|
------------------------------------------------------------------------------*/
|
|
- optEntry * option_def;
|
|
- /* Instructions to OptParseOptions3 on how to parse our options. */
|
|
- optStruct3 opt;
|
|
- unsigned int dataSpec, headerSpec, prefixSpec, qualitySpec;
|
|
- unsigned int option_def_index;
|
|
- unsigned int i;
|
|
- unsigned int q[10];
|
|
-
|
|
- MALLOCARRAY_NOFAIL(option_def, 100);
|
|
-
|
|
- option_def_index = 0; /* incremented by OPTENTRY */
|
|
- OPTENT3( 0, "data", OPT_STRING, &cmdlineP->data, &dataSpec, 0);
|
|
- OPTENT3( 0, "header", OPT_STRING, &cmdlineP->header, &headerSpec, 0);
|
|
- OPTENT3('q', "quality", OPT_UINT, &cmdlineP->quality, &qualitySpec, 0);
|
|
- OPTENT3('p', "prefix", OPT_STRING, &cmdlineP->prefix, &prefixSpec, 0);
|
|
- OPTENT3('0', "0", OPT_FLAG, NULL, &q[0], 0);
|
|
- OPTENT3('1', "1", OPT_FLAG, NULL, &q[1], 0);
|
|
- OPTENT3('2', "2", OPT_FLAG, NULL, &q[2], 0);
|
|
- OPTENT3('3', "3", OPT_FLAG, NULL, &q[3], 0);
|
|
- OPTENT3('4', "4", OPT_FLAG, NULL, &q[4], 0);
|
|
- OPTENT3('5', "5", OPT_FLAG, NULL, &q[5], 0);
|
|
- OPTENT3('6', "6", OPT_FLAG, NULL, &q[6], 0);
|
|
- OPTENT3('7', "7", OPT_FLAG, NULL, &q[7], 0);
|
|
- OPTENT3('8', "8", OPT_FLAG, NULL, &q[8], 0);
|
|
- OPTENT3('9', "9", OPT_FLAG, NULL, &q[9], 0);
|
|
-
|
|
- opt.opt_table = option_def;
|
|
- opt.short_allowed = FALSE;
|
|
- opt.allowNegNum = FALSE;
|
|
-
|
|
- optParseOptions3(&argc, (char**)argv, opt, sizeof(opt), 0);
|
|
-
|
|
- if (!dataSpec)
|
|
- cmdlineP->data = NULL;
|
|
- if (!headerSpec)
|
|
- cmdlineP->header = NULL;
|
|
- if (!prefixSpec)
|
|
- cmdlineP->prefix = "";
|
|
- if (!qualitySpec)
|
|
- cmdlineP->quality = 200;
|
|
-
|
|
-
|
|
- /* cmdlineP->quality2 is the greatest number from the --1, --2, etc.
|
|
- options, or 5 if none of those are specified.
|
|
- */
|
|
- cmdlineP->quality2 = 5; /* initial value */
|
|
- for (i = 0; i < 10; ++i) {
|
|
- if (q[i])
|
|
- cmdlineP->quality2 = i;
|
|
- }
|
|
-
|
|
- cmdlineP->nFiles = argc-1;
|
|
-
|
|
- MALLOCARRAY_NOFAIL(cmdlineP->inFileName, argc-1);
|
|
-
|
|
- for (i = 0; i < argc-1; ++i) {
|
|
- if (cmdlineP->data && strchr(argv[i+1], ':'))
|
|
- pm_error("Filename '%s' contains a \":\", which is forbidden "
|
|
- "with -data", argv[i+1]);
|
|
- else
|
|
- cmdlineP->inFileName[i] = strdup(argv[1+1]);
|
|
- }
|
|
-}
|
|
-
|
|
-
|
|
-
|
|
-typedef struct {
|
|
- int f[sizeof(int) * 8 + 1];
|
|
-} factorset;
|
|
-
|
|
-typedef struct {
|
|
- int x; int y;
|
|
-} coord;
|
|
-
|
|
-typedef struct {
|
|
- coord ul;
|
|
- coord size;
|
|
-} rectangle;
|
|
-
|
|
-static coord
|
|
-lr(rectangle const r) {
|
|
-/*----------------------------------------------------------------------------
|
|
- Return the coordinates of the lower right corner of 'r'
|
|
- (i.e. the pixel just beyond the lowest rightmost one).
|
|
------------------------------------------------------------------------------*/
|
|
- coord retval;
|
|
-
|
|
- retval.x = r.ul.x + r.size.x;
|
|
- retval.y = r.ul.y + r.size.y;
|
|
-
|
|
- return retval;
|
|
-}
|
|
+static int qfactor = 200;
|
|
+static int quality = 5;
|
|
|
|
static factorset
|
|
factor(int n)
|
|
@@ -180,151 +63,109 @@ gcd(int n, int m)
|
|
return (g);
|
|
}
|
|
|
|
+static __inline__ int imax(int n, int m) { return (n > m ? n : m); }
|
|
|
|
-
|
|
-static bool
|
|
-overlaps(rectangle const a,
|
|
- rectangle const b) {
|
|
-
|
|
- return
|
|
- (a.ul.x < lr(b).x && a.ul.y < lr(b).y) &&
|
|
- (lr(a).x > b.ul.x && lr(a).y > b.ul.y);
|
|
-}
|
|
-
|
|
-
|
|
-
|
|
-static bool
|
|
-collides(rectangle const test,
|
|
- const rectangle * const fieldList,
|
|
- unsigned int const n) {
|
|
-/*----------------------------------------------------------------------------
|
|
- Return true iff the rectangle 'test' overlaps any of the 'n' rectangles
|
|
- fieldList[].
|
|
------------------------------------------------------------------------------*/
|
|
- unsigned int i;
|
|
-
|
|
- for (i = 0; i < n; ++i)
|
|
- if (overlaps(fieldList[i], test))
|
|
- return true;
|
|
-
|
|
- return false;
|
|
+static int
|
|
+checkcollision(coord *locs, coord *szs, coord *cloc, coord *csz, int n)
|
|
+{
|
|
+ int i;
|
|
+ for (i = 0; i < n; ++i)
|
|
+ {
|
|
+ if ((locs[i].x < cloc->x + csz->x) &&
|
|
+ (locs[i].y < cloc->y + csz->y) &&
|
|
+ (locs[i].x + szs[i].x > cloc->x) &&
|
|
+ (locs[i].y + szs[i].y > cloc->y))
|
|
+ return (1);
|
|
+ }
|
|
+ return (0);
|
|
}
|
|
|
|
-
|
|
-
|
|
static void
|
|
-recursefindpack(rectangle * const current,
|
|
- coord const currentsz,
|
|
- coord * const best,
|
|
- unsigned int const minarea,
|
|
- unsigned int * const maxareaP,
|
|
- unsigned int const depth,
|
|
- unsigned int const n,
|
|
- unsigned int const xinc,
|
|
- unsigned int const yinc,
|
|
- unsigned int const quality,
|
|
- unsigned int const qfactor) {
|
|
-
|
|
- if (depth == n) {
|
|
- if (currentsz.x * currentsz.y < *maxareaP) {
|
|
- unsigned int i;
|
|
- for (i = 0; i < n; ++i)
|
|
- best[i] = current[i].ul;
|
|
- *maxareaP = currentsz.x * currentsz.y;
|
|
- }
|
|
- } else {
|
|
- unsigned int i;
|
|
-
|
|
- rectangle * const newP = ¤t[depth];
|
|
+recursefindpack(coord *current, coord currentsz, coord *set,
|
|
+ coord *best, int minarea, int *maxarea,
|
|
+ int depth, int n, int xinc, int yinc)
|
|
+{
|
|
+ coord c;
|
|
+ if (depth == n)
|
|
+ {
|
|
+ if (currentsz.x * currentsz.y < *maxarea)
|
|
+ {
|
|
+ memcpy(best, current, sizeof(coord) * n);
|
|
+ *maxarea = currentsz.x * currentsz.y;
|
|
+ }
|
|
+ return;
|
|
+ }
|
|
|
|
- for (i = 0; ; ++i) {
|
|
- for (newP->ul.x = 0, newP->ul.y = i * yinc;
|
|
- newP->ul.y <= i * yinc;) {
|
|
-
|
|
- coord c;
|
|
-
|
|
- c.x = MAX(lr(*newP).x, currentsz.x);
|
|
- c.y = MAX(lr(*newP).y, currentsz.y);
|
|
- pm_message("current = (%u.%u, %u.%u) new = (%u.%u, %u.%u)",
|
|
- current[0].ul.x, current[0].size.x,
|
|
- current[0].ul.y, current[0].size.y,
|
|
- newP->ul.x, newP->size.x,
|
|
- newP->ul.y, newP->size.y);
|
|
- if (!collides(*newP, current, depth)) {
|
|
- pm_message("Depth %u: Doesn't collide at i=%u", depth,i);
|
|
- recursefindpack(current, c, best, minarea, maxareaP,
|
|
- depth + 1, n, xinc, yinc,
|
|
- quality, qfactor);
|
|
- if (*maxareaP <= minarea)
|
|
- return;
|
|
- }
|
|
- if (newP->ul.x == (i - 1) * xinc)
|
|
- newP->ul.y = 0;
|
|
- if (newP->ul.x < i * xinc)
|
|
- newP->ul.x += xinc;
|
|
- else
|
|
- newP->ul.y += yinc;
|
|
- }
|
|
- }
|
|
+ for (current[depth].x = 0;
|
|
+ imax(current[depth].x + set[depth].x, currentsz.x) *
|
|
+ imax(currentsz.y, set[depth].y) < *maxarea;
|
|
+ current[depth].x += xinc)
|
|
+ {
|
|
+ for (current[depth].y = 0;
|
|
+ imax(current[depth].x + set[depth].x, currentsz.x) *
|
|
+ imax(currentsz.y, current[depth].y + set[depth].y) < *maxarea;
|
|
+ current[depth].y += yinc)
|
|
+ {
|
|
+ c.x = imax(current[depth].x + set[depth].x, currentsz.x);
|
|
+ c.y = imax(current[depth].y + set[depth].y, currentsz.y);
|
|
+ if (!checkcollision(current, set, ¤t[depth], &set[depth], depth))
|
|
+ {
|
|
+ recursefindpack(current, c, set, best, minarea, maxarea,
|
|
+ depth + 1, n, xinc, yinc);
|
|
+ if (*maxarea <= minarea)
|
|
+ return;
|
|
+ }
|
|
}
|
|
+ }
|
|
}
|
|
|
|
-
|
|
-
|
|
static void
|
|
-findpack(struct pam * const imgs,
|
|
- unsigned int const n,
|
|
- coord * const coords,
|
|
- unsigned int const quality,
|
|
- unsigned int const qfactor) {
|
|
+findpack(struct pam *imgs, int n, coord *coords)
|
|
+{
|
|
+ int minarea;
|
|
+ int i;
|
|
+ int rdiv;
|
|
+ int cdiv;
|
|
+ int minx = -1;
|
|
+ int miny = -1;
|
|
+ coord *current;
|
|
+ coord *set;
|
|
+ int z = INT_MAX;
|
|
+ coord c = { 0, 0 };
|
|
|
|
- int minarea;
|
|
- int i;
|
|
- int rdiv;
|
|
- int cdiv;
|
|
- int minx;
|
|
- int miny;
|
|
- rectangle * current;
|
|
- unsigned int z;
|
|
- coord c;
|
|
-
|
|
- minx = -1; miny = -1; /* initial value */
|
|
- z = UINT_MAX; /* initial value */
|
|
- c.x = 0; c.y = 0; /* initial value */
|
|
-
|
|
- if (quality > 1) {
|
|
- unsigned int realMinarea;
|
|
- for (realMinarea = i = 0; i < n; ++i)
|
|
- realMinarea += imgs[i].height * imgs[i].width,
|
|
- minx = MAX(minx, imgs[i].width),
|
|
- miny = MAX(miny, imgs[i].height);
|
|
-
|
|
- minarea = realMinarea * qfactor / 100;
|
|
- } else {
|
|
- minarea = INT_MAX - 1;
|
|
- }
|
|
+ if (quality > 1)
|
|
+ {
|
|
+ for (minarea = i = 0; i < n; ++i)
|
|
+ minarea += imgs[i].height * imgs[i].width,
|
|
+ minx = imax(minx, imgs[i].width),
|
|
+ miny = imax(miny, imgs[i].height);
|
|
|
|
- /* It's relatively easy to show that, if all the images
|
|
- * are multiples of a particular size, then a best
|
|
- * packing will always align the images on a grid of
|
|
- * that size.
|
|
- *
|
|
- * This speeds computation immensely.
|
|
- */
|
|
- for (rdiv = imgs[0].height, i = 1; i < n; ++i)
|
|
- rdiv = gcd(imgs[i].height, rdiv);
|
|
-
|
|
- for (cdiv = imgs[0].width, i = 1; i < n; ++i)
|
|
- cdiv = gcd(imgs[i].width, cdiv);
|
|
-
|
|
- MALLOCARRAY(current, n);
|
|
-
|
|
- for (i = 0; i < n; ++i) {
|
|
- current[i].size.x = imgs[i].width;
|
|
- current[i].size.y = imgs[i].height;
|
|
- }
|
|
- recursefindpack(current, c, coords, minarea, &z, 0, n, cdiv, rdiv,
|
|
- quality, qfactor);
|
|
+ minarea = minarea * qfactor / 100;
|
|
+ }
|
|
+ else
|
|
+ {
|
|
+ minarea = INT_MAX - 1;
|
|
+ }
|
|
+
|
|
+ /* It's relatively easy to show that, if all the images
|
|
+ * are multiples of a particular size, then a best
|
|
+ * packing will always align the images on a grid of
|
|
+ * that size.
|
|
+ *
|
|
+ * This speeds computation immensely.
|
|
+ */
|
|
+ for (rdiv = imgs[0].height, i = 1; i < n; ++i)
|
|
+ rdiv = gcd(imgs[i].height, rdiv);
|
|
+
|
|
+ for (cdiv = imgs[0].width, i = 1; i < n; ++i)
|
|
+ cdiv = gcd(imgs[i].width, cdiv);
|
|
+
|
|
+ MALLOCARRAY(current, n);
|
|
+ MALLOCARRAY(set, n);
|
|
+ for (i = 0; i < n; ++i)
|
|
+ set[i].x = imgs[i].width,
|
|
+ set[i].y = imgs[i].height;
|
|
+ recursefindpack(current, c, set, coords, minarea, &z, 0, n, cdiv, rdiv);
|
|
}
|
|
|
|
|
|
@@ -396,264 +237,204 @@ writePam(struct pam * const outpam
|
|
|
|
|
|
|
|
-static void
|
|
-writeData(FILE * const dataFileP,
|
|
- unsigned int const width,
|
|
- unsigned int const height,
|
|
- unsigned int const nfiles,
|
|
- const char ** const names,
|
|
- const coord * const coords,
|
|
- const struct pam * const imgs) {
|
|
-
|
|
- unsigned int i;
|
|
-
|
|
- fprintf(dataFileP, ":0:0:%u:%u\n", width, height);
|
|
-
|
|
- for (i = 0; i < nfiles; ++i) {
|
|
- fprintf(dataFileP, "%s:%u:%u:%u:%u\n", names[i], coords[i].x,
|
|
- coords[i].y, imgs[i].width, imgs[i].height);
|
|
- }
|
|
-}
|
|
-
|
|
-
|
|
-
|
|
-static void
|
|
-writeHeader(FILE * const headerFileP,
|
|
- const char * const prefix,
|
|
- unsigned int const width,
|
|
- unsigned int const height,
|
|
- unsigned int const nfiles,
|
|
- const char ** const names,
|
|
- const coord * const coords,
|
|
- const struct pam * imgs) {
|
|
-
|
|
- unsigned int i;
|
|
-
|
|
- fprintf(headerFileP, "#define %sOVERALLX %u\n", prefix, width);
|
|
-
|
|
- fprintf(headerFileP, "#define %sOVERALLY %u\n", prefix, height);
|
|
-
|
|
- fprintf(headerFileP, "\n");
|
|
-
|
|
- for (i = 0; i < nfiles; ++i) {
|
|
- char * const buffer = strdup(names[i]);
|
|
- coord const coord = coords[i];
|
|
- struct pam const img = imgs[i];
|
|
-
|
|
- unsigned int j;
|
|
-
|
|
- *strchr(buffer, '.') = 0;
|
|
- for (j = 0; buffer[j]; ++j) {
|
|
- if (ISLOWER(buffer[j]))
|
|
- buffer[j] = TOUPPER(buffer[j]);
|
|
- }
|
|
- fprintf(headerFileP, "#define %s%sX %u\n",
|
|
- prefix, buffer, coord.x);
|
|
-
|
|
- fprintf(headerFileP, "#define %s%sY %u\n",
|
|
- prefix, buffer, coord.y);
|
|
-
|
|
- fprintf(headerFileP, "#define %s%sSZX %u\n",
|
|
- prefix, buffer, img.width);
|
|
-
|
|
- fprintf(headerFileP, "#define %s%sSZY %u\n",
|
|
- prefix, buffer, img.height);
|
|
-
|
|
- fprintf(headerFileP, "\n");
|
|
- }
|
|
-}
|
|
+int
|
|
+main(int argc, char **argv)
|
|
+{
|
|
+ struct pam *imgs;
|
|
+ struct pam outimg;
|
|
+ struct pam p;
|
|
+ int nfiles;
|
|
+ int i, j;
|
|
+ unsigned int q[10];
|
|
+ coord *coords;
|
|
+ const char *headfname = NULL;
|
|
+ const char *datafname = NULL;
|
|
+ const char *prefix = "";
|
|
+ FILE *header;
|
|
+ FILE *data;
|
|
+ char **names;
|
|
+ char *c;
|
|
+
|
|
+ optEntry *option_def = malloc(100*sizeof(optEntry));
|
|
+ /* Instructions to OptParseOptions3 on how to parse our options.
|
|
+ */
|
|
+ optStruct3 opt;
|
|
+
|
|
+ unsigned int option_def_index;
|
|
+
|
|
+ option_def_index = 0; /* incremented by OPTENTRY */
|
|
+ OPTENT3( 0, "data", OPT_STRING, &datafname, NULL, 0);
|
|
+ OPTENT3( 0, "header", OPT_STRING, &headfname, NULL, 0);
|
|
+ OPTENT3('q', "quality", OPT_UINT, &qfactor, NULL, 0);
|
|
+ OPTENT3('p', "prefix", OPT_STRING, &prefix, NULL, 0);
|
|
+ OPTENT3('0', "0", OPT_FLAG, NULL, &q[0], 0);
|
|
+ OPTENT3('1', "1", OPT_FLAG, NULL, &q[1], 0);
|
|
+ OPTENT3('2', "2", OPT_FLAG, NULL, &q[2], 0);
|
|
+ OPTENT3('3', "3", OPT_FLAG, NULL, &q[3], 0);
|
|
+ OPTENT3('4', "4", OPT_FLAG, NULL, &q[4], 0);
|
|
+ OPTENT3('5', "5", OPT_FLAG, NULL, &q[5], 0);
|
|
+ OPTENT3('6', "6", OPT_FLAG, NULL, &q[6], 0);
|
|
+ OPTENT3('7', "7", OPT_FLAG, NULL, &q[7], 0);
|
|
+ OPTENT3('8', "8", OPT_FLAG, NULL, &q[8], 0);
|
|
+ OPTENT3('9', "9", OPT_FLAG, NULL, &q[9], 0);
|
|
+
|
|
+ opt.opt_table = option_def;
|
|
+ opt.short_allowed = FALSE;
|
|
+ opt.allowNegNum = FALSE;
|
|
+
|
|
+ pnm_init(&argc, argv);
|
|
+
|
|
+ /* Check for flags. */
|
|
+ optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
|
|
|
|
+ if (headfname)
|
|
+ header = pm_openw(headfname);
|
|
|
|
+ if (datafname)
|
|
+ data = pm_openw(datafname);
|
|
|
|
-static void
|
|
-sortImagesByArea(unsigned int const nfiles,
|
|
- struct pam * const imgs,
|
|
- const char ** const names) {
|
|
-/*----------------------------------------------------------------------------
|
|
- Sort the images described by 'imgs' and 'names' in place, from largest
|
|
- area to smallest.
|
|
------------------------------------------------------------------------------*/
|
|
- /* Bubble sort */
|
|
-
|
|
- unsigned int i;
|
|
-
|
|
- for (i = 0; i < nfiles - 1; ++i) {
|
|
- unsigned int j;
|
|
- for (j = i + 1; j < nfiles; ++j) {
|
|
- if (imgs[j].width * imgs[j].height >
|
|
- imgs[i].width * imgs[i].height) {
|
|
-
|
|
- struct pam p;
|
|
- const char * c;
|
|
-
|
|
- p = imgs[i]; imgs[i] = imgs[j]; imgs[j] = p;
|
|
- c = names[i]; names[i] = names[j]; names[j] = c;
|
|
- }
|
|
- }
|
|
+ for (i = 0; i < 10; ++i)
|
|
+ {
|
|
+ if (q[i])
|
|
+ {
|
|
+ quality = i;
|
|
+ switch (quality)
|
|
+ {
|
|
+ case 0: case 1: break;
|
|
+ case 2: case 3: case 4: case 5: case 6:
|
|
+ qfactor = 100 * (8 - quality);
|
|
+ break;
|
|
+ case 7: qfactor = 150; break;
|
|
+ case 8: qfactor = 125; break;
|
|
+ case 9: qfactor = 100; break;
|
|
+ }
|
|
}
|
|
-}
|
|
-
|
|
+ }
|
|
|
|
+ if (1 < argc)
|
|
+ nfiles = argc - 1;
|
|
+ else
|
|
+ nfiles = 1;
|
|
+
|
|
+ MALLOCARRAY(imgs, nfiles);
|
|
+ MALLOCARRAY(coords, nfiles);
|
|
+ MALLOCARRAY(names, nfiles);
|
|
+
|
|
+ if (!imgs || !coords || !names)
|
|
+ pm_error("out of memory");
|
|
|
|
-static void
|
|
-computeOutputType(sample * const maxvalP,
|
|
- int * const formatP,
|
|
- char * const tupleTypeP,
|
|
- unsigned int * const depthP,
|
|
- unsigned int const nfiles,
|
|
- const struct pam * const imgs) {
|
|
-
|
|
- unsigned int i;
|
|
-
|
|
- sample maxval;
|
|
- int format;
|
|
- const char * tupleType;
|
|
- unsigned int depth;
|
|
-
|
|
- assert(nfiles > 0);
|
|
-
|
|
- /* initial guesses */
|
|
- maxval = imgs[0].maxval;
|
|
- format = imgs[0].format;
|
|
- depth = imgs[0].depth;
|
|
- tupleType = imgs[0].tuple_type;
|
|
-
|
|
- for (i = 1; i < nfiles; ++i) {
|
|
- if (PAM_FORMAT_TYPE(imgs[i].format) > PAM_FORMAT_TYPE(format)) {
|
|
- format = imgs[i].format;
|
|
- tupleType = imgs[i].tuple_type;
|
|
- }
|
|
- maxval = MAX(maxval, imgs[i].maxval);
|
|
- depth = MAX(depth, imgs[i].depth);
|
|
+ if (1 < argc)
|
|
+ {
|
|
+ for (i = 0; i < nfiles; ++i)
|
|
+ {
|
|
+ if (strchr(argv[i+1], ':'))
|
|
+ {
|
|
+ imgs[i].file = pm_openr(strchr(argv[i+1], ':') + 1);
|
|
+ *strchr(argv[i+1], ':') = 0;
|
|
+ names[i] = argv[i+1];
|
|
+ }
|
|
+ else
|
|
+ {
|
|
+ imgs[i].file = pm_openr(argv[i+1]);
|
|
+ names[i] = argv[i+1];
|
|
+ }
|
|
}
|
|
+ }
|
|
+ else
|
|
+ {
|
|
+ imgs[0].file = stdin;
|
|
+ }
|
|
|
|
- *maxvalP = maxval;
|
|
- *formatP = format;
|
|
- *depthP = depth;
|
|
- memcpy(tupleTypeP, tupleType, sizeof(imgs[0].tuple_type));
|
|
-}
|
|
+ pnm_readpaminit(imgs[0].file, &imgs[0], PAM_STRUCT_SIZE(tuple_type));
|
|
+ memset(&outimg, 0, sizeof(outimg));
|
|
+ outimg.maxval = imgs[0].maxval;
|
|
+ outimg.format = imgs[0].format;
|
|
+ memcpy(outimg.tuple_type, imgs[0].tuple_type, sizeof(imgs[0].tuple_type));
|
|
+ outimg.depth = imgs[0].depth;
|
|
|
|
+ for (i = 1; i < nfiles; ++i)
|
|
+ {
|
|
+ pnm_readpaminit(imgs[i].file, &imgs[i], PAM_STRUCT_SIZE(tuple_type));
|
|
+ if (PAM_FORMAT_TYPE(imgs[i].format) > PAM_FORMAT_TYPE(outimg.format))
|
|
+ outimg.format = imgs[i].format,
|
|
+ memcpy(outimg.tuple_type, imgs[i].tuple_type,
|
|
+ sizeof(imgs[i].tuple_type));
|
|
+ outimg.maxval = imax(imgs[i].maxval, outimg.maxval);
|
|
+ outimg.depth = imax(imgs[i].depth, outimg.depth);
|
|
+ }
|
|
|
|
+ for (i = 0; i < nfiles - 1; ++i)
|
|
+ for (j = i + 1; j < nfiles; ++j)
|
|
+ if (imgs[j].width * imgs[j].height > imgs[i].width * imgs[i].height)
|
|
+ p = imgs[i], imgs[i] = imgs[j], imgs[j] = p,
|
|
+ c = names[i], names[i] = names[j], names[j] = c;
|
|
|
|
-static void
|
|
-computeOutputDimensions(int * const widthP,
|
|
- int * const heightP,
|
|
- unsigned int const nfiles,
|
|
- const struct pam * const imgs,
|
|
- const coord * const coords) {
|
|
-
|
|
- unsigned int widthGuess, heightGuess;
|
|
- unsigned int i;
|
|
-
|
|
- widthGuess = 0; /* initial value */
|
|
- heightGuess = 0; /* initial value */
|
|
-
|
|
- for (i = 0; i < nfiles; ++i) {
|
|
- widthGuess = MAX(widthGuess, imgs[i].width + coords[i].x);
|
|
- heightGuess = MAX(heightGuess, imgs[i].height + coords[i].y);
|
|
- }
|
|
+ findpack(imgs, nfiles, coords);
|
|
|
|
- *widthP = widthGuess;
|
|
- *heightP = heightGuess;
|
|
-}
|
|
+ outimg.height = outimg.width = 0;
|
|
+ for (i = 0; i < nfiles; ++i)
|
|
+ {
|
|
+ outimg.width = imax(outimg.width, imgs[i].width + coords[i].x);
|
|
+ outimg.height = imax(outimg.height, imgs[i].height + coords[i].y);
|
|
+ }
|
|
|
|
+ outimg.size = sizeof(outimg);
|
|
+ outimg.len = sizeof(outimg);
|
|
+ outimg.file = stdout;
|
|
+ outimg.bytes_per_sample = 0;
|
|
+ for (i = outimg.maxval; i; i >>= 8)
|
|
+ ++outimg.bytes_per_sample;
|
|
|
|
+ writePam(&outimg, nfiles, coords, imgs);
|
|
|
|
-int
|
|
-main(int argc, const char **argv) {
|
|
+ if (datafname)
|
|
+ {
|
|
+ fprintf(data, ":0:0:%u:%u\n", outimg.width, outimg.height);
|
|
|
|
- struct cmdlineInfo cmdline;
|
|
- struct pam * imgs;
|
|
- struct pam outimg;
|
|
- unsigned int nfiles;
|
|
- coord * coords;
|
|
- FILE * header;
|
|
- FILE * data;
|
|
- const char ** names;
|
|
- unsigned int i;
|
|
- unsigned int qfactor; /* In per cent */
|
|
-
|
|
- pm_proginit(&argc, argv);
|
|
-
|
|
- parseCommandLine(argc, argv, &cmdline);
|
|
-
|
|
- header = cmdline.header ? pm_openw(cmdline.header) : NULL;
|
|
- data = cmdline.data ? pm_openw(cmdline.data) : NULL;
|
|
-
|
|
- switch (cmdline.quality2) {
|
|
- case 0: case 1:
|
|
- qfactor = cmdline.quality;
|
|
- break;
|
|
- case 2: case 3: case 4: case 5: case 6:
|
|
- qfactor = 100 * (8 - cmdline.quality2);
|
|
- break;
|
|
- case 7: qfactor = 150; break;
|
|
- case 8: qfactor = 125; break;
|
|
- case 9: qfactor = 100; break;
|
|
- default: pm_error("Internal error - impossible value of 'quality2': %u",
|
|
- cmdline.quality2);
|
|
+ for (i = 0; i < nfiles; ++i)
|
|
+ {
|
|
+ fprintf(data, "%s:%u:%u:%u:%u\n", names[i], coords[i].x,
|
|
+ coords[i].y, imgs[i].width, imgs[i].height);
|
|
}
|
|
+ }
|
|
|
|
- nfiles = cmdline.nFiles > 0 ? cmdline.nFiles : 1;
|
|
-
|
|
- MALLOCARRAY(imgs, nfiles);
|
|
- MALLOCARRAY(coords, nfiles);
|
|
- MALLOCARRAY(names, nfiles);
|
|
-
|
|
- if (!imgs || !coords || !names)
|
|
- pm_error("out of memory");
|
|
-
|
|
- if (cmdline.nFiles > 0) {
|
|
- unsigned int i;
|
|
-
|
|
- for (i = 0; i < cmdline.nFiles; ++i) {
|
|
- imgs[i].file = pm_openr(cmdline.inFileName[i]);
|
|
- names[i] = strdup(cmdline.inFileName[i]);
|
|
- }
|
|
- } else {
|
|
- imgs[0].file = stdin;
|
|
- names[0] = strdup("stdin");
|
|
- }
|
|
+ if (headfname)
|
|
+ {
|
|
+ fprintf(header, "#define %sOVERALLX %u\n"
|
|
+ "#define %sOVERALLY %u\n"
|
|
+ "\n",
|
|
+ prefix, outimg.width,
|
|
+ prefix, outimg.height);
|
|
|
|
for (i = 0; i < nfiles; ++i)
|
|
- pnm_readpaminit(imgs[i].file, &imgs[i], PAM_STRUCT_SIZE(tuple_type));
|
|
-
|
|
- sortImagesByArea(nfiles, imgs, names);
|
|
-
|
|
- findpack(imgs, nfiles, coords, cmdline.quality2, qfactor);
|
|
-
|
|
- computeOutputType(&outimg.maxval, &outimg.format, outimg.tuple_type,
|
|
- &outimg.depth, nfiles, imgs);
|
|
-
|
|
- computeOutputDimensions(&outimg.width, &outimg.height, nfiles,
|
|
- imgs, coords);
|
|
-
|
|
- pnm_setminallocationdepth(&outimg, outimg.depth);
|
|
-
|
|
- outimg.size = sizeof(outimg);
|
|
- outimg.len = sizeof(outimg);
|
|
- outimg.file = stdout;
|
|
- outimg.bytes_per_sample = 0;
|
|
- for (i = outimg.maxval; i; i >>= 8)
|
|
- ++outimg.bytes_per_sample;
|
|
-
|
|
- writePam(&outimg, nfiles, coords, imgs);
|
|
+ {
|
|
+ *strchr(names[i], '.') = 0;
|
|
+ for (j = 0; names[i][j]; ++j)
|
|
+ {
|
|
+ if (ISLOWER(names[i][j]))
|
|
+ names[i][j] = TOUPPER(names[i][j]);
|
|
+ }
|
|
+ fprintf(header, "#define %s%sX %u\n"
|
|
+ "#define %s%sY %u\n"
|
|
+ "#define %s%sSZX %u\n"
|
|
+ "#define %s%sSZY %u\n"
|
|
+ "\n",
|
|
+ prefix, names[i], coords[i].x,
|
|
+ prefix, names[i], coords[i].y,
|
|
+ prefix, names[i], imgs[i].width,
|
|
+ prefix, names[i], imgs[i].height);
|
|
+ }
|
|
+ }
|
|
|
|
- if (data)
|
|
- writeData(data, outimg.width, outimg.height,
|
|
- nfiles, names, coords, imgs);
|
|
+ for (i = 0; i < nfiles; ++i)
|
|
+ pm_close(imgs[i].file);
|
|
+ pm_close(stdout);
|
|
|
|
- if (header)
|
|
- writeHeader(header, cmdline.prefix, outimg.width, outimg.height,
|
|
- nfiles, names, coords, imgs);
|
|
+ if (headfname)
|
|
+ pm_close(header);
|
|
|
|
- for (i = 0; i < nfiles; ++i)
|
|
- pm_close(imgs[i].file);
|
|
- pm_close(stdout);
|
|
- if (header)
|
|
- pm_close(header);
|
|
- if (data)
|
|
- pm_close(data);
|
|
+ if (datafname)
|
|
+ pm_close(data);
|
|
|
|
- return 0;
|
|
+ return 0;
|
|
}
|