nitf_Record *readRecord(char *file)
{
nitf_IOHandle in; /* Handle for input */
nitf_Reader *reader; /* Reader object */
nitf_Record *record; /* The result */
nitf_Error error; /* For errors */
in = nitf_IOHandle_create(file,
NITF_ACCESS_READONLY, NITF_OPEN_EXISTING, &error);
if (NITF_INVALID_HANDLE(in))
{
nitf_Error_print(&error, stderr, "Error opening input ");
exit(EXIT_FAILURE);
}
reader = nitf_Reader_construct(&error);
if (!reader)
{
nitf_Error_print(&error, stderr, "Error creating reader ");
exit(EXIT_FAILURE);
}
record = nitf_Reader_read(reader, in, &error);
if (!record)
{
nitf_Error_print(&error, stderr, "Error reading input ");
exit(EXIT_FAILURE);
}
nitf_IOHandle_close(in);
nitf_Reader_destruct(&reader);
return(record);
}
/* this writes the text data from a text segment to a file */
void writeTextData(nitf_TextSegment * segment,
const char *fileName,
nitf_SegmentReader * reader,
int textNumber, nitf_Error * error)
{
size_t toRead;
char * buf = NULL;
char * outName = NULL;
nitf_IOHandle file;
toRead = (size_t)(segment->end - segment->offset);
buf = (char*)NITF_MALLOC(toRead + 1);
if (!buf)
{
nitf_Error_init(error, NITF_STRERROR(NITF_ERRNO),
NITF_CTXT, NITF_ERR_MEMORY);
return;
}
/* get the data */
if (nitf_SegmentReader_read(reader, buf, toRead, error) != NITF_SUCCESS)
{
/* TODO populate error */
goto CATCH_ERROR;
}
outName = makeBandName(fileName, "text", textNumber, -1);
file = nitf_IOHandle_create(outName, NITF_ACCESS_WRITEONLY,
NITF_CREATE, error);
freeBandName(&outName);
if (NITF_INVALID_HANDLE(file))
{
goto CATCH_ERROR;
}
if (!nitf_IOHandle_write(file, (const char*)buf, toRead, error))
goto CATCH_ERROR;
nitf_IOHandle_close(file);
CATCH_ERROR:
if (buf) NITF_FREE(buf);
return;
}
nitf_ImageSource *setupBands(int nbands, int imageNum,
const char *inRootFile)
{
nitf_Error error;
int i;
nitf_BandSource *bandSource;
nitf_ImageSource *iSource = nitf_ImageSource_construct(&error);
if (!iSource)
goto CATCH_ERROR;
for (i = 0; i < nbands; i++)
{
char *inFile = makeBandName(inRootFile, "img", imageNum, i);
nitf_IOHandle sourceHandle =
nitf_IOHandle_create(inFile, NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING, &error);
if (NITF_INVALID_HANDLE(sourceHandle))
goto CATCH_ERROR;
freeBandName(&inFile);
bandSource = nitf_FileSource_construct(sourceHandle,
0, 0 /*gets ignored */ , 0,
&error);
freeBandName(&inFile);
if (!bandSource)
{
goto CATCH_ERROR;
}
if (!nitf_ImageSource_addBand(iSource, bandSource, &error))
{
goto CATCH_ERROR;
}
}
return iSource;
CATCH_ERROR:
nitf_Error_print(&error, stderr, "While constructing image source");
exit(EXIT_FAILURE);
}
int main(int argc, char **argv)
{
/* This is the error we hopefully wont receive */
nitf_Error e;
/* This is the reader */
nitf_Reader* reader;
/* This is the record of the file we are reading */
nitf_Record* record;
/* This is the io handle we will give the reader to parse */
nitf_IOHandle io;
/* These iterators are for going through the image segments */
nitf_ListIterator iter;
nitf_ListIterator end;
/* If you didnt give us a nitf file, we're croaking */
if (argc != 2)
{
printf("Usage: %s <nitf-file>\n", argv[0]);
exit(EXIT_FAILURE);
}
reader = nitf_Reader_construct(&e);
if (!reader)
{
nitf_Error_print(&e, stderr, "nitf::Reader::construct() failed");
exit(EXIT_FAILURE);
}
/* If you did, though, we'll be nice and open it for you */
io = nitf_IOHandle_create(argv[1],
NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING,
&e);
/* But, oh boy, if you gave us a bad location...! */
if ( NITF_INVALID_HANDLE( io ) )
{
/* You had this coming! */
nitf_Error_print(&e, stderr, "nitf::IOHandle::create() failed");
exit(EXIT_FAILURE);
}
/* Read the file */
record = nitf_Reader_read(reader,
io,
&e);
if (!record)
{
nitf_Error_print(&e, stderr, "nitf::Reader::read() failed");
exit(EXIT_FAILURE);
}
/* Set the iterator to traverse the list of image segments */
iter = nitf_List_begin(record->images);
/* And set this one to the end, so we'll know when we're done! */
end = nitf_List_end(record->images);
/* While we are not done... */
while ( nitf_ListIterator_notEqualTo(&iter, &end) )
{
/* Get the image segment as its proper object */
nitf_ImageSegment* imageSegment =
(nitf_ImageSegment*)nitf_ListIterator_get(&iter);
assert( imageSegment->subheader);
if ( imageSegment->subheader->userDefinedSection )
findInExtensions( imageSegment->subheader->userDefinedSection );
else
printf("Nothing found in user defined section!\n");
if ( imageSegment->subheader->extendedSection )
findInExtensions( imageSegment->subheader->extendedSection );
else
printf("Nothing found in extended section!\n");
/* Increment the iterator so we can continue */
nitf_ListIterator_increment(&iter);
}
nitf_Record_destruct(&record);
nitf_Reader_destruct(&reader);
nitf_IOHandle_close(io);
return 0;
}
/*
* Take a buffer of memory that we read out of a NITF segment
* and write it one of two-ways.
*
* For non RGB 24-bit true-color data, write each band separately.
* This demonstrates the typical, non-accelerated, generic read.
*
* For 24-bit true-color, if its band interleaved by pixel (mode 'P')
* demonstrate accelerated mode, and read without de-interleaving pixels,
* then write it to one big image as is.
*
*/
void writeImage(nitf_ImageSegment * segment,
char *imageName,
nitf_ImageReader * deserializer,
int imageNumber,
nitf_Uint32 rowSkipFactor,
nitf_Uint32 columnSkipFactor,
NITF_BOOL optz,
nitf_Error * error)
{
nitf_Uint32 nBits, nBands, xBands, nRows, nColumns;
size_t subimageSize;
nitf_SubWindow *subimage;
unsigned int i;
int padded;
nitf_Uint8 **buffer = NULL;
nitf_Uint32 band;
nitf_Uint32 *bandList = NULL;
nitf_DownSampler *pixelSkip;
/* TODO, replace these macros! */
NITF_TRY_GET_UINT32(segment->subheader->numBitsPerPixel, &nBits,
error);
NITF_TRY_GET_UINT32(segment->subheader->numImageBands, &nBands, error);
NITF_TRY_GET_UINT32(segment->subheader->numMultispectralImageBands,
&xBands, error);
nBands += xBands;
NITF_TRY_GET_UINT32(segment->subheader->numRows, &nRows, error);
NITF_TRY_GET_UINT32(segment->subheader->numCols, &nColumns, error);
subimageSize = (nRows / rowSkipFactor) * (nColumns / columnSkipFactor)
* NITF_NBPP_TO_BYTES(nBits);
printf("Image number: %d\n", imageNumber);
printf("NBANDS -> %d\n"
"XBANDS -> %d\n"
"NROWS -> %d\n"
"NCOLS -> %d\n"
"PVTYPE -> %.*s\n"
"NBPP -> %.*s\n"
"ABPP -> %.*s\n"
"PJUST -> %.*s\n"
"IMODE -> %.*s\n"
"NBPR -> %.*s\n"
"NBPC -> %.*s\n"
"NPPBH -> %.*s\n"
"NPPBV -> %.*s\n"
"IC -> %.*s\n"
"COMRAT -> %.*s\n",
nBands,
xBands,
nRows,
nColumns,
(int)segment->subheader->pixelValueType->length,
segment->subheader->pixelValueType->raw,
(int)segment->subheader->numBitsPerPixel->length,
segment->subheader->numBitsPerPixel->raw,
(int)segment->subheader->actualBitsPerPixel->length,
segment->subheader->actualBitsPerPixel->raw,
(int)segment->subheader->pixelJustification->length,
segment->subheader->pixelJustification->raw,
(int)segment->subheader->imageMode->length,
segment->subheader->imageMode->raw,
(int)segment->subheader->numBlocksPerRow->length,
segment->subheader->numBlocksPerRow->raw,
(int)segment->subheader->numBlocksPerCol->length,
segment->subheader->numBlocksPerCol->raw,
(int)segment->subheader->numPixelsPerHorizBlock->length,
segment->subheader->numPixelsPerHorizBlock->raw,
(int)segment->subheader->numPixelsPerVertBlock->length,
segment->subheader->numPixelsPerVertBlock->raw,
(int)segment->subheader->imageCompression->length,
segment->subheader->imageCompression->raw,
(int)segment->subheader->compressionRate->length,
segment->subheader->compressionRate->raw);
if (optz)
{
/*
* There is an accelerated mode for band-interleaved by pixel data.
* In that case, we assume that the user doesnt want the data
* de-interleaved into separate band buffers. To make this work
* you have to tell us that you want only one band back,
* and you have to provide us a singular buffer that is the
* actual number of bands x the pixel size. Then we will
* read the window and not de-interleave.
* To demonstrate, for RGB24 images, let's we write out the 1 band
* - this will be MUCH faster
*/
if (nBands == 3
&& segment->subheader->imageMode->raw[0] == 'P'
&& strncmp("RGB", segment->subheader->imageRepresentation->raw, 3) == 0
&& NITF_NBPP_TO_BYTES(nBits) == 1
&& (strncmp("NC", segment->subheader->imageCompression->raw, 2)
|| strncmp("NM", segment->subheader->imageCompression->raw, 2)))
{
subimageSize *= nBands;
nBands = 1;
printf("Using accelerated 3-band RGB mode pix-interleaved image\n");
}
if (nBands == 2
&& segment->subheader->NITF_IMODE->raw[0] == 'P'
&& NITF_NBPP_TO_BYTES(nBits) == 4
&& segment->subheader->bandInfo[0]->NITF_ISUBCAT->raw[0] == 'I'
&& (strncmp("NC", segment->subheader->NITF_IC->raw, 2)
|| strncmp("NM", segment->subheader->NITF_IC->raw, 2)))
{
subimageSize *= nBands;
nBands = 1;
printf("Using accelerated 2-band IQ mode pix-interleaved image\n");
}
}
subimage = nitf_SubWindow_construct(error);
assert(subimage);
/*
* You need a buffer for each band (unless this is an
* accelerated IQ complex or RGB read, in which case, you
* can set the number of bands to 1, and size your buffer
* accordingly to receive band-interleaved by pixel data)
*/
buffer = (nitf_Uint8 **) NITF_MALLOC(nBands * sizeof(nitf_Uint8*));
/* An iterator for bands */
band = 0;
/*
* This tells us what order to give you bands in. Normally
* you just want it in the order of the banding. For example,
* in a non-accelerated band-interleaved by pixel cases, you might
* have a band of magnitude and a band of phase. If you order the
* bandList backwards, the phase buffer comes first in the output
*/
bandList = (nitf_Uint32 *) NITF_MALLOC(sizeof(nitf_Uint32 *) * nBands);
/* This example reads all rows and cols starting at 0, 0 */
subimage->startCol = 0;
subimage->startRow = 0;
/* Request rows is the full rows dividied by pixel skip (usually 1) */
subimage->numRows = nRows / rowSkipFactor;
/* Request columns is the full columns divided by pixel skip (usually 1) */
subimage->numCols = nColumns / columnSkipFactor;
/* Construct our pixel skip downsampler (does nothing if skips are 1) */
pixelSkip = nitf_PixelSkip_construct(rowSkipFactor,
columnSkipFactor,
error);
if (!pixelSkip)
{
nitf_Error_print(error, stderr, "Pixel Skip construction failed");
goto CATCH_ERROR;
}
if (!nitf_SubWindow_setDownSampler(subimage, pixelSkip, error))
{
nitf_Error_print(error, stderr, "Set down sampler failed");
goto CATCH_ERROR;
}
for (band = 0; band < nBands; band++)
bandList[band] = band;
subimage->bandList = bandList;
subimage->numBands = nBands;
assert(buffer);
for (i = 0; i < nBands; i++)
{
buffer[i] = (nitf_Uint8 *) NITF_MALLOC(subimageSize);
assert(buffer[i]);
}
if (!nitf_ImageReader_read
(deserializer, subimage, buffer, &padded, error))
{
nitf_Error_print(error, stderr, "Read failed");
goto CATCH_ERROR;
}
for (i = 0; i < nBands; i++)
{
nitf_IOHandle toFile;
char file[NITF_MAX_PATH];
int pos;
/* find end slash */
for (pos = strlen(imageName) - 1;
pos && imageName[pos] != '\\' && imageName[pos] != '/';
pos--);
pos = pos == 0 ? pos : pos + 1;
NITF_SNPRINTF(file, NITF_MAX_PATH,
"%s_%d__%d_%d_%d_band_%d", &imageName[pos],
imageNumber, nRows / rowSkipFactor,
nColumns / columnSkipFactor, nBits, i);
/* remove decimals */
for (pos = strlen(file) - 1; pos; pos--)
if (file[pos] == '.')
file[pos] = '_';
strcat(file, ".out");
printf("File: %s\n", file);
toFile = nitf_IOHandle_create(file, NITF_ACCESS_WRITEONLY,
NITF_CREATE, error);
if (NITF_INVALID_HANDLE(toFile))
{
nitf_Error_print(error, stderr,
"IO handle creation failed for raw band");
goto CATCH_ERROR;
}
if (!nitf_IOHandle_write(toFile,
(const char *) buffer[i],
subimageSize, error))
{
nitf_Error_print(error, stderr,
"IO handle write failed for raw band");
goto CATCH_ERROR;
}
nitf_IOHandle_close(toFile);
}
/* free buffers */
for (i = 0; i < nBands; i++)
NITF_FREE(buffer[i]);
NITF_FREE(buffer);
NITF_FREE(bandList);
nitf_SubWindow_destruct(&subimage);
nitf_DownSampler_destruct(&pixelSkip);
return;
CATCH_ERROR:
/* free buffers */
for (i = 0; i < nBands; i++)
NITF_FREE(buffer[i]);
NITF_FREE(buffer);
NITF_FREE(bandList);
printf("ERROR processing\n");
}
int main(int argc, char **argv)
{
/* This is the error we hopefully wont receive */
nitf_Error e;
/* Skip factors */
nitf_Uint32 rowSkipFactor = 1;
nitf_Uint32 columnSkipFactor = 1;
/* This is the reader */
nitf_Reader *reader;
/* This is the record of the file we are reading */
nitf_Record *record;
/* This is the io handle we will give the reader to parse */
nitf_IOHandle io;
int count = 0;
int numImages;
/* These iterators are for going through the image segments */
nitf_ListIterator iter;
nitf_ListIterator end;
char* inputFile;
NITF_BOOL optz = 0;
/* If you didnt give us a nitf file, we're croaking */
if (argc < 2)
{
printf("Usage: %s <nitf-file> (-o)\n", argv[0]);
exit(EXIT_FAILURE);
}
if (argc == 3)
{
optz = 1;
if (strcmp(argv[1], "-o") == 0)
{
inputFile = argv[2];
}
else if (strcmp(argv[2], "-o") == 0)
{
inputFile = argv[1];
}
else
{
printf("Usage: %s <nitf-file> (-o)\n", argv[0]);
exit(EXIT_FAILURE);
}
}
else
inputFile = argv[1];
/* You should use this function to test that you have a valid NITF */
if (nitf_Reader_getNITFVersion( inputFile ) == NITF_VER_UNKNOWN)
{
printf("This file does not appear to be a valid NITF");
exit(EXIT_FAILURE);
}
reader = nitf_Reader_construct(&e);
if (!reader)
{
nitf_Error_print(&e, stderr, "Reader creation failed");
exit(EXIT_FAILURE);
}
/*
* As of 2.5, you do not have to use an IOHandle if you use
* readIO instead of read()
*/
io = nitf_IOHandle_create(inputFile,
NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING, &e);
if (NITF_INVALID_HANDLE(io))
{
nitf_Error_print(&e, stderr, "IO creation failed");
exit(EXIT_FAILURE);
}
/* Read the file */
record = nitf_Reader_read(reader, io, &e);
if (!record)
{
nitf_Error_print(&e, stderr, "Read failed");
nitf_IOHandle_close(io);
nitf_Reader_destruct(&reader);
exit(EXIT_FAILURE);
}
numImages = nitf_Record_getNumImages(record, &e);
if ( NITF_INVALID_NUM_SEGMENTS( numImages ) )
{
nitf_Error_print(&e, stderr, "Failed to get the number of images");
nitf_IOHandle_close(io);
nitf_Reader_destruct(&reader);
nitf_Record_destruct( &record );
exit(EXIT_FAILURE);
}
/* Set the iterator to traverse the list of image segments */
iter = nitf_List_begin(record->images);
/* And set this one to the end, so we'll know when we're done! */
end = nitf_List_end(record->images);
for (count = 0; count < numImages; ++count)
{
nitf_ImageSegment *imageSegment =
(nitf_ImageSegment *) nitf_ListIterator_get(&iter);
nitf_ImageReader *deserializer =
nitf_Reader_newImageReader(reader, count, &e);
if (!deserializer)
{
nitf_Error_print(&e, stderr, "Couldnt spawn deserializer");
exit(EXIT_FAILURE);
}
printf("Writing image %d... ", count);
/* Write the thing out */
writeImage(imageSegment, inputFile, deserializer, count,
rowSkipFactor, columnSkipFactor, optz, &e);
nitf_ImageReader_destruct(&deserializer);
printf("done.\n");
/* Increment the iterator so we can continue */
nitf_ListIterator_increment(&iter);
}
nitf_Record_destruct(&record);
nitf_Reader_destruct(&reader);
nitf_IOHandle_close(io);
return 0;
}
int main(int argc, char **argv)
{
/* Get the error object */
nitf_Error error;
/* This is the reader object */
nitf_Reader* reader;
nitf_Record* record;
/* The IO handle */
nitf_IOHandle io;
int num;
/* Check argv and make sure we are happy */
if ( argc != 2 )
{
printf("Usage: %s <nitf-file>\n", argv[0]);
exit(EXIT_FAILURE);
}
io = nitf_IOHandle_create(argv[1], NITF_ACCESS_READONLY, NITF_OPEN_EXISTING, &error);
if ( NITF_INVALID_HANDLE( io ) )
{
nitf_Error_print(&error, stdout, "Exiting...");
exit( EXIT_FAILURE );
}
reader = nitf_Reader_construct(&error);
if (!reader)
{
nitf_Error_print(&error, stdout, "Exiting (1) ...");
exit( EXIT_FAILURE );
}
/* record = nitf_Record_construct(&error);
if (!record)
{
nitf_Error_print(&error, stdout, "Exiting (2) ...");
nitf_Reader_destruct(&reader);
exit( EXIT_FAILURE );
}*/
#if NITF_VERBOSE_READER
printf("Here are the loaded handlers\n");
printf("* * * * * * * * * * * * * * * *\n");
nitf_HashTable_print(reader->reg->treHandlers);
printf("* * * * * * * * * * * * * * * *\n");
#endif
if ( ! (record = nitf_Reader_read(reader, io, &error )) )
{
nitf_Error_print(&error, stdout, "Exiting ...");
exit(EXIT_FAILURE);
}
printf("User defined: in file header\n");
showExtSection(record->header->userDefinedSection);
printf("Extended defined: in file header\n");
showExtSection(record->header->extendedSection);
if (!nitf_Field_get(record->header->numImages,
&num,
NITF_CONV_INT,
NITF_INT32_SZ,
&error))
nitf_Error_print(&error, stdout, "Skipping b/c Invalid numImages");
/* And now show the image information */
else if (num > 0)
{
/* Walk each image and show */
nitf_ListIterator iter = nitf_List_begin(record->images);
nitf_ListIterator end = nitf_List_end(record->images);
while ( nitf_ListIterator_notEqualTo(&iter, &end) )
{
nitf_ImageSegment* segment =
(nitf_ImageSegment*)nitf_ListIterator_get(&iter);
printf("User defined: in image segment\n");
showExtSection(segment->subheader->userDefinedSection);
printf("Extended defined: in image segment\n");
showExtSection(segment->subheader->extendedSection);
nitf_ListIterator_increment(&iter);
}
}
else
{
printf("No image in file!\n");
}
nitf_IOHandle_close(io);
nitf_Record_destruct(&record);
if ( !nitf_List_isEmpty(reader->warningList))
{
/* Iterator to a list */
nitf_ListIterator it;
/* Iterator to the end of list */
nitf_ListIterator endList;
it = nitf_List_begin(reader->warningList);
/* End of list pointer */
endList = nitf_List_end(reader->warningList);
printf("WARNINGS: ");
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
/* While we are not at the end */
while ( nitf_ListIterator_notEqualTo( &it, &endList ) )
{
/* Get the last data */
char* p = (char*)nitf_ListIterator_get(&it);
/* Make sure */
assert(p != NULL);
/* Show the data */
printf("\tFound problem: [%s]\n\n", p);
/* Increment the list iterator */
nitf_ListIterator_increment(&it);
}
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
}
nitf_Reader_destruct(&reader);
return 0;
}
/* This test case just reads in a NITF file, clones it
* then destructs the clone and original.
* If you compile the library with the NITF_DEBUG flag set,
* then you can make sure there are no memory leaks.
*
* In the future, we should use the cloned record to test
* the functionality of a clone.
*/
int main(int argc, char **argv)
{
/* Get the error object */
nitf_Error error;
/* This is the reader object */
nitf_Reader* reader;
nitf_Record* record;
nitf_Record* cloneRecord;
/* The IO handle */
nitf_IOHandle io;
int num;
/* Check argv and make sure we are happy */
if ( argc != 2 )
{
printf("Usage: %s <nitf-file>\n", argv[0]);
exit(EXIT_FAILURE);
}
io = nitf_IOHandle_create(argv[1], NITF_ACCESS_READONLY, NITF_OPEN_EXISTING, &error);
if ( NITF_INVALID_HANDLE( io ) )
{
nitf_Error_print(&error, stdout, "Exiting...");
exit( EXIT_FAILURE );
}
reader = nitf_Reader_construct(&error);
if (!reader)
{
nitf_Error_print(&error, stdout, "Exiting(1) ...");
exit( EXIT_FAILURE );
}
/* read the record */
record = nitf_Reader_read(reader, io, &error );
if (!record) goto CATCH_ERROR;
cloneRecord = nitf_Record_clone(record, &error);
if (!cloneRecord)
{
nitf_Error_print(&error, stdout, "Exiting(3) ...");
exit( EXIT_FAILURE );
}
printf("Destructing Cloned Record\n");
nitf_Record_destruct(&cloneRecord);
nitf_IOHandle_close(io);
printf("Destructing Original Record\n");
nitf_Record_destruct(&record);
nitf_Reader_destruct(&reader);
return 0;
CATCH_ERROR:
printf("!!! we had a problem reading the file !!!\n");
nitf_Error_print(&error, stdout, "Exiting...");
exit(EXIT_FAILURE);
}
int main(int argc, char *argv[])
{
char *inFile; /* Input filename */
char *outFile; /* Output filename */
char *compCode; /* Compression code NC or NM */
char *padValueString = NULL; /* Pad value string */
nitf_Reader *reader; /* Reader object */
nitf_Record *record; /* Record used for input and output */
imgInfo *imgs; /* Image segment information */
nitf_FileHeader *fileHdr; /* File header */
nitf_Uint32 numImages; /* Total number of image segments */
nitf_ListIterator imgIter; /* Image segment list iterator */
nitf_IOHandle in; /* Input I/O handle */
nitf_IOHandle out; /* Output I/O handle */
nitf_Writer *writer; /* Writer object for output */
static nitf_Error errorObj; /* Error object for messages */
nitf_Error *error; /* Pointer to the error object */
int i;
error = &errorObj;
compCode = "NM";
if (argc == 3)
{
inFile = argv[1];
outFile = argv[2];
}
else if (argc == 4)
{
if (strcmp(argv[1], "-r") != 0)
{
fprintf(stderr,
"Usage %s [-r] [-p padValue] inputFile outputFile\n", argv[0]);
exit(EXIT_FAILURE);
}
inFile = argv[2];
outFile = argv[3];
compCode = "NC";
}
else if (argc == 5)
{
if (strcmp(argv[1], "-p") != 0)
{
fprintf(stderr,
"Usage %s [-r] [-p padValue] inputFile outputFile\n", argv[0]);
exit(EXIT_FAILURE);
}
inFile = argv[3];
outFile = argv[4];
padValueString = argv[2];
}
else
{
fprintf(stderr, "Usage %s [-r] inputFile outputFile\n", argv[0]);
exit(EXIT_FAILURE);
}
/* Get the input record */
in = nitf_IOHandle_create(inFile,
NITF_ACCESS_READONLY, NITF_OPEN_EXISTING, error);
if (NITF_INVALID_HANDLE(in))
{
nitf_Error_print(error, stderr, "Error opening input ");
exit(EXIT_FAILURE);
}
reader = nitf_Reader_construct(error);
if (!reader)
{
nitf_Error_print(error, stderr, "Error creating reader ");
exit(EXIT_FAILURE);
}
record = nitf_Reader_read(reader, in, error);
if (!record)
{
nitf_Error_print(error, stderr, "Error reading input ");
exit(EXIT_FAILURE);
}
fileHdr = record->header;
nitf_Field_get(fileHdr->numImages,
&numImages, NITF_CONV_UINT, NITF_INT32_SZ, error);
/* Get information about all image segments and set-up for write */
imgs = (imgInfo *) NITF_MALLOC(numImages * sizeof(imgInfo));
if (imgs == NULL)
{
nitf_Error_print(error, stderr, "Error allocating image info ");
exit(EXIT_FAILURE);
}
for (i = 0;i < numImages;i++)
{
imgs[i].index = i;
imgIter = nitf_List_at(record->images, i);
imgs[i].seg = (nitf_ImageSegment *) nitf_ListIterator_get(&imgIter);
if (!imgs[i].seg)
{
fprintf(stderr, "No Image segment in file\n");
exit(EXIT_FAILURE);
}
imgs[i].subhdr = imgs[i].seg->subheader;
if (padValueString != NULL)
{
if (!decodePadValue(&(imgs[i]), padValueString, imgs[i].padValue, error))
{
nitf_Error_print(error, stderr, "Error allocating image info ");
exit(EXIT_FAILURE);
}
}
else
memset(imgs[i].padValue, 0, MAX_PAD);
}
/* Read all of the image data into buffers */
for (i = 0;i < numImages;i++)
if (!readImageSegment(&(imgs[i]), reader, error))
{
nitf_Error_print(error, stderr, "Error reading image segment ");
exit(EXIT_FAILURE);
}
/* Set compression type to NM or NC (has to happen afetr read) */
for (i = 0;i < numImages;i++)
{
if (!nitf_ImageSubheader_setCompression(imgs[i].subhdr, compCode, "", error))
{
nitf_Error_print(error, stderr, "No DE segment in file ");
exit(EXIT_FAILURE);
}
}
/* Create output */
out = nitf_IOHandle_create(outFile, NITF_ACCESS_WRITEONLY, NITF_CREATE, error);
if (NITF_INVALID_HANDLE(out))
{
nitf_Error_print(error, stderr, "Could not create output file ");
exit(EXIT_FAILURE);
}
/* Setup write and write */
writer = nitf_Writer_construct(error);
if (writer == NULL)
{
nitf_Error_print(error, stderr, "Write setup failed ");
exit(EXIT_FAILURE);
}
if (!nitf_Writer_prepare(writer, record, out, error))
{
nitf_Error_print(error, stderr, "Write setup failed ");
exit(EXIT_FAILURE);
}
for (i = 0;i < numImages;i++)
if (!makeImageSource(&(imgs[i]), writer, error))
{
nitf_Error_print(error, stderr, "Write setup failed ");
exit(EXIT_FAILURE);
}
/* Set pad pixel if padValue string is not NULL */
if (padValueString != NULL)
for (i = 0;i < numImages;i++)
{
}
if (!nitf_Writer_write(writer, error))
{
nitf_Error_print(error, stderr, "Write error ");
exit(EXIT_FAILURE);
}
/* Clean-up */
nitf_Record_destruct(&record);
nitf_IOHandle_close(out);
return 0;
}
void doWrite(nitf_Record * record, char *inRootFile, char *outFile)
{
nitf_ListIterator iter;
nitf_ImageWriter *iWriter;
nitf_ImageSource *iSource;
nitf_SegmentWriter *segmentWriter;
nitf_SegmentSource *segmentSource;
nitf_ListIterator end;
int i;
int numImages;
int numTexts;
int numDataExtensions;
nitf_Writer *writer = NULL;
nitf_Error error;
nitf_IOHandle output_io = nitf_IOHandle_create(outFile,
NITF_ACCESS_WRITEONLY,
NITF_CREATE,
&error);
if (NITF_INVALID_HANDLE(output_io))
{
goto CATCH_ERROR;
}
writer = nitf_Writer_construct(&error);
if (!writer)
{
goto CATCH_ERROR;
}
if (!nitf_Writer_prepare(writer, record, output_io, &error))
{
goto CATCH_ERROR;
}
if (!nitf_Field_get
(record->header->numImages, &numImages, NITF_CONV_INT,
NITF_INT32_SZ, &error))
{
nitf_Error_print(&error, stderr, "nitf::Value::get() failed");
numImages = 0;
}
if (!nitf_Field_get
(record->header->numTexts, &numTexts, NITF_CONV_INT,
NITF_INT32_SZ, &error))
{
nitf_Error_print(&error, stderr, "nitf::Value::get() failed");
numTexts = 0;
}
if (!nitf_Field_get
(record->header->numDataExtensions, &numDataExtensions, NITF_CONV_INT,
NITF_INT32_SZ, &error))
{
nitf_Error_print(&error, stderr, "nitf::Value::get() failed");
numDataExtensions = 0;
}
if (record->images)
{
end = nitf_List_end(record->images);
for (i = 0; i < numImages; i++)
{
int nbands;
nitf_ImageSegment *imseg = NULL;
iter = nitf_List_at(record->images, i);
assert(nitf_ListIterator_notEqualTo(&iter, &end));
imseg = (nitf_ImageSegment *) nitf_ListIterator_get(&iter);
assert(imseg);
if (!nitf_Field_get
(imseg->subheader->numImageBands, &nbands, NITF_CONV_INT,
NITF_INT32_SZ, &error))
goto CATCH_ERROR;
iWriter = nitf_Writer_newImageWriter(writer, i, &error);
if (!iWriter)
{
goto CATCH_ERROR;
}
iSource = setupBands(nbands, i, inRootFile);
if (!iSource)
goto CATCH_ERROR;
if (!nitf_ImageWriter_attachSource(iWriter, iSource, &error))
goto CATCH_ERROR;
}
}
if (record->texts)
{
end = nitf_List_end(record->texts);
for (i = 0; i < numTexts; i++)
{
nitf_TextSegment *textSeg = NULL;
char *inFile = NULL;
nitf_IOHandle sourceHandle;
iter = nitf_List_at(record->texts, i);
assert(nitf_ListIterator_notEqualTo(&iter, &end));
textSeg = (nitf_TextSegment *) nitf_ListIterator_get(&iter);
assert(textSeg);
segmentWriter = nitf_Writer_newTextWriter(writer, i, &error);
if (!segmentWriter)
{
goto CATCH_ERROR;
}
/* setup file */
inFile = makeBandName(inRootFile, "text", i, -1);
sourceHandle =
nitf_IOHandle_create(inFile, NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING, &error);
if (NITF_INVALID_HANDLE(sourceHandle))
goto CATCH_ERROR;
freeBandName(&inFile);
segmentSource = nitf_SegmentFileSource_construct(sourceHandle, 0, 0, &error);
if (!segmentSource)
goto CATCH_ERROR;
if (!nitf_SegmentWriter_attachSource(segmentWriter, segmentSource, &error))
goto CATCH_ERROR;
}
}
if (record->dataExtensions)
{
end = nitf_List_end(record->dataExtensions);
for (i = 0; i < numDataExtensions; i++)
{
nitf_DESegment *DESeg = NULL;
char *inFile = NULL;
nitf_IOHandle sourceHandle;
iter = nitf_List_at(record->dataExtensions, i);
assert(nitf_ListIterator_notEqualTo(&iter, &end));
DESeg = (nitf_DESegment *) nitf_ListIterator_get(&iter);
assert(DESeg);
segmentWriter = nitf_Writer_newDEWriter(writer, i, &error);
if (!segmentWriter)
{
goto CATCH_ERROR;
}
/* setup file */
inFile = makeBandName(inRootFile, "DE", i, -1);
sourceHandle =
nitf_IOHandle_create(inFile, NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING, &error);
if (NITF_INVALID_HANDLE(sourceHandle))
goto CATCH_ERROR;
freeBandName(&inFile);
segmentSource = nitf_SegmentFileSource_construct(sourceHandle, 0, 0, &error);
if (!segmentSource)
goto CATCH_ERROR;
if (!nitf_SegmentWriter_attachSource(segmentWriter, segmentSource, &error))
goto CATCH_ERROR;
}
}
if (!nitf_Writer_write(writer, &error))
{
goto CATCH_ERROR;
}
/*nitf_ImageSource_destruct(&iSource);*/
nitf_IOHandle_close(output_io);
nitf_Writer_destruct(&writer);
return;
CATCH_ERROR:
nitf_Error_print(&error, stderr, "During write");
exit(EXIT_FAILURE);
}
int main(int argc, char **argv)
{
/* This is the reader object */
nitf_Reader* reader;
nitf_Record* record;
/* The IO handle */
nitf_IOHandle io;
/* Get the error object */
nitf_Error error;
/* Check argv and make sure we are happy */
if ( argc != 2 )
{
printf("Usage: %s <nitf-file>\n", argv[0]);
exit(EXIT_FAILURE);
}
io = nitf_IOHandle_create(argv[1],
NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING,
&error);
if ( NITF_INVALID_HANDLE( io ) )
{
nitf_Error_print(&error, stdout, "Exiting...");
exit( EXIT_FAILURE );
}
reader = nitf_Reader_construct(&error);
if (!reader)
{
nitf_Error_print(&error, stdout, "Exiting (1) ...");
exit( EXIT_FAILURE );
}
printf("Here are the loaded handlers\n");
printf("* * * * * * * * * * * * * * * *\n");
{
nitf_PluginRegistry* reg = nitf_PluginRegistry_getInstance(&error);
nitf_HashTable_print( reg->treHandlers);
}
printf("* * * * * * * * * * * * * * * *\n");
record = nitf_Reader_read(reader, io, &error);
if (!record)
{
nitf_Error_print(&error, stderr, "Failed to read the file");
exit(EXIT_FAILURE);
}
/* Now show the header */
showFileHeader(record->header);
/* And now show the image information */
if (record->header->numImages)
{
/* Walk each image and show */
nitf_ListIterator iter = nitf_List_begin(record->images);
nitf_ListIterator end = nitf_List_end(record->images);
while ( nitf_ListIterator_notEqualTo(&iter, &end) )
{
nitf_ImageSegment* segment =
(nitf_ImageSegment*)nitf_ListIterator_get(&iter);
nitf_ImageSubheader* dolly =
nitf_ImageSubheader_clone(segment->subheader, &error);
if (!dolly)
{
nitf_Error_print(&error, stdout, "During cloning!");
exit(EXIT_FAILURE);
}
SHOW_IMSUB(segment->subheader);
SHOW_IMSUB(dolly);
nitf_ImageSubheader_destruct(&dolly);
nitf_ListIterator_increment(&iter);
}
}
else
{
printf("No image in file!\n");
}
nitf_IOHandle_close(io);
nitf_Record_destruct(&record);
nitf_Reader_destruct(&reader);
return 0;
}
int main(int argc, char *argv[])
{
nitf_Reader *reader; /* Reader object */
nitf_Record *record; /* Record used for input and output */
nitf_IOHandle in; /* Input I/O handle */
nitf_ListIterator desIter; /* Iterator for getting the DES */
nitf_DESegment *des; /* DE segment to read */
nitf_DEReader *deReader; /* DE reader object for reading data */
char *data; /* Data buffer */
static nitf_Error errorObj; /* Error object for messages */
nitf_Error *error; /* Pointer to the error object */
error = &errorObj;
if (argc != 2)
{
fprintf(stderr, "Usage %s inputFile\n", argv[0]);
exit(EXIT_FAILURE);
}
/* Get the input record */
in = nitf_IOHandle_create(argv[1],
NITF_ACCESS_READONLY, NITF_OPEN_EXISTING,
error);
if (NITF_INVALID_HANDLE(in))
{
nitf_Error_print(error, stderr, "Error opening input ");
exit(EXIT_FAILURE);
}
reader = nitf_Reader_construct(error);
if (!reader)
{
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Error creating reader ");
exit(EXIT_FAILURE);
}
record = nitf_Reader_read(reader, in, error);
if (!record)
{
nitf_Reader_destruct(&reader);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Error reading input ");
exit(EXIT_FAILURE);
}
/* Print the user header */
desIter = nitf_List_at(record->dataExtensions, 0);
des = (nitf_DESegment *) nitf_ListIterator_get(&desIter);
if (!des)
{
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "No DE segment in file ");
exit(EXIT_FAILURE);
}
nitf_TRE_print(des->subheader->subheaderFields, error);
/* Read the data and print it */
deReader = nitf_Reader_newDEReader(reader, 0, error);
if (!deReader)
{
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Could not create DEReader ");
exit(EXIT_FAILURE);
}
fprintf(stdout, "Data length = %d\n", deReader->user->dataLength);
fprintf(stdout, "Virtual data length = %d\n",
deReader->user->virtualLength);
fprintf(stdout, "File offset = %lld\n", deReader->user->baseOffset);
data = (char *) NITF_MALLOC(deReader->user->virtualLength + 2);
if (!data)
{
nitf_DEReader_destruct(&deReader);
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Could not allocate data buffer ");
exit(EXIT_FAILURE);
}
if (!nitf_DEReader_read
(deReader, data, deReader->user->virtualLength, error))
{
NITF_FREE(data);
nitf_DEReader_destruct(&deReader);
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Read failed ");
exit(EXIT_FAILURE);
}
fprintf(stdout, "Data: |%s|\n", data);
/* Try some seeks */
if (nitf_DEReader_seek(deReader, (nitf_Off) 4, SEEK_SET, error) == (nitf_Off) - 1)
{
NITF_FREE(data);
nitf_DEReader_destruct(&deReader);
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Read failed ");
exit(EXIT_FAILURE);
}
if (!nitf_DEReader_read(deReader, data, 1, error))
{
NITF_FREE(data);
nitf_DEReader_destruct(&deReader);
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Read failed ");
exit(EXIT_FAILURE);
}
data[1] = 0;
fprintf(stdout, "Data after set seek: |%s|\n", data);
/*
The last read advanced to position 5 so relative position10 should be
the last byte in the file
*/
if (nitf_DEReader_seek(deReader, (nitf_Off) 10, SEEK_CUR, error) == (nitf_Off) - 1)
{
NITF_FREE(data);
nitf_DEReader_destruct(&deReader);
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Read failed ");
exit(EXIT_FAILURE);
}
if (!nitf_DEReader_read(deReader, data, 1, error))
{
NITF_FREE(data);
nitf_DEReader_destruct(&deReader);
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Read failed ");
exit(EXIT_FAILURE);
}
data[1] = 0;
fprintf(stdout, "Data after current seek: |%s|\n", data);
if (nitf_DEReader_seek(deReader, (nitf_Off) - 2, SEEK_END, error) == (nitf_Off) - 1)
{
NITF_FREE(data);
nitf_DEReader_destruct(&deReader);
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Read failed ");
exit(EXIT_FAILURE);
}
if (!nitf_DEReader_read(deReader, data, 1, error))
{
NITF_FREE(data);
nitf_DEReader_destruct(&deReader);
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Read failed ");
exit(EXIT_FAILURE);
}
data[1] = 0;
fprintf(stdout, "Data after end seek: |%s|\n", data);
/* Clean-up */
NITF_FREE(data);
nitf_DEReader_destruct(&deReader);
nitf_Reader_destruct(&reader);
nitf_Record_destruct(&record);
nitf_IOHandle_close(in);
return 0;
}
int main(int argc, char *argv[])
{
FILE *vector; /* File stream for input vector */
/* Arguments for new */
test_nitf_ImageIOConstructArgs *newArgs;
/* Arguments for read */
test_nitf_ImageIOReadArgs *readArgs;
char *errorStr; /* Error string */
nitf_ImageSubheader *subheader; /* Subheader for ImageIO constructor */
nitf_IOHandle io; /* Handle for output */
nitf_Error error; /* Error object */
nitf_ImageIO *image; /* ImageIO for image */
nitf_Uint8 *user[NUM_BANDS_MAX]; /* User buffer for write rows */
nitf_Uint8 ***data; /* Generated data [band][row][col] */
nitf_Uint32 band; /* Current band */
nitf_Uint32 row; /* Current row */
nitf_Uint32 col; /* Current column*/
if (argc < 3)
{
fprintf(stderr, "Not enough arguments\n");
exit(-1);
}
vector = fopen(argv[1], "r");
if (vector == NULL)
{
fprintf(stderr, "Error opening vector file %s\n", argv[1]);
exit(-1);
}
newArgs = test_nitf_ImageIOReadConstructArgs(vector, &errorStr);
if (newArgs == NULL)
{
fprintf(stderr, "%s\n", errorStr);
return(-1);
}
fclose(vector);
/* Create a fake image subheader to give to ImageIO constructor */
subheader = test_nitf_ImageIO_fakeSubheader(newArgs, &errorStr);
if (subheader == NULL)
{
fprintf(stderr, "%s", error);
return(-1);
}
/* Create Image */
if (strcmp(newArgs->dataPattern, "brcI4") == 0)
{
data = (nitf_Uint8 ***) test_nitf_ImageIO_brcI4(newArgs, &errorStr);
if (data == NULL)
{
fprintf(stderr, "%s\n", errorStr);
exit(-1);
}
}
else if (strcmp(newArgs->dataPattern, "brcC8") == 0)
{
data = (nitf_Uint8 ***) test_nitf_ImageIO_brcC8(newArgs, &errorStr);
if (data == NULL)
{
fprintf(stderr, "%s\n", errorStr);
exit(-1);
}
}
else
{
fprintf(stderr, "Invalid pattern method %s\n");
exit(-1);
}
/* Create output file */
io = nitf_IOHandle_create(argv[2],
NITF_ACCESS_WRITEONLY, NITF_CREATE | NITF_TRUNCATE, &error);
if (NITF_INVALID_HANDLE(io))
{
nitf_Error_print(&error, stderr, "Error creating output file");
exit(1);
}
/* Create the ImageIO structure */
/* What about segment length in write ?? */
image = nitf_ImageIO_construct(subheader, 0, 0, NULL, NULL, &error);
if (image == NULL)
{
nitf_Error_print(&error, stderr, "Error creating ImageIO");
exit(1);
}
/* Setup for write */
nitf_ImageIO_setPadPixel(image, newArgs->padValue,
NITF_NBPP_TO_BYTES(newArgs->nBits));
if (nitf_ImageIO_writeSequential(image, io, &error) == 0)
{
nitf_Error_print(&error, stderr, "Error creating ImageIO");
exit(1);
}
/* Write rows */
for (row = 0;row < newArgs->nRows;row++)
{
for (band = 0;band < newArgs->nBands;band++)
user[band] = (nitf_Uint8 *) & (data[band][row][0]);
if (!nitf_ImageIO_writeRows(image, io, 1, user, &error))
{
nitf_Error_print(&error, stderr, "Writing rows");
exit(1);
}
}
if (!nitf_ImageIO_writeDone(image, io, &error))
{
nitf_Error_print(&error, stderr, "Writing rows");
exit(1);
}
/* Destroy things */
test_nitf_ImageIO_freeArray(data);
nitf_ImageIO_destruct(&image);
nitf_IOHandle_close(io);
exit(0);
}
int main(int argc, char **argv)
{
nitf_Reader* reader; /* The reader object */
nitf_Writer* writer; /* The writer object */
nitf_Record* record; /* a record object */
nitf_Record* record2;
nitf_ListIterator iter; /* current pos iterator */
nitf_ListIterator end; /* end of list iterator */
nitf_ImageSegment* segment; /* the image segment */
NITF_BOOL success; /* status bool */
nitf_IOHandle input_io; /* input IOHandle */
nitf_IOHandle output_io; /* output IOHandle */
nitf_Error error; /* error object */
/* Check argv and make sure we are happy */
if (argc != 3)
{
printf("Usage: %s <input-file> <output-file> \n", argv[0]);
exit(EXIT_FAILURE);
}
input_io = nitf_IOHandle_create(argv[1],
NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING, &error);
if ( NITF_INVALID_HANDLE(input_io))
{
goto CATCH_ERROR;
}
output_io = nitf_IOHandle_create(argv[2],
NITF_ACCESS_WRITEONLY,
NITF_CREATE | NITF_TRUNCATE,
&error);
if ( NITF_INVALID_HANDLE(output_io))
{
goto CATCH_ERROR;
}
reader = nitf_Reader_construct(&error);
if (!reader)
{
goto CATCH_ERROR;
}
writer = nitf_Writer_construct(&error);
if (!writer)
{
goto CATCH_ERROR;
}
record = nitf_Record_construct(&error);
if (!record)
{
goto CATCH_ERROR;
}
assert(nitf_Reader_read(reader, input_io, record, &error));
showFileHeader(record->header);
/* Write to the file */
success = nitf_Writer_writeHeader(writer, record->header, output_io, &error);
if (!success) goto CATCH_ERROR;
/* ------ IMAGES ------ */
iter = nitf_List_begin(record->images);
end = nitf_List_end(record->images);
while (nitf_ListIterator_notEqualTo(&iter, &end))
{
/* Cast it to an imageSegment... */
segment = (nitf_ImageSegment*)nitf_ListIterator_get(&iter);
/* write the image subheader */
if (!nitf_Writer_writeImageSubheader(writer,
segment->subheader,
record->header->NITF_FVER->raw,
output_io,
&error))
{
goto CATCH_ERROR;
}
/* Now, write the image */
if (!writeImage(segment, input_io, output_io))
{
goto CATCH_ERROR;
}
nitf_ListIterator_increment(&iter);
}
nitf_IOHandle_close(input_io);
nitf_IOHandle_close(output_io);
nitf_Record_destruct(&record);
nitf_Writer_destruct(&writer);
/* Open the file we just wrote to, and dump it to screen */
input_io = nitf_IOHandle_create(argv[2],
NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING,
&error);
if (NITF_INVALID_HANDLE(input_io))
{
goto CATCH_ERROR;
}
record2 = nitf_Record_construct(&error);
if (!record2)
{
goto CATCH_ERROR;
}
assert(nitf_Reader_readHeader(reader, input_io, record2, &error));
showFileHeader(record2->header);
nitf_IOHandle_close(input_io);
nitf_Record_destruct(&record2);
nitf_Reader_destruct(&reader);
return 0;
CATCH_ERROR:
if (input_io) nitf_IOHandle_close(input_io);
if (output_io) nitf_IOHandle_close(output_io);
if (record2) nitf_Record_destruct(&record2);
if (reader) nitf_Reader_destruct(&reader);
if (record) nitf_Record_destruct(&record);
if (writer) nitf_Writer_destruct(&writer);
nitf_Error_print(&error, stdout, "Exiting...");
exit(EXIT_FAILURE);
}
/* this writes the data extension data from a data segment to a file */
void writeDEData(nitf_DESegment * segment,
const char *fileName,
nitf_SegmentReader * reader,
int DENumber, nitf_Error * error)
{
#define DE_READ_SIZE 16*1024
/*XXX
size_t toRead = DE_READ_SIZE;
size_t leftToRead;
size_t amtToRead;
*/
nitf_Uint64 toRead = DE_READ_SIZE;
nitf_Uint64 leftToRead;
nitf_Uint64 amtToRead;
char * buf = NULL;
char * outName = NULL;
nitf_IOHandle file;
leftToRead = (size_t)(segment->end - segment->offset);
fprintf(stderr, "XXX Data Ext write %llu %llu %llu\n", leftToRead, segment->end , segment->offset);
buf = (char*)NITF_MALLOC(toRead + 1);
if (!buf)
{
nitf_Error_init(error, NITF_STRERROR(NITF_ERRNO),
NITF_CTXT, NITF_ERR_MEMORY);
return;
}
fprintf(stderr, "XXX Data Ext A\n");
/* Make file output file anme and create */
outName = makeBandName(fileName, "DE", DENumber, -1);
fprintf(stderr, "XXX Data Ext names %s %s\n", fileName, outName);
file = nitf_IOHandle_create(outName, NITF_ACCESS_WRITEONLY,
NITF_CREATE, error);
freeBandName(&outName);
fprintf(stderr, "XXX Data Ext B\n");
if (NITF_INVALID_HANDLE(file))
{
goto CATCH_ERROR;
}
/* get the data and write to file */
while (leftToRead > 0)
{
fprintf(stderr, "XXX Data Ext C\n");
amtToRead = DE_READ_SIZE;
if (amtToRead > leftToRead)
amtToRead = leftToRead;
fprintf(stderr, "XXX Data Ext C2 %llu\n", amtToRead);
if (nitf_SegmentReader_read(reader, buf, (size_t)amtToRead, error) != NITF_SUCCESS)
{
/* TODO populate error */
goto CATCH_ERROR;
}
fprintf(stderr, "XXX Data Ext D %llu\n", amtToRead);
if (!nitf_IOHandle_write(file, (const char*)buf, (size_t)amtToRead, error))
goto CATCH_ERROR;
fprintf(stderr, "XXX Data Ext E\n");
leftToRead -= amtToRead;
}
nitf_IOHandle_close(file);
CATCH_ERROR:
if (buf) NITF_FREE(buf);
return;
}
int main(int argc, char *argv[])
{
nitf_ImageIO *nitf; /* The parent nitf_ImageIO object */
char errorBuf[NITF_MAX_EMESSAGE]; /* Error buffer */
nitf_Uint8 **user; /* User buffer list */
int padded; /* Pad pixel present flag */
nitf_IOHandle fileHandle; /* I/O handle for reads */
int ofd; /* File descriptor for writes */
FILE *vector; /* FILE for reading vectors */
test_nitf_ImageIOConstructArgs *newArgs;/* Arguments for new */
test_nitf_ImageIOReadArgs *readArgs; /* Arguments for read */
nitf_ImageSubheader *subheader; /* For constructor */
size_t subWindowSize; /* Sub-window pixel count */
nitf_SubWindow *subWindow; /* Argument for read */
nitf_DownSampler* downSampler; /* Down-sample object */
char *error; /* Error message return */
nitf_Error errorObjActual; /* Error object instance */
nitf_Error *errorObj; /* Error object (pointer) */
int i;
errorObj = &errorObjActual;
/* Usage */
if (argc < 2)
{
fprintf(stderr,
"Usage: %s imageVector readVector band0Out band1Out ... >result\n", argv[0]);
exit(0);
}
/* Read image and read parameters from first and second arguments */
vector = fopen(argv[1], "r");
if (vector == NULL)
{
fprintf(stderr, "Error opening image vector file %s\n", argv[0]);
exit(-1);
}
newArgs = test_nitf_ImageIOReadConstructArgs(vector, &error);
if (newArgs == NULL)
{
fprintf(stderr, "%s\n", error);
exit(-1);
}
fclose(vector);
vector = fopen(argv[2], "r");
if (vector == NULL)
{
fprintf(stderr, "Error opening read vector file %s\n", argv[0]);
exit(-1);
}
readArgs = test_nitf_ImageIOReadReadArgs(vector, &error);
if (readArgs == NULL)
{
fprintf(stderr, "%s\n", error);
exit(-1);
}
fclose(vector);
/* Allocate user buffers */
subWindowSize = (readArgs->nRows) * (readArgs->nColumns) * (newArgs->nBits / 8);
user = (nitf_Uint8 **) malloc(sizeof(nitf_Uint8 *) * (readArgs->nBands));
if (user == NULL)
{
fprintf(stderr, "Error allocating user buffer\n");
exit(-1);
}
for (i = 0;i < readArgs->nBands;i++)
{
user[i] = (nitf_Uint8 *) malloc(subWindowSize);
if (user[i] == NULL)
{
fprintf(stderr, "Error allocating user buffer\n");
exit(-1);
}
}
/* Create a fake image subheader to give to ImageIO constructor */
subheader = test_nitf_ImageIO_fakeSubheader(newArgs, &error);
if (subheader == NULL)
{
fprintf(stderr, "%s", error);
exit(-1);
}
/* Create the ImageIO */
nitf = nitf_ImageIO_construct(subheader, newArgs->offset,
0,/*length, must be correct for decompression */
NULL, NULL, errorObj);
if (nitf == NULL)
{
fprintf(stderr, "NtfBlk new failed: %s\n", errorBuf);
fprintf(stderr, "Err: %s\n", errorObj->message);
exit(0);
}
nitf_ImageIO_setPadPixel(nitf, newArgs->padValue,
NITF_NBPP_TO_BYTES(newArgs->nBits));
nitf_ImageIO_print(nitf, stdout);
/* Open input file */
fileHandle = nitf_IOHandle_create(readArgs->name,
NITF_ACCESS_READONLY, 0, errorObj);
if (NITF_INVALID_HANDLE(fileHandle))
{
nitf_Error_init(errorObj, "File open failed",
NITF_CTXT, NITF_ERR_OPENING_FILE);
nitf_Error_print(errorObj, stderr, "File open failed");
exit(0);
}
/* Setup for read (create and initialize sub-window object */
if ((subWindow = nitf_SubWindow_construct(errorObj)) == NULL)
{
nitf_Error_init(errorObj, "Sub-window object construct failed",
NITF_CTXT, NITF_ERR_INVALID_OBJECT);
nitf_Error_print(errorObj, stderr, "Sub-window object construct failed");
nitf_IOHandle_close(fileHandle);
nitf_ImageIO_destruct(&nitf);
exit(0);
}
subWindow->startRow = readArgs->row;
subWindow->numRows = readArgs->nRows;
subWindow->startCol = readArgs->column;
subWindow->numCols = readArgs->nColumns;
subWindow->bandList = readArgs->bands;
subWindow->numBands = readArgs->nBands;
if ((readArgs->rowSkip != 1) || (readArgs->columnSkip != 1))
{
if (strcmp(readArgs->downSample, "pixelSkip") == 0)
{
if ((downSampler = nitf_PixelSkip_construct(
readArgs->rowSkip, readArgs->columnSkip, errorObj)) == NULL)
{
nitf_Error_init(errorObj, "Down-sampler object construct failed",
NITF_CTXT, NITF_ERR_INVALID_OBJECT);
nitf_Error_print(errorObj, stderr,
"Down-sampler object construct failed");
nitf_IOHandle_close(fileHandle);
nitf_ImageIO_destruct(&nitf);
nitf_SubWindow_destruct(&subWindow);
exit(0);
}
if (nitf_SubWindow_setDownSampler(
subWindow, downSampler, errorObj) == NITF_FAILURE)
{
nitf_Error_init(errorObj, "Read failed",
NITF_CTXT, NITF_ERR_READING_FROM_FILE);
nitf_Error_print(errorObj, stderr, "Read failed");
nitf_IOHandle_close(fileHandle);
nitf_ImageIO_destruct(&nitf);
nitf_SubWindow_destruct(&subWindow);
nitf_DownSampler_destruct(&downSampler);
exit(0);
}
}
else if (strcmp(readArgs->downSample, "max") == 0)
{
if ((downSampler = nitf_MaxDownSample_construct(
readArgs->rowSkip, readArgs->columnSkip, errorObj)) == NULL)
{
nitf_Error_init(errorObj, "Down-sampler object construct failed",
NITF_CTXT, NITF_ERR_INVALID_OBJECT);
nitf_Error_print(errorObj, stderr,
"Down-sampler object construct failed");
nitf_IOHandle_close(fileHandle);
nitf_ImageIO_destruct(&nitf);
nitf_SubWindow_destruct(&subWindow);
exit(0);
}
if (nitf_SubWindow_setDownSampler(
subWindow, downSampler, errorObj) == NITF_FAILURE)
{
nitf_Error_init(errorObj, "Read failed",
NITF_CTXT, NITF_ERR_READING_FROM_FILE);
nitf_Error_print(errorObj, stderr, "Read failed");
nitf_IOHandle_close(fileHandle);
nitf_ImageIO_destruct(&nitf);
nitf_SubWindow_destruct(&subWindow);
nitf_DownSampler_destruct(&downSampler);
exit(0);
}
}
else if (strcmp(readArgs->downSample, "sumSq2") == 0)
{
if ((downSampler = nitf_SumSq2DownSample_construct(
readArgs->rowSkip, readArgs->columnSkip, errorObj)) == NULL)
{
nitf_Error_init(errorObj, "Down-sampler object construct failed",
NITF_CTXT, NITF_ERR_INVALID_OBJECT);
nitf_Error_print(errorObj, stderr,
"Down-sampler object construct failed");
nitf_IOHandle_close(fileHandle);
nitf_ImageIO_destruct(&nitf);
nitf_SubWindow_destruct(&subWindow);
exit(0);
}
if (nitf_SubWindow_setDownSampler(
subWindow, downSampler, errorObj) == NITF_FAILURE)
{
nitf_Error_init(errorObj, "Read failed",
NITF_CTXT, NITF_ERR_READING_FROM_FILE);
nitf_Error_print(errorObj, stderr, "Read failed");
nitf_IOHandle_close(fileHandle);
nitf_ImageIO_destruct(&nitf);
nitf_SubWindow_destruct(&subWindow);
nitf_DownSampler_destruct(&downSampler);
exit(0);
}
}
else if (strcmp(readArgs->downSample, "select2") == 0)
{
if ((downSampler = nitf_Select2DownSample_construct(
readArgs->rowSkip, readArgs->columnSkip, errorObj)) == NULL)
{
nitf_Error_init(errorObj, "Down-sampler object construct failed",
NITF_CTXT, NITF_ERR_INVALID_OBJECT);
nitf_Error_print(errorObj, stderr,
"Down-sampler object construct failed");
nitf_IOHandle_close(fileHandle);
nitf_ImageIO_destruct(&nitf);
nitf_SubWindow_destruct(&subWindow);
exit(0);
}
if (nitf_SubWindow_setDownSampler(
subWindow, downSampler, errorObj) == NITF_FAILURE)
{
nitf_Error_init(errorObj, "Read failed",
NITF_CTXT, NITF_ERR_READING_FROM_FILE);
nitf_Error_print(errorObj, stderr, "Read failed");
nitf_IOHandle_close(fileHandle);
nitf_ImageIO_destruct(&nitf);
nitf_SubWindow_destruct(&subWindow);
nitf_DownSampler_destruct(&downSampler);
exit(0);
}
}
else
{
nitf_Error_init(errorObj, "Invalid down-sample method",
NITF_CTXT, NITF_ERR_INVALID_PARAMETER);
nitf_Error_fprintf(errorObj, stderr,
"Invalid down-sample method: %s\n", readArgs->downSample);
nitf_IOHandle_close(fileHandle);
nitf_ImageIO_destruct(&nitf);
nitf_SubWindow_destruct(&subWindow);
exit(0);
}
}
/* Read sub-window */
if (!nitf_ImageIO_read(nitf, fileHandle, subWindow, user, &padded, errorObj))
{
nitf_Error_print(errorObj, stderr, "Read failed");
nitf_IOHandle_close(fileHandle);
nitf_ImageIO_destruct(&nitf);
nitf_SubWindow_destruct(&subWindow);
exit(0);
}
nitf_SubWindow_destruct(&subWindow);
nitf_IOHandle_close(fileHandle);
printf("Padded = %d\n", padded);
/* Write result */
for (i = 0;i < readArgs->nBands;i++)
{
if ((ofd = open(argv[3+i], O_WRONLY | O_CREAT | O_TRUNC, 0666)) == -1)
{
fprintf(stderr, "Output file %d open failed\n", i);
exit(0);
}
write(ofd, user[i], subWindowSize);
close(ofd);
}
return 0;
}
void manuallyWriteImageBands(nitf_ImageSegment * segment,
const char *imageName,
nitf_ImageReader * deserializer,
int imageNumber, nitf_Error * error)
{
char *file;
nitf_Uint32 nBits, nBands, xBands, nRows, nColumns;
size_t subimageSize;
nitf_SubWindow *subimage;
unsigned int i;
int padded;
nitf_Uint8 **buffer = NULL;
nitf_Uint32 band;
nitf_Uint32 *bandList = NULL;
NITF_TRY_GET_UINT32(segment->subheader->numBitsPerPixel, &nBits,
error);
NITF_TRY_GET_UINT32(segment->subheader->numImageBands, &nBands, error);
NITF_TRY_GET_UINT32(segment->subheader->numMultispectralImageBands,
&xBands, error);
nBands += xBands;
NITF_TRY_GET_UINT32(segment->subheader->numRows, &nRows, error);
NITF_TRY_GET_UINT32(segment->subheader->numCols, &nColumns, error);
subimageSize = nRows * nColumns * NITF_NBPP_TO_BYTES(nBits);
printf("Image number: %d\n", imageNumber);
printf("NBANDS -> %d\n"
"XBANDS -> %d\n"
"NROWS -> %d\n"
"NCOLS -> %d\n"
"PVTYPE -> %.*s\n"
"NBPP -> %.*s\n"
"ABPP -> %.*s\n"
"PJUST -> %.*s\n"
"IMODE -> %.*s\n"
"NBPR -> %.*s\n"
"NBPC -> %.*s\n"
"NPPBH -> %.*s\n"
"NPPBV -> %.*s\n"
"IC -> %.*s\n"
"COMRAT -> %.*s\n",
nBands,
xBands,
nRows,
nColumns,
(int)segment->subheader->pixelValueType->length,
segment->subheader->pixelValueType->raw,
(int)segment->subheader->numBitsPerPixel->length,
segment->subheader->numBitsPerPixel->raw,
(int)segment->subheader->actualBitsPerPixel->length,
segment->subheader->actualBitsPerPixel->raw,
(int)segment->subheader->pixelJustification->length,
segment->subheader->pixelJustification->raw,
(int)segment->subheader->imageMode->length,
segment->subheader->imageMode->raw,
(int)segment->subheader->numBlocksPerRow->length,
segment->subheader->numBlocksPerRow->raw,
(int)segment->subheader->numBlocksPerCol->length,
segment->subheader->numBlocksPerCol->raw,
(int)segment->subheader->numPixelsPerHorizBlock->length,
segment->subheader->numPixelsPerHorizBlock->raw,
(int)segment->subheader->numPixelsPerVertBlock->length,
segment->subheader->numPixelsPerVertBlock->raw,
(int)segment->subheader->imageCompression->length,
segment->subheader->imageCompression->raw,
(int)segment->subheader->compressionRate->length,
segment->subheader->compressionRate->raw);
buffer = (nitf_Uint8 **) malloc(sizeof(nitf_Uint8*) * nBands);
band = 0;
bandList = (nitf_Uint32 *) malloc(sizeof(nitf_Uint32 *) * nBands);
subimage = nitf_SubWindow_construct(error);
assert(subimage);
subimage->startCol = 0;
subimage->startRow = 0;
subimage->numRows = nRows;
subimage->numCols = nColumns;
for (band = 0; band < nBands; band++)
bandList[band] = band;
subimage->bandList = bandList;
subimage->numBands = nBands;
assert(buffer);
for (i = 0; i < nBands; i++)
{
buffer[i] = (nitf_Uint8 *) malloc(subimageSize);
assert(buffer[i]);
}
/* This should change to returning failures! */
/*
if (! nitf_ImageIO_read(segment->imageIO, io, &subimage, buffer, &padded,
error) )
{
nitf_Error_print(error, stderr, "Read failed");
goto CATCH_ERROR;
}
*/
if (!nitf_ImageReader_read
(deserializer, subimage, buffer, &padded, error))
{
nitf_Error_print(error, stderr, "Read failed");
goto CATCH_ERROR;
}
for (i = 0; i < nBands; i++)
{
nitf_IOHandle toFile;
file = makeBandName(imageName, "img", imageNumber, i);
toFile = nitf_IOHandle_create(file, NITF_ACCESS_WRITEONLY,
NITF_CREATE, error);
freeBandName(&file);
if (NITF_INVALID_HANDLE(toFile))
{
goto CATCH_ERROR;
}
if (!nitf_IOHandle_write(toFile,
(const char *) buffer[i],
subimageSize, error))
{
goto CATCH_ERROR;
}
nitf_IOHandle_close(toFile);
}
/* free buffers */
for (i = 0; i < nBands; i++)
{
free(buffer[i]);
}
free(buffer);
free(bandList);
nitf_SubWindow_destruct(&subimage);
return;
CATCH_ERROR:
/* free buffers */
for (i = 0; i < nBands; i++)
{
free(buffer[i]);
}
free(buffer);
free(bandList);
nitf_Error_print(error, stderr, "Manual write failed");
}
int main(int argc, char **argv)
{
/* Get the error object */
nitf_Error error;
/* so I can remember what Im doing with args */
const char* treName;
const char* fieldName;
/* This is the reader object */
nitf_Reader *reader;
nitf_Record *record;
/* The IO handle */
nitf_IOHandle io;
int num;
/* Check argv and make sure we are happy */
if (argc != 4)
{
printf("Usage: %s <nitf-file> <TRE> <field>\n", argv[0]);
exit(EXIT_FAILURE);
}
if (nitf_Reader_getNITFVersion(argv[1]) == NITF_VER_UNKNOWN)
{
printf("File: %s is not a NITF\n", argv[1]);
exit(EXIT_FAILURE);
}
treName = argv[2];
fieldName = argv[3];
io = nitf_IOHandle_create(argv[1], NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING, &error);
if (NITF_INVALID_HANDLE(io))
{
nitf_Error_print(&error, stdout, "Exiting...");
exit(EXIT_FAILURE);
}
reader = nitf_Reader_construct(&error);
if (!reader)
{
nitf_Error_print(&error, stdout, "Exiting (1) ...");
exit(EXIT_FAILURE);
}
#if NITF_VERBOSE_READER
printf("Here are the loaded handlers\n");
printf("* * * * * * * * * * * * * * * *\n");
nitf_HashTable_print(reader->reg->treHandlers);
printf("* * * * * * * * * * * * * * * *\n");
#endif
record = nitf_Reader_read(reader, io, &error);
lookForTREField(record->header->extendedSection, treName, fieldName);
lookForTREField(record->header->userDefinedSection, treName, fieldName);
if (!nitf_Field_get(record->header->numImages,
&num, NITF_CONV_INT, NITF_INT32_SZ, &error))
goto CATCH_ERROR;
/* And now show the image information */
if (num > 0)
{
/* Walk each image and show */
nitf_ListIterator iter = nitf_List_begin(record->images);
nitf_ListIterator end = nitf_List_end(record->images);
while (nitf_ListIterator_notEqualTo(&iter, &end))
{
nitf_ImageSegment *segment =
(nitf_ImageSegment *) nitf_ListIterator_get(&iter);
lookForTREField(segment->subheader->extendedSection, treName, fieldName);
lookForTREField(segment->subheader->userDefinedSection, treName, fieldName);
nitf_ListIterator_increment(&iter);
}
}
else
{
printf("No image in file!\n");
}
nitf_IOHandle_close(io);
nitf_Record_destruct(&record);
nitf_Reader_destruct(&reader);
return 0;
CATCH_ERROR:
printf("!!! we had a problem reading the file !!!\n");
nitf_Error_print(&error, stdout, "Exiting...");
exit(EXIT_FAILURE);
}
nitf_Record *doRead(const char *inFile)
{
/* This is the error we hopefully wont receive */
nitf_Error e;
/* This is the reader */
nitf_Reader *reader;
/* This is the record of the file we are reading */
nitf_Record *record;
/* This is the io handle we will give the reader to parse */
nitf_IOHandle io;
int count = 0;
int numImages;
int numTexts;
int numDataExtensions;
nitf_ListIterator iter;
nitf_ListIterator end;
nitf_ImageSegment *imageSegment = NULL;
nitf_ImageReader *deserializer = NULL;
nitf_TextSegment *textSegment = NULL;
nitf_DESegment *deSegment = NULL;
nitf_SegmentReader *segmentReader = NULL;
nitf_SegmentReader *deReader = NULL;
reader = nitf_Reader_construct(&e);
if (!reader)
{
nitf_Error_print(&e, stderr, "nitf::Reader::construct() failed");
exit(EXIT_FAILURE);
}
/* If you did, though, we'll be nice and open it for you */
io = nitf_IOHandle_create(inFile,
NITF_ACCESS_READONLY,
NITF_OPEN_EXISTING, &e);
/* But, oh boy, if you gave us a bad location...! */
if (NITF_INVALID_HANDLE(io))
{
/* You had this coming! */
nitf_Error_print(&e, stderr, "nitf::IOHandle::create() failed");
exit(EXIT_FAILURE);
}
/* Read the file */
record = nitf_Reader_read(reader, io, &e);
if (!record)
{
nitf_Error_print(&e, stderr, "nitf::Reader::read() failed");
exit(EXIT_FAILURE);
}
if (!nitf_Field_get
(record->header->numImages, &numImages, NITF_CONV_INT,
NITF_INT32_SZ, &e))
{
nitf_Error_print(&e, stderr, "nitf::Field::get() failed");
numImages = 0;
}
if (!nitf_Field_get
(record->header->numTexts, &numTexts, NITF_CONV_INT,
NITF_INT32_SZ, &e))
{
nitf_Error_print(&e, stderr, "nitf::Field::get() failed");
numTexts = 0;
}
if (!nitf_Field_get
(record->header->numDataExtensions, &numDataExtensions, NITF_CONV_INT,
NITF_INT32_SZ, &e))
{
nitf_Error_print(&e, stderr, "nitf::Field::get() failed");
numDataExtensions = 0;
}
if (record->images)
{
end = nitf_List_end(record->images);
for (count = 0; count < numImages; ++count)
{
iter = nitf_List_at(record->images, count);
if (nitf_ListIterator_equals(&iter, &end))
{
printf("Out of bounds on iterator [%d]!\n", count);
exit(EXIT_FAILURE);
}
imageSegment = (nitf_ImageSegment *) nitf_ListIterator_get(&iter);
deserializer = nitf_Reader_newImageReader(reader, count, &e);
if (!deserializer)
{
nitf_Error_print(&e, stderr, "Couldnt spawn deserializer");
exit(EXIT_FAILURE);
}
printf("Writing image %d... ", count);
/* Write the thing out */
manuallyWriteImageBands(imageSegment, inFile, deserializer, count,
&e);
nitf_ImageReader_destruct(&deserializer);
printf("done.\n");
/* Increment the iterator so we can continue */
nitf_ListIterator_increment(&iter);
}
}
/* loop over texts and read the data to a file */
if (record->texts)
{
end = nitf_List_end(record->texts);
for (count = 0; count < numTexts; ++count)
{
iter = nitf_List_at(record->texts, count);
if (nitf_ListIterator_equals(&iter, &end))
{
printf("Out of bounds on iterator [%d]!\n", count);
exit(EXIT_FAILURE);
}
textSegment = (nitf_TextSegment *) nitf_ListIterator_get(&iter);
segmentReader = nitf_Reader_newTextReader(reader, count, &e);
if (!segmentReader)
{
nitf_Error_print(&e, stderr, "Couldnt spawn deserializer");
exit(EXIT_FAILURE);
}
printf("Writing text %d... ", count);
/* Write the thing out */
writeTextData(textSegment, inFile, segmentReader, count, &e);
nitf_SegmentReader_destruct(&segmentReader);
/* Increment the iterator so we can continue */
nitf_ListIterator_increment(&iter);
}
}
/*XXX*/
/* loop over data extensions and read the data to a file */
if (record->dataExtensions)
{
fprintf(stderr, "XXX Data Ext %d\n", numDataExtensions);
end = nitf_List_end(record->dataExtensions);
for (count = 0; count < numDataExtensions; ++count)
{
iter = nitf_List_at(record->dataExtensions, count);
if (nitf_ListIterator_equals(&iter, &end))
{
printf("Out of bounds on iterator [%d]!\n", count);
exit(EXIT_FAILURE);
}
deSegment = (nitf_DESegment *) nitf_ListIterator_get(&iter);
deReader = nitf_Reader_newDEReader(reader, count, &e);
if (!deReader)
{
nitf_Error_print(&e, stderr, "Couldnt spawn deserializer");
exit(EXIT_FAILURE);
}
printf("Writing data extension %d... ", count);
/* Write the thing out */
writeDEData(deSegment, inFile, deReader, count, &e);
nitf_SegmentReader_destruct(&segmentReader);
/* Increment the iterator so we can continue */
nitf_ListIterator_increment(&iter);
}
}
nitf_Reader_destruct(&reader);
return record;
}
int main(int argc, char *argv[])
{
char *vectorFile; /* Vector file name */
char *inputFile; /* Input file name */
char *outputFile; /* Output file name */
FILE *vector; /* File stream for input vector */
/* Arguments for new */
test_nitf_ImageIOConstructArgs *newArgs;
/* Arguments for read */
test_nitf_ImageIOReadArgs *readArgs;
char *errorStr; /* Error string */
nitf_Record *record; /* Record used for input and output */
nitf_FileHeader *fileHdr; /* File header */
nitf_ImageSegment *imgSeg; /* New image segment */
nitf_Writer *writer; /* Writer for output */
nitf_ImageWriter *imgWriter; /* Image writer */
nitf_ImageSource *imgSource; /* Image source */
nitf_IOHandle out; /* Handle for output */
nitf_Error error; /* Error object */
nitf_Uint8 ***data; /* Generated data [band][row][col] */
if (argc < 4)
{
fprintf(stderr, "test_make_pattern vector input output\n");
exit(-1);
}
vectorFile = argv[1];
inputFile = argv[2];
outputFile = argv[3];
vector = fopen(vectorFile, "r");
if (vector == NULL)
{
fprintf(stderr, "Error opening vector file %s\n", vectorFile);
exit(-1);
}
newArgs = test_nitf_ImageIOReadConstructArgs(vector, &errorStr);
if (newArgs == NULL)
{
fprintf(stderr, "%s\n", errorStr);
return(-1);
}
fclose(vector);
/* Create the input record which will be used for output */
record = readRecord(inputFile);
/* Setup the image segment */
imgSeg = nitf_Record_newImageSegment(record, &error);
if (imgSeg == NULL)
{
nitf_Error_print(&error, stderr, "Error reading input ");
exit(EXIT_FAILURE);
}
setupImageSubheader(newArgs, record, imgSeg);
/* Create Image */
if (strcmp(newArgs->dataPattern, "brcI4") == 0)
{
data = (nitf_Uint8 ***) test_nitf_ImageIO_brcI4(newArgs, &errorStr);
if (data == NULL)
{
fprintf(stderr, "%s\n", errorStr);
exit(-1);
}
}
else if (strcmp(newArgs->dataPattern, "brcC8") == 0)
{
data = (nitf_Uint8 ***) test_nitf_ImageIO_brcC8(newArgs, &errorStr);
if (data == NULL)
{
fprintf(stderr, "%s\n", errorStr);
exit(-1);
}
}
else if (strncmp(newArgs->dataPattern, "blocks_", 7) == 0)
{
data = (nitf_Uint8 ***) test_nitf_ImageIO_block(newArgs, &errorStr);
if (data == NULL)
{
fprintf(stderr, "%s\n", errorStr);
exit(-1);
}
}
else
{
fprintf(stderr, "Invalid pattern method %s\n");
exit(-1);
}
/* Create output file */
out = nitf_IOHandle_create(outputFile,
NITF_ACCESS_WRITEONLY, NITF_CREATE | NITF_TRUNCATE, &error);
if (NITF_INVALID_HANDLE(out))
{
nitf_Error_print(&error, stderr, "Error creating output file");
exit(1);
}
writer = nitf_Writer_construct(&error);
if (writer == NULL)
{
nitf_Error_print(&error, stderr, "Error creating writer object");
exit(1);
}
if (!nitf_Writer_prepare(writer, record, out, &error))
{
nitf_Error_print(&error, stderr, "Error setting up write");
exit(1);
}
imgWriter = nitf_Writer_newImageWriter(writer, 0, &error);
if (imgWriter == NULL)
{
nitf_Error_print(&error, stderr, "Error setting up write");
exit(1);
}
imgSource = makeImageSource(newArgs, (char ***) data);
nitf_ImageWriter_setWriteCaching(imgWriter, 1);
if (!nitf_ImageWriter_attachSource(imgWriter, imgSource, &error))
{
nitf_Error_print(&error, stderr, "Error setting up write");
exit(1);
}
if (!nitf_Writer_write(writer, &error))
{
nitf_Error_print(&error, stderr, "Error writing up write");
exit(1);
}
/* Destroy things */
test_nitf_ImageIO_freeArray(data);
nitf_IOHandle_close(out);
exit(0);
}
int main(int argc, char *argv[])
{
nitf_Reader *reader; /* Reader object */
nitf_Record *record; /* Record used for input and output */
nitf_IOHandle in; /* Input I/O handle */
nitf_ListIterator imgIter; /* Image segment list iterator */
nitf_ListIterator imgEnd; /* Image segment list iterator */
nitf_ImageSegment *seg; /* Image segment object */
nitf_ImageSubheader *subhdr; /* Image subheader object */
nitf_ImageReader *iReader; /* Image reader */
nitf_BlockingInfo *blkInfo; /* Blocking information */
static nitf_Error errorObj; /* Error object for messages */
nitf_Error *error; /* Pointer to the error object */
/* Image information */
char imageMode[NITF_IMODE_SZ+1]; /* Image (blocking) mode */
/* Mask structure and mask components */
nitf_Uint32 imageDataOffset; /* Offset to actual image data past masks */
nitf_Uint32 blockRecordLength; /* Block mask record length */
nitf_Uint32 padRecordLength; /* Pad mask record length */
nitf_Uint32 padPixelValueLength; /* Pad pixel value length in bytes */
nitf_Uint8 *padValue; /* Pad value */
nitf_Uint64 *blockMask; /* Block mask array */
nitf_Uint64 *padMask; /* Pad mask array */
size_t imgCtr = 0;
const char* pathname;
error = &errorObj;
if (argc != 2)
{
fprintf(stderr, "Usage %s inputFile\n", argv[0]);
exit(EXIT_FAILURE);
}
pathname = argv[1];
/* Get the input record */
in = nitf_IOHandle_create(pathname,
NITF_ACCESS_READONLY, NITF_OPEN_EXISTING, error);
if (NITF_INVALID_HANDLE(in))
{
nitf_Error_print(error, stderr, "Error opening input ");
exit(EXIT_FAILURE);
}
reader = nitf_Reader_construct(error);
if (reader == NULL)
{
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Error creating reader ");
exit(EXIT_FAILURE);
}
record = nitf_Reader_read(reader, in, error);
if (record == NULL)
{
nitf_Reader_destruct(&reader);
nitf_IOHandle_close(in);
nitf_Error_print(error, stderr, "Error reading input ");
exit(EXIT_FAILURE);
}
/* Loop through the image segments */
imgIter = nitf_List_begin(record->images);
imgEnd = nitf_List_end(record->images);
while (nitf_ListIterator_notEqualTo(&imgIter, &imgEnd))
{
/* Get information from the image subheader */
seg = (nitf_ImageSegment *) nitf_ListIterator_get(&imgIter);
if (seg == NULL)
{
fprintf(stderr, "No Image segment\n");
nitf_Reader_destruct(&reader);
nitf_IOHandle_close(in);
exit(EXIT_FAILURE);
}
subhdr = seg->subheader;
nitf_Field_get(subhdr->imageMode,
imageMode, NITF_CONV_STRING, NITF_IMODE_SZ + 1, error);
imageMode[NITF_IMODE_SZ] = 0;
/* Get an image reader which creates the nitf_ImageIO were the masks are */
iReader = nitf_Reader_newImageReader(reader, imgCtr, NULL, error);
if (iReader == NULL)
{
nitf_Reader_destruct(&reader);
nitf_IOHandle_close(in);
nitf_Record_destruct(&record);
nitf_Error_print(error, stderr, "Error reading input ");
exit(EXIT_FAILURE);
}
blkInfo = nitf_ImageReader_getBlockingInfo(iReader, error);
if (blkInfo == NULL)
{
nitf_ImageReader_destruct(&iReader);
nitf_Reader_destruct(&reader);
nitf_IOHandle_close(in);
nitf_Record_destruct(&record);
nitf_Error_print(error, stderr, "Error reading input ");
exit(EXIT_FAILURE);
}
/* Print the blocking information */
printf("Image %s segment %zu:\n", pathname, imgCtr);
printf(" Blocking (mode is %s):\n", imageMode);
printf(" Block array dimensions (r,c) = %d %d\n",
blkInfo->numBlocksPerRow, blkInfo->numBlocksPerCol);
printf(" Block dimensions (r,c) = %d,%d\n",
blkInfo->numRowsPerBlock, blkInfo->numColsPerBlock);
printf(" Block length in bytes %zu\n", blkInfo->length);
/* Get the actual information */
if (nitf_ImageIO_getMaskInfo(iReader->imageDeblocker,
&imageDataOffset, &blockRecordLength,
&padRecordLength, &padPixelValueLength,
&padValue, &blockMask, &padMask))
{
nitf_Uint32 i;
printf(" Masked image:\n");
printf(" Image data offset = %d\n", imageDataOffset);
printf(" Block and pad mask record lengths = %u %u\n",
blockRecordLength, padRecordLength);
printf(" Pad value length = %u\n", padPixelValueLength);
printf(" Pad value = ");
for (i = 0;i < padPixelValueLength;i++)
{
printf("%x ", padValue[i]);
}
printf("\n");
if (blockRecordLength != 0)
{
dumpMask("Block",
blockMask,
blkInfo->numBlocksPerRow,
blkInfo->numBlocksPerCol);
}
if (padRecordLength != 0)
{
dumpMask("Pad",
padMask,
blkInfo->numBlocksPerRow,
blkInfo->numBlocksPerCol);
}
}
else
{
printf("Not a masked image\n");
}
nitf_ImageReader_destruct(&iReader);
nrt_ListIterator_increment(&imgIter);
++imgCtr;
}
/* Clean-up */
nitf_Reader_destruct(&reader);
nitf_IOHandle_close(in);
nitf_Record_destruct(&record);
return(0);
}
