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;
}
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);
}
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);
}
