/*{{{ static void prtX360(int pno)*/
static void prtX360(int pno)
{
bit** bits;
bit* pr[24];
int row, v_sp;
int i;
v_sp = 0;
printf("\033U\001"); /* print unidirectional */
bits = pbm_allocarray(cols, 48);
for (row=0; row<rows; row+=48)
{
for(i=0; i<48 && row+i<rows; i++)
readpbmrow(fp, bits[i], cols, format);
while(i<48)
memset(bits[i++], PBM_WHITE, cols);
for(i=0; i<24; i++)
pr[i]=bits[2*i];
print24rows(pno, pr, &v_sp); /* even rows */
v_sp += 1; /* vertical space : 1/360 */
for(i=0; i<24; i++)
pr[i]=bits[2*i+1];
print24rows(pno, pr, &v_sp); /* odd rows */
v_sp += 47; /* vertical space : 47/360 */
}
putchar('\f');
}
/*{{{ static void epsX216(int pno)*/
static void epsX216(int pno)
{
bit** bits;
bit* pr[8];
int row, v_sp;
int i, j;
v_sp = 0; /* counter for vertical spacing */
bits = pbm_allocarray(cols, 24);
for (row=0; row<rows; row+=24)
{
for(i=0; i<24 && row+i<rows; i++)
readpbmrow(fp, bits[i], cols, format);
while(i<24)
memset(bits[i++], PBM_WHITE, cols); /* remaining rows set to 'white' */
for(j=0; j<3; j++)
{
for(i=0; i<8; i++)
pr[i]=bits[3*i+j];
print8rows(pno, pr, &v_sp);
v_sp += 1;
}
v_sp += 21;
}
putchar('\f');
}
/*{{{ static void prtX180(int pno)*/
static void prtX180(int pno)
{
bit** bits;
bit* pr[24]; /* Print Row */
int row, v_sp;
int i;
v_sp = 0;
printf("\033U\001"); /* print unidirectional */
bits = pbm_allocarray(cols, 24);
for (row=0; row<rows; row+=24)
{
for(i=0; i<24 && row+i<rows; i++)
readpbmrow(fp, bits[i], cols, format);
while(i<24)
memset(bits[i++], PBM_WHITE, cols);
for(i=0; i<24; i++) /* senseless ? yes ! */
pr[i]=bits[i];
print24rows(pno, pr, &v_sp);
v_sp += 24; /* vertical space : 24/180 */
}
putchar('\f');
}
/*{{{ static void epsX144(int pno)*/
static void epsX144(int pno)
{
bit** bits;
bit* pr[8];
int row, v_sp;
int i, j;
v_sp = 0; /* counter for vertical spacing */
bits = pbm_allocarray(cols, 16);
for (row=0; row<rows; row+=16)
{
for(i=0; i<16 && row+i<rows; i++)
readpbmrow(fp, bits[i], cols, format);
while(i<16)
memset(bits[i++], PBM_WHITE, cols);
for(j=0; j<2; j++)
{
for(i=0; i<8; i++)
pr[i]=bits[2*i+j];
print8rows(pno, pr, &v_sp);
v_sp += 1;
}
v_sp += 22;
}
putchar('\f');
}
/*{{{ static void epsX72(int pno)*/
static void epsX72(int pno)
{
bit** bits;
bit* pr[8]; /* Print Row */
int row, v_sp;
int i;
v_sp = 0;
bits = pbm_allocarray(cols, 8);
for (row=0; row<rows; row+=8)
{
for(i=0; i<8 && row+i<rows; i++)
readpbmrow(fp, bits[i], cols, format);
while(i<8)
memset(bits[i++], PBM_WHITE, cols);
for(i=0; i<8; i++) /* Not very useful in this case */
pr[i]=bits[i];
print8rows(pno, pr, &v_sp);
v_sp += 24;
}
putchar('\f');
}
int
main (int argc, char *args[])
{
int i, n, r, c, ch;
FILE *inf;
marklistptr library = NULL, list = NULL, step = NULL;
marklistptr symbol_list = NULL;
marktype d, d2;
Pixel **bitmap, **recon, **bitmapcopy;
char *splitfilename = NULL;
int cols, rows, count, librarysize, lossy = 1;
int quick = 0;
int ticencode = 0, ticdecode = 0, external = 0;
char *libraryname = NULL, *infile = NULL;
char *s1 = NULL, *s2 = NULL;
char bufferin[BUFSIZ], bufferout[BUFSIZ];
if (argc < 2)
usage ();
while ((ch = getopt (argc, args, "edlLQhvXR:")) != -1)
switch (ch)
{
case 'e':
ticencode = 1;
break;
case 'd':
ticdecode = 1;
break;
case 'l':
lossy = 1;
break;
case 'L':
lossy = 0;
break;
case 'Q':
quick = 1;
break;
case 'v':
V = 1;
break;
case 'X':
external = 1;
break;
case 'R':
splitfilename = optarg;
break;
case 'h':
case '?':
usage ();
}
for (i = 1; i < argc; i++)
if (args[i][0] != '-')
if (strcmp (args[i - 1], "-R"))
{ /* ignore arg following -R, ie. -R <filename> */
if (!s1)
s1 = args[i];
else if (!s2)
s2 = args[i];
else
error_msg (args[0], "too many filenames", "");
}
if (ticencode == ticdecode)
error_msg (args[0], "please specify either encode XOR decode", "");
if (ticencode)
{
/*****************
ENCODING STAGE
*****************/
long PrevBits = 0;
long BITS_header = 0, BITS_symbols = 0, BITS_offsets = 0, BITS_residue = 0,
BITS_footer = 0, BITS_library = 0;
libraryname = s1;
if (!libraryname)
error_msg (args[0], "please specify a library file", "");
infile = s2;
if (!infile)
error_msg (args[0], "please specify a file name", "");
inf = fopen (infile, "rb");
if (inf == NULL)
error_msg (args[0], "Trouble opening file:", infile);
setbuf (inf, bufferin);
count = librarysize = read_library (libraryname, &library);
if (V)
fprintf (stderr, "%s: processing...\n", args[0]);
if (pbm_isapbmfile (inf))
{
if (V)
fprintf (stderr, "reading file %s...\n", infile);
bitmap = pbm_readfile (inf, &cols, &rows);
fclose (inf);
bitmapcopy = pbm_copy (bitmap, cols, rows);
if (V)
fprintf (stderr, "extracting...");
ExtractAllMarks (bitmap, &list, cols, rows);
if (V)
fprintf (stderr, "(%d marks)\n", marklist_length (list));
/* sort into reading order */
if (V)
fprintf (stderr, "sorting...\n");
list = sortmarks (list);
pbm_freearray (&bitmap, rows); /* clear old version */
bitmap = bitmapcopy; /* point to the copy */
recon = pbm_allocarray (cols, rows);
if (V)
fprintf (stderr, "matching...");
match_sequence (list, library, &symbol_list, recon, quick);
PrevBits = 0;
setbuf (stdout, bufferout);
/* start output */
magic_write (stdout, MAGIC_TIC);
InitArithEncoding ();
EncodeGammaDist (1); /* version 1 of the program */
EncodeGammaDist (lossy); /* lossy=1 = no residue */
EncodeGammaDist (external); /* 1== external file */
count = marklist_length (symbol_list);
if (V)
fprintf (stderr, "encoding cols, rows, and number of symbols=%d\n", count);
EncodeGammaDist (cols);
EncodeGammaDist (rows);
EncodeGammaDist (count);
EncodeGammaDist (librarysize);
BITS_header = CountOfBitsOut - PrevBits;
PrevBits = CountOfBitsOut;
/* output the library sequence */
if (external == 0)
{
if (V)
fprintf (stderr, "encoding library\n");
bl_clearmodel ();
bl_writetemplate (library_template);
for (step = library; step; step = step->next)
bl_compress_mark (step->data);
bl_freemodel ();
BITS_library = CountOfBitsOut - PrevBits;
PrevBits = CountOfBitsOut;
}
/* output the symbol sequence */
if (V)
fprintf (stderr, "encoding symbol sequence\n");
InitPPM ();
EncodeSymbols (symbol_list, count);
BITS_symbols = CountOfBitsOut - PrevBits;
PrevBits = CountOfBitsOut;
/* output the offset sequence */
if (V)
fprintf (stderr, "encoding offset sequence\n");
EncodeOffsets (symbol_list, count);
BITS_offsets = CountOfBitsOut - PrevBits;
PrevBits = CountOfBitsOut;
EncodeChecksum (); /* code lossy checksum */
/* calculate the residue...and compress it---if need be! */
if (!lossy)
{
if (V)
fprintf (stderr, "encoding residue...\n");
d.bitmap = bitmap;
d.h = rows;
d.w = cols;
d2.bitmap = recon;
d2.h = rows;
d2.w = cols;
if (splitfilename)
{
FILE *temp;
CloseDownArithEncoding ();
fclose (stdout);
/* no residue result */
BITS_footer = CountOfBitsOut - PrevBits;
temp = fopen (splitfilename, "wb");
if (temp == NULL)
error_msg (args[0], "Trouble creating file:", splitfilename);
arith_out = temp;
InitArithEncoding ();
bl_clair_compress (d, d2);
CloseDownArithEncoding ();
BITS_residue = CountOfBitsOut;
fclose (temp);
}
else
{
bl_clair_compress (d, d2);
BITS_residue = CountOfBitsOut - PrevBits;
PrevBits = CountOfBitsOut;
EncodeChecksum (); /* code lossless checksum */
CloseDownArithEncoding ();
BITS_footer = CountOfBitsOut - PrevBits;
}
}
else
{
if (V)
fprintf (stderr, "not encoding residue..lossy mode\n");
CloseDownArithEncoding ();
BITS_footer = CountOfBitsOut - PrevBits;
}
/* because we edit the values above */
CountOfBitsOut = BITS_header + BITS_library + BITS_symbols + BITS_offsets + BITS_residue + BITS_footer;
fprintf (stderr, "bits: header=%ld, library=%ld, "
"symbols=%ld, offsets=%ld, residue=%ld, footer=%ld\n",
BITS_header, BITS_library, BITS_symbols,
BITS_offsets, BITS_residue, BITS_footer);
fprintf (stderr, "total bits: %ld, ", CountOfBitsOut);
fprintf (stderr, "Lossy CR: %4.2f", (cols * rows) / (float) (CountOfBitsOut - BITS_residue));
if (external)
fprintf (stderr, " (excluding external lib)");
fprintf (stderr, ", Lossless CR: %4.2f\n", (!lossy) * (cols * rows) / (float) (CountOfBitsOut));
}
else
error_msg (args[0], "unknown format of bitmap--expecting PBM.", "");
}
else
{
/*****************
DECODING STAGE
*****************/
int lastx, lasty;
librarysize = 0;
if (external)
{
libraryname = s1;
infile = s2;
count = librarysize = read_library (libraryname, &library);
}
else
{
infile = s1;
if (infile && s2)
error_msg (args[0], "too many filenames", "");
}
if (!freopen (infile, "rb", stdin))
error_msg (args[0], "Trouble opening file:", infile);
if (V)
fprintf (stderr, "decompressing...\n");
setbuf (stdin, bufferin);
magic_check (stdin, MAGIC_TIC);
InitArithDecoding ();
{
int version = DecodeGammaDist ();
if (version != 1)
error_msg (args[0], "Need later version of decompressor.", "");
}
{
int templossy = DecodeGammaDist ();
if (!lossy)
lossy = templossy; /* can only choose if encoded file is lossless */
if (V)
{
if (lossy)
fprintf (stderr, "lossy mode\n");
else
fprintf (stderr, "lossless mode\n");
}
}
if (DecodeGammaDist ())
{ /* if compressed file doesn't contain library */
if (!external)
error_msg (args[0], "compressed file doesn't contain library, specify externally", "");
external = 1;
}
else
{ /* if compressed file contains library */
if (external)
fprintf (stderr, "ignoring external library file\n");
external = 0;
}
cols = DecodeGammaDist ();
rows = DecodeGammaDist ();
count = DecodeGammaDist ();
i = DecodeGammaDist (); /* librarysize */
if (external)
{
if (i > librarysize)
error_msg (args[0], "external library file is too small!", "");
else if (i < librarysize)
fprintf (stderr, "%s: warning, expecting a different (smaller) library.\n", args[0]);
}
librarysize = i;
if (V)
fprintf (stderr, "cols %d, rows %d, num syms %d, library size %d\n", cols, rows, count, librarysize);
/* decode library */
if (external == 0)
{
if (V)
fprintf (stderr, "reading library\n");
bl_clearmodel ();
bl_readtemplate ();
for (n = 0; n < librarysize; n++)
{
bl_decompress_mark (&d);
d.symnum = n;
if (library == NULL)
step = marklist_add (&library, d);
else
step = marklist_add (&step, d);
}
bl_freemodel ();
if (V)
fprintf (stderr, "read %d marks from library\n", marklist_length (library));
}
recon = pbm_allocarray (cols, rows);
/* decode symbols */
InitPPM ();
if (V)
fprintf (stderr, "decompressing %d symbols\n", count);
symbol_list = DecodeSymbols (count);
/* decode offsets */
if (V)
fprintf (stderr, "reading offsets...\n");
DecodeOffsets (symbol_list, count);
lastx = lasty = 0;
for (step = symbol_list; step; step = step->next)
{
lastx = lastx + step->data.xoffset;
lasty = lasty + step->data.yoffset;
marklist_getat (library, step->data.symnum, &d2);
for (r = 0; r < d2.h; r++)
for (c = 0; c < d2.w; c++)
if (pbm_getpixel (d2.bitmap, c, r))
pbm_putpixel_trunc (recon, lastx + c, lasty + r, 1, cols, rows); /* we don't care, already warned them! */
lastx += d2.w;
}
DecodeChecksum (args[0]);
/* decode the residue */
if (!lossy)
{
if (V)
fprintf (stderr, "decoding residue...\n");
bitmap = pbm_allocarray (cols, rows);
d.bitmap = bitmap;
d.w = d2.w = cols;
d.h = d2.h = rows;
d2.bitmap = recon;
/* NOTE: the 2nd argument is clairvoyantly compressed */
if (splitfilename)
{
FILE *temp;
CloseDownArithDecoding ();
fclose (stdin);
temp = fopen (splitfilename, "rb");
if (temp == NULL)
error_msg (args[0], "Trouble opening file:", splitfilename);
arith_in = temp;
InitArithDecoding ();
bl_clair_decompress (d, d2);
CloseDownArithDecoding ();
fclose (temp);
}
else
{
bl_clair_decompress (d, d2);
DecodeChecksum (args[0]);
CloseDownArithDecoding ();
}
pbm_freearray (&recon, rows);
recon = bitmap; /* point to the bitmap */
}
else
{
CloseDownArithDecoding ();
}
if (V)
fprintf (stderr, "writing pbm file...\n");
setbuf (stdout, bufferout);
pbm_writefile (stdout, recon, cols, rows);
pbm_freearray (&recon, rows);
} /* end decoding */
exit(0);
}
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
}
