int
main(int argc, char **argv) {
int n, optstop = 0;
char *fname = NULL;
pbm_init(&argc, argv);
/* Parse options */
for (n = 1; n < argc; ++n) {
if (argv[n][0] == '-' && !optstop) {
if (argv[n][1] == 'a' || argv[n][1] == 'A') bAscii = 1;
if (argv[n][1] == 'd' || argv[n][1] == 'D') bScale = 1;
if (argv[n][1] == 'i' || argv[n][1] == 'I') bInvert = 1;
if (argv[n][1] == 'h' || argv[n][1] == 'H') usage(argv[0]);
if (argv[n][1] == '-' && argv[n][2] == 0 && !fname) {
/* "--" */
optstop = 1;
}
if (argv[n][1] == '-' && (argv[n][2] == 'h' || argv[n][2] == 'H'))
usage(argv[0]);
}
else if (argv[n][0] && !fname) {
/* Filename */
fname = argv[n];
}
}
if (fname)
infile = pm_openr(fname);
else
infile = stdin;
/* Read MDA file header */
if (fread(header, 1, 128, infile) < 128)
pm_error("Not a .MDA file\n");
if (strncmp((char*) header, ".MDA", 4) &&
strncmp((char*) header, ".MDP", 4))
pm_error("Not a .MDA file\n");
{
short yy;
pm_readlittleshort(infile, &yy); nInRows = yy;
pm_readlittleshort(infile, &yy); nInCols = yy;
}
overflow2(nOutCols, 8);
nOutCols = 8 * nInCols;
nOutRows = nInRows;
if (bScale) {
overflow2(nOutRows, 2);
nOutRows *= 2;
}
data = pbm_allocarray(nOutCols, nOutRows);
MALLOCARRAY_NOFAIL(mdrow, nInCols);
if (header[21] == '0')
md2_trans();
else
md3_trans();
pbm_writepbm(stdout, data, nInCols*8, nOutRows, bAscii);
if (infile != stdin)
pm_close(infile);
fflush(stdout);
pbm_freearray(data, nOutRows);
free(mdrow);
return 0;
}
int
main(int argc, const char *argv[]) {
struct cmdlineInfo cmdline;
bit ** bits;
unsigned int rows, cols;
struct font * fontP;
unsigned int vmargin, hmargin;
struct text inputText;
struct text formattedText;
int maxleftb;
pm_proginit(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
computeFont(cmdline, &fontP);
getText(cmdline.text, fontP, &inputText);
if (cmdline.nomargins) {
vmargin = 0;
hmargin = 0;
} else {
if (inputText.lineCount == 1) {
vmargin = fontP->maxheight / 2;
hmargin = fontP->maxwidth;
} else {
vmargin = fontP->maxheight;
hmargin = 2 * fontP->maxwidth;
}
}
if (cmdline.width > 0) {
if (cmdline.width > INT_MAX -10)
pm_error("-width value too large: %u", cmdline.width);
/* Flow or truncate lines to meet user's width request */
if (inputText.lineCount == 1)
flowText(inputText, cmdline.width, fontP, cmdline.space,
&formattedText);
else
truncateText(inputText, cmdline.width, fontP, cmdline.space,
&formattedText);
freeTextArray(inputText);
} else
formattedText = inputText;
if (formattedText.lineCount == 0)
pm_error("No input text.");
computeImageHeight(formattedText, fontP, cmdline.lspace, vmargin,
&rows);
computeImageWidth(formattedText, fontP, cmdline.space, hmargin,
&cols, &maxleftb);
if (cols == 0 || rows == 0)
pm_error("Input is all whitespace and/or non-renderable characters.");
bits = pbm_allocarray(cols, rows);
/* Fill background with white */
fill_rect(bits, 0, 0, rows, cols, PBM_WHITE);
/* Put the text in */
insert_characters(bits, formattedText, fontP, vmargin, hmargin + maxleftb,
cmdline.space, cmdline.lspace);
pbm_writepbm(stdout, bits, cols, rows, 0);
pbm_freearray(bits, rows);
freeTextArray(formattedText);
pm_close(stdout);
return 0;
}
static void
pgmHist(FILE * const ifP,
int const cols,
int const rows,
xelval const maxval,
int const format,
bool const dots,
bool const no_white,
bool const no_black,
bool const verbose,
xelval const startval,
xelval const endval,
unsigned int const histWidth,
unsigned int const histHeight,
bool const clipSpec,
unsigned int const clipCount) {
gray * grayrow;
bit ** bits;
int i, j;
unsigned int * ghist;
double vscale;
unsigned int hmax;
MALLOCARRAY(ghist, histWidth);
if (ghist == NULL)
pm_error("Not enough memory for histogram array (%u bytes)",
histWidth * (unsigned)sizeof(int));
bits = pbm_allocarray(histWidth, histHeight);
if (bits == NULL)
pm_error("no space for output array (%u bits)",
histWidth * histHeight);
memset(ghist, 0, histWidth * sizeof(ghist[0]));
/* read the pixel values into the histogram arrays */
grayrow = pgm_allocrow(cols);
if (verbose)
pm_message("making histogram...");
for (i = rows; i > 0; --i) {
pgm_readpgmrow (ifP, grayrow, cols, maxval, format);
for (j = cols-1; j >= 0; --j)
countComp(grayrow[j], startval, endval, histWidth, ghist);
}
pgm_freerow(grayrow);
/* find the highest-valued slot and set the vertical scale value */
if (verbose)
pm_message("finding max. slot height...");
if (clipSpec)
hmax = clipCount;
else
hmax = maxSlotCount(ghist, histWidth, no_white, no_black);
assert(hmax > 0);
if (verbose)
pm_message("Done: height = %u", hmax);
clipHistogram(ghist, histWidth, hmax);
vscale = (double) histHeight / hmax;
for (i = 0; i < histWidth; ++i) {
int mark = histHeight - (int)(vscale * ghist[i]);
for (j = 0; j < mark; ++j)
bits[j][i] = PBM_BLACK;
if (j < histHeight)
bits[j++][i] = PBM_WHITE;
for ( ; j < histHeight; ++j)
bits[j][i] = dots ? PBM_BLACK : PBM_WHITE;
}
pbm_writepbm(stdout, bits, histWidth, histHeight, 0);
}
/** Generate a mask image (pbm) */
QString GeoImage::mask(float west, float north, float east, float south,
int id, QString prefixDir, QString fname)
{
#define GenMaskBlockStorage(T) \
{ \
T* iptr; \
bit *optr; \
int x,y; \
for (y = 0; y < dy; y++) { \
if (y<-ry1 || y>=rows_-ry1) iptr=0; \
else iptr = ((T*)data_p)+(y + ry1)*cols_+rx1; \
optr = dat_b_out[y]; \
for (x = 0; x < dx; x++) { \
if (!iptr || x<-rx1 || x>=cols_-rx1) *optr=0; \
else *optr=(*iptr==(T)id?1:0); \
optr ++; \
if (iptr) iptr ++; \
} \
} \
}
#define GenMaskRowStorage(T) \
{ \
T* iptr; \
bit *optr; \
int x,y; \
for (y = 0; y < dy; y++) { \
if (y<-ry1 || y>=rows_-ry1) iptr=0; \
else iptr = (((T**)data_p)[y + ry1]) + rx1; \
optr = dat_b_out[y]; \
for (x = 0; x < dx; x++) { \
if (!iptr || x<-rx1 || x>=cols_-rx1) *optr=0; \
else *optr=(*iptr==(T)id?1:0); \
optr ++; \
if (iptr) iptr ++; \
} \
} \
}
if (fname.isEmpty()) { //create output filname
Q_ASSERT(contains("key"));
QString dir = CleanUp::mkdir(CleanUp::getTmpDirPID(), prefixDir);
fname.sprintf("%s/%f_%f_%f_%f.pbm",
dir.toLatin1().constData(),
west, north, east, south);
}
qDebug("# GeoImage::mask %s (%f, %f, %f, %f)", fname.toLatin1().constData(),
west, north, east, south);
QFile f(fname);
if (f.exists())
return fname;
const void *data_p = data(); //get pointer to data
Q_ASSERT(data_p);
if (type_ == UNKNOWN)
return 0;
int dx, dy, rx1, ry1, rx2, ry2;
picBBox(west, north, east, south, rx1, ry2, rx2, ry1);
dx = rx2 - rx1 + 1;
dy = ry2 - ry1 + 1;
if (dx <= 0 || dy <= 0)
qDebug("# (ERROR) GeoImage::part: (dx=%d=%d-%d || dy=%d=%d-%d)", dx, rx2,
rx1, dy, ry2, ry1);
FILE *of = fopen(fname.toLatin1().constData(), "w");
if (!of) {
fprintf(stderr, "# (ERROR) Can't open file %s for writing!\n",
fname.toLatin1().constData());
return "";
}
bit **dat_b_out = pbm_allocarray(dx, dy);
switch (type_) {
case PFM_FLOAT:
GenMaskBlockStorage(float);
break;
case PFM_UINT:
GenMaskBlockStorage(unsigned int);
break;
case PFM_SINT:
GenMaskBlockStorage(signed int);
break;
case PFM_UINT16:
GenMaskBlockStorage(unsigned short);
break;
case PFM_SINT16:
GenMaskBlockStorage(signed short);
break;
case PBM:{
bit *iptr;
bit *optr;
int x, y;
for (y = 0; y < dy; y++) {
iptr = (((bit **) data_p)[y + ry1]) + rx1;
optr = dat_b_out[y];
for (x = 0; x < dx; x++) {
*optr = (*iptr == (bit) id ? 1 : 0);
optr++;
iptr++;
}
}
}
// GenMaskRowStorage(bit);
break;
case PFM_BYTE:
GenMaskBlockStorage(unsigned char);
break;
default:
pbm_freearray(dat_b_out, dy);
fclose(of);
return "";
break;
}
pbm_writepbm(of, (bit **) dat_b_out, dx, dy, 0);
pbm_freearray(dat_b_out, dy);
fclose(of);
return fname;
#undef GenMaskBlockStorage
#undef GenMaskRowStorage
}
/** write a scrap of the data,
* return the filename,
* if the file exist do nothing
* argument fname is optional
* the coordinates of the image part are geodata e.g. Gauss Krueger **/
QString
GeoImage::part(float west, float north, float east, float south,
QString fname)
{
if (fname.isEmpty()) { //create output filname
Q_ASSERT(contains("key"));
QString dir = CleanUp::getTmpDir();
fname.sprintf("%s/%s_%f_%f_%f_%f",
dir.toLatin1().constData(),
value("key").toLatin1().constData(),
west, north, east, south);
}
qDebug("# GeoImage::part %s (%f, %f, %f, %f)",
fname.toLatin1().constData(), west,
north, east, south);
QFile f(fname);
if (f.exists())
return fname;
const void *data_p = data(); //get pointer to data
Q_ASSERT(data_p);
if (type_ == UNKNOWN)
return 0;
int dx, dy, i, j, rx1, ry1, rx2, ry2;
picBBox(west, north, east, south, rx1, ry2, rx2, ry1);
dx = rx2 - rx1 + 1;
dy = ry2 - ry1 + 1;
if (dx <= 0 || dy <= 0) {
qDebug("# (ERROR) GeoImage::part: (dx=%d=%d-%d || dy=%d=%d-%d)", dx, rx2,
rx1, dy, ry2, ry1);
throw ImageException(rx1,rx2,dx,ry1,ry2,dy);
}
FILE *of = fopen(fname.toLatin1().constData(), "w");
if (!of) {
throw FileIOException(FileIOException::OPEN_FAILED,fname);
}
switch (type_) {
case PBM:{
bit *bpi, *bpo, **dat_b_out = pbm_allocarray(dx, dy);
bit **dat_b = (bit **) data_p;
for (i = 0; i < dy; i++) {
bpi = dat_b[i + ry1] + rx1;
bpo = dat_b_out[i];
for (j = 0; j < dx; j++) {
*bpo = *bpi;
bpo++;
bpi++;
}
}
pbm_writepbm(of, (bit **) dat_b_out, dx, dy, 0);
pbm_freearray(dat_b_out, dy);
}
break;
case PGM:{
gray *gpi, *gpo, **dat_g_out = pgm_allocarray(dx, dy);
gray **dat_g = (gray **) data_p;
gray maxval = 0;
for (i = 0; i < dy; i++) {
gpi = dat_g[i + ry1] + rx1;
gpo = dat_g_out[i];
for (j = 0; j < dx; j++) {
*gpo = *gpi;
if (*gpi > maxval)
maxval = *gpi;
gpo++;
gpi++;
}
}
pgm_writepgm(of, (gray **) dat_g_out, dx, dy, maxval, 0);
pgm_freearray(dat_g_out, dy);
}
break;
case PPM:{
pixel *ppi, *ppo, **dat_p_out = ppm_allocarray(dx, dy);
pixel **dat_p = (pixel **) data_p;
pixval maxval = 255; //! should be calculated
for (i = 0; i < dy; i++) {
ppi = dat_p[i + ry1] + rx1;
ppo = dat_p_out[i];
for (j = 0; j < dx; j++) {
*ppo = *ppi;
ppo++;
ppi++;
}
}
ppm_writeppm(of, (pixel **) dat_p_out, dx, dy, maxval, 0);
ppm_freearray(dat_p_out, dy);
}
break;
default:
pfm_geo_set(geoWest(),geoNorth(),geoEast(),geoSouth());
pfm_writepfm_region_type(of, data_, cols_, rows_, minval_, maxval_,
rx1, ry1, rx2, ry2, type_);
break;
}
fclose(of);
return fname;
}
/** Generate a mask image (pbm) */
QString GeoImage::mask(float west, float north, float east, float south,
int id, QString prefixDir, QString fname)
{
#define GenMaskBlockStorage(T) \
{ \
T* iptr; \
bit *optr; \
int x,y; \
for (y = 0; y < dy; y++) { \
if (y<-ry1 || y>=rows_-ry1) iptr=0; \
else iptr = ((T*)data_p)+(y + ry1)*cols_+rx1; \
optr = dat_b_out[y]; \
for (x = 0; x < dx; x++) { \
if (!iptr || x<-rx1 || x>=cols_-rx1) *optr=0; \
else *optr=(*iptr==(T)id?1:0); \
optr ++; \
if (iptr) iptr ++; \
} \
} \
}
#define GenMaskRowStorage(T) \
{ \
T* iptr; \
bit *optr; \
int x,y; \
for (y = 0; y < dy; y++) { \
if (y<-ry1 || y>=rows_-ry1) iptr=0; \
else iptr = (((T**)data_p)[y + ry1]) + rx1; \
optr = dat_b_out[y]; \
for (x = 0; x < dx; x++) { \
if (!iptr || x<-rx1 || x>=cols_-rx1) *optr=0; \
else *optr=(*iptr==(T)id?1:0); \
optr ++; \
if (iptr) iptr ++; \
} \
} \
}
if (fname.isEmpty()) { //create output filname
Q_ASSERT(contains("key"));
QString dir = CleanUp::mkdir(CleanUp::getTmpDirPID(), prefixDir);
fname.sprintf("%s/%f_%f_%f_%f.pbm",
dir.toLatin1().constData(),
west, north, east, south);
qDebug("GeoImage::mask: create output filename %s",fname.toLatin1().constData());
}
qDebug("# GeoImage::mask %s (%f, %f, %f, %f)", fname.toLatin1().constData(),
west, north, east, south);
QFile f(fname);
if (f.exists()) {
qDebug("mask %s already exists",fname.toLatin1().constData());
return fname;
}
const void *data_p = data(); //get pointer to data
Q_ASSERT(data_p);
if (type_ == UNKNOWN)
throw ImageException(ImageException::UnknownType, filename(),
__FILE__":GeoImage::mask", __LINE__);
int dx, dy, rx1, ry1, rx2, ry2;
picBBox(west, north, east, south, rx1, ry2, rx2, ry1);
qDebug("GeoImage::mask: picBBox: (%f, %f, %f, %f) (rx1=%d, ry2=%d, rx2=%d, ry1=%d",
west, north, east, south, rx1, ry2, rx2, ry1);
dx = rx2 - rx1 + 1;
dy = ry2 - ry1 + 1;
if (dx <= 0 || dy <= 0) {
throw ImageException(ImageException::Dimension, rx1, rx2, dx, ry1, ry2, dy,
__FILE__":GeoImage::mask", __LINE__);
}
FILE *of = fopen(fname.toLatin1().constData(), "w");
if (!of) {
throw FileIOException(FileIOException::OPEN_FAILED, fname,
__FILE__":GeoImage::mask", __LINE__);
return "";
}
bit **dat_b_out = pbm_allocarray(dx, dy);
switch (type_) {
case PFM_FLOAT:
GenMaskBlockStorage(float);
break;
case PFM_UINT:
GenMaskBlockStorage(unsigned int);
break;
case PFM_SINT:
GenMaskBlockStorage(signed int);
break;
case PFM_UINT16:
GenMaskBlockStorage(unsigned short);
break;
case PFM_SINT16:
GenMaskBlockStorage(signed short);
break;
case PBM:{
bit *iptr;
bit *optr;
int x, y;
for (y = 0; y < dy; y++) {
iptr = (((bit **) data_p)[y + ry1]) + rx1;
optr = dat_b_out[y];
for (x = 0; x < dx; x++) {
*optr = (*iptr == (bit) id ? 1 : 0);
optr++;
iptr++;
}
}
}
// GenMaskRowStorage(bit);
break;
case PFM_BYTE:
GenMaskBlockStorage(unsigned char);
break;
default:
pbm_freearray(dat_b_out, dy);
fclose(of);
return "";
break;
}
pbm_writepbm(of, (bit **) dat_b_out, dx, dy, 0);
pbm_freearray(dat_b_out, dy);
fclose(of);
return fname;
#undef GenMaskBlockStorage
#undef GenMaskRowStorage
}