NITF_BOOL makeImageSource(imgInfo *img, nitf_Writer *writer, nitf_Error *error)
{
nitf_ImageSource *source; /* Image source for image writer */
nitf_BandSource *bandSource; /* Current band source */
int i;
img->imgWriter = nitf_Writer_newImageWriter(writer, img->index, error);
source = nitf_ImageSource_construct(error);
if (source == NULL)
return(NITF_FAILURE);
for (i = 0;i < img->nBands;i++)
{
bandSource = nitf_MemorySource_construct((char *) (img->buffers[i]),
img->imgSize, (nitf_Off) 0, 0, 0, error);
if (!bandSource)
return(NITF_FAILURE);
if (!nitf_ImageSource_addBand(source, bandSource, error))
return(NITF_FAILURE);
}
img->imgSource = source;
if (!nitf_ImageWriter_attachSource(img->imgWriter, source, error))
return(NITF_FAILURE);
nitf_ImageIO_setPadPixel(img->imgWriter->imageBlocker,
img->padValue, img->bytes);
return(NITF_SUCCESS);
}
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);
}
