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[])
{
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;
}
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);
}
