/*
* Class: nitf_SubWindow
* Method: construct
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_nitf_SubWindow_construct
(JNIEnv * env, jobject self)
{
nitf_SubWindow *subWindow;
nitf_Error error;
subWindow = nitf_SubWindow_construct(&error);
if (!subWindow)
{
/* throw an error */
_ThrowNITFException(env, error.message);
}
else
{
_SetObj(env, self, subWindow);
}
}
NITF_BOOL readImageSegment(imgInfo *img, nitf_Reader *reader, nitf_Error *error)
{
nitf_Uint32 nBits; /* Bits/pixel */
nitf_Uint32 nBands; /* Number of bands */
nitf_Uint32 xBands; /* Number of extended bands */
nitf_Uint32 nRows; /* Number of rows */
nitf_Uint32 nColumns; /* Number of columns */
size_t subimageSize; /* Image band size in bytes */
nitf_SubWindow *subimage; /* Sub-image object specifying full image */
nitf_DownSampler *pixelSkip; /* Downsample for sub-window */
nitf_Uint32 *bandList; /* List of bands for read */
nitf_Uint32 band; /* Current band */
nitf_Uint8 **buffers; /* Read buffer one/band */
/* Image reader */
nitf_ImageReader *deserializer;
int padded; /* Argument for read */
int i;
/* Get dimension and band info */
nitf_Field_get(img->subhdr->numBitsPerPixel,
&nBits, NITF_CONV_UINT, NITF_INT32_SZ, error);
nitf_Field_get(img->subhdr->numImageBands,
&nBands, NITF_CONV_UINT, NITF_INT32_SZ, error);
nitf_Field_get(img->subhdr->numMultispectralImageBands,
&xBands, NITF_CONV_UINT, NITF_INT32_SZ, error);
nBands += xBands;
nitf_Field_get(img->subhdr->numRows,
&nRows, NITF_CONV_UINT, NITF_INT32_SZ, error);
nitf_Field_get(img->subhdr->numCols,
&nColumns, NITF_CONV_UINT, NITF_INT32_SZ, error);
img->bytes = NITF_NBPP_TO_BYTES(nBits);
subimageSize = nRows * nColumns * img->bytes;
img->imgSize = subimageSize;
/* Setup sub-window */
subimage = nitf_SubWindow_construct(error);
if (subimage == NULL)
return(NITF_FAILURE);
bandList = (nitf_Uint32 *) NITF_MALLOC(sizeof(nitf_Uint32 *) * nBands);
if (bandList == NULL)
return(NITF_FAILURE);
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;
pixelSkip = nitf_PixelSkip_construct(1, 1, error);
if (pixelSkip == NULL)
return(NITF_FAILURE);
if (!nitf_SubWindow_setDownSampler(subimage, pixelSkip, error))
return(NITF_FAILURE);
/* Set-up buffers (one/band) */
buffers = (nitf_Uint8 **) NITF_MALLOC(nBands * sizeof(nitf_Uint8*));
if (buffers == NULL)
return(NITF_FAILURE);
for (i = 0;i < nBands;i++)
{
buffers[i] = (nitf_Uint8 *) malloc(subimageSize);
if (buffers[i] == NULL)
return(NITF_FAILURE);
}
deserializer = nitf_Reader_newImageReader(reader, img->index, error);
if (deserializer == NULL)
return(NITF_FAILURE);
if (!nitf_ImageReader_read(deserializer, subimage, buffers, &padded, error))
return(NITF_FAILURE);
img->nBands = nBands;
img->buffers = buffers;
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;
}
NITF_BOOL writeImage(nitf_ImageSegment* segment, nitf_IOHandle input_io, nitf_IOHandle output_io)
{
nitf_Error error;
nitf_Off offset;
int ret;
nitf_ImageIO* ioClone;
nitf_Uint8** buffer;
nitf_Uint32 nBits, nBands, xBands, nRows, nColumns;
nitf_SubWindow *subimage;
size_t subimageSize;
nitf_Uint32 band;
nitf_Uint32 *bandList;
NITF_BOOL success;
int padded;
nitf_ImageSource *imgSrc; /* Image source object */
nitf_BandSource *bandSrc; /* Current band source object */
/* clone the imageIO */
ioClone = nitf_ImageIO_clone(segment->imageIO, &error);
if (!ioClone)
{
nitf_Error_print(&error, stderr, "Clone failed");
goto CATCH_ERROR;
}
/* get IO offset, and set the offset for the ImageIO */
offset = nitf_IOHandle_tell(output_io, &error);
if (!NITF_IO_SUCCESS(offset)) goto CATCH_ERROR;
if (!nitf_ImageIO_setFileOffset(segment->imageIO, offset, &error))
{
goto CATCH_ERROR;
}
/* Read image */
GET_UINT32(segment->subheader->numBitsPerPixel, &nBits, &error);
GET_UINT32(segment->subheader->numImageBands, &nBands, &error);
GET_UINT32(segment->subheader->numMultispectralImageBands, &xBands, &error);
nBands += xBands;
GET_UINT32(segment->subheader->numRows, &nRows, &error);
GET_UINT32(segment->subheader->numCols, &nColumns, &error);
subimageSize = nRows * nColumns * NITF_NBPP_TO_BYTES(nBits);
/* Allcoate buffers */
buffer = (nitf_Uint8 **)malloc(8 * nBands);
assert(buffer);
for (band = 0; band < nBands; band++)
{
buffer[band] = (nitf_Uint8*)malloc(subimageSize);
assert(buffer[band]);
}
/* Set-up band array and subimage */
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;
/* Read data */
if (!nitf_ImageIO_read(ioClone,
input_io, subimage, buffer, &padded, &error) )
{
nitf_Error_print(&error, stderr, "Read failed");
return(0);
}
free(bandList);
/* Setup for image source */
imgSrc = nitf_ImageSource_construct(&error);
if (imgSrc == NULL)
return(0);
for (band = 0; band < nBands; band++)
{
bandSrc = nitf_MemorySource_construct(buffer[band], (size_t) subimageSize,
(nitf_Off) 0, NITF_NBPP_TO_BYTES(nBits), 0, &error);
if (bandSrc == NULL)
return(0);
if (!nitf_ImageSource_addBand(imgSrc, bandSrc, &error))
return(0);
}
/* Do write */
ret = doWrite(segment, imgSrc, output_io, ioClone);
if (ioClone) nitf_ImageIO_destruct(&ioClone);
nitf_ImageSource_destruct(&imgSrc);
/* OK return */
return ret;
CATCH_ERROR:
if (ioClone) nitf_ImageIO_destruct(&ioClone);
printf("ERROR processing\n");
return 0;
}
int main(int argc, char** argv)
{
try
{
nitf_Error e;
// Foo<int>* foo = new Bar<int>();
// delete foo;
nitf_Field* cField = nitf_Field_construct(100, NITF_BCS_N, &e);
nitf::Field field(cField);
{
nitf::Field field2(cField);
}
std::cout << field.isValid() << std::endl;
nitf_BandInfo* cBandInfo = nitf_BandInfo_construct(&e);
assert(cBandInfo);
nitf::BandInfo info(cBandInfo);
std::cout << (int)info.getNumLUTs() << std::endl;
std::cout << "HERE!!!!!!!!!!!!!!!!!!!!" << std::endl;
nitf::SubWindow sub;
nitf::SubWindow sub2 = sub;
sub.setNumRows(5);
nitf::PixelSkip p(1, 1);
sub.setDownSampler(p);
sub.setDownSampler(p);
sub.setDownSampler(p);
sub.setDownSampler(p);
nitf::PixelSkip p2(1, 1);
sub.setDownSampler(p2);
sub.setDownSampler(p);
nitf_SubWindow* subw = nitf_SubWindow_construct(&e);
nitf::SubWindow sub3(subw);
std::cout << sub.getNumRows() << " == " << sub2.getNumRows() << std::endl;
nitf::List list;
nitf::List list2 = list;
{
nitf::FileHeader header;
nitf::FileHeader header2(header.clone());
//should be not equal
std::cout << "Equal? " << (header == header2) << std::endl;
nitf::FileHeader header3(header2);
//these two should be equal
std::cout << "Equal? " << (header3 == header2) << std::endl;
}
nitf::HashTable hash;
nitf::Extensions extensions;
{
nitf::ImageSegment imageSeg;
nitf::ImageSubheader imageSub;
imageSeg.getSubheader().getImageId() = "Test Image";
std::cout << imageSeg.getSubheader().getImageId().toString() << std::endl;
nitf::Field f = imageSeg.getSubheader().getImageId();
std::cout << f.toString() << std::endl;
nitf::ImageSegment imageSeg2 = imageSeg.clone();
nitf::ImageSubheader imageSub2(imageSub.clone());
extensions = imageSub.getExtendedSection();
}
nitf::TextSegment tSeg;
nitf::TextSubheader tSub;
nitf::GraphicSegment gSeg;
nitf::GraphicSubheader gSub;
nitf::DESegment dSeg;
nitf::DESubheader dSub;
nitf::LabelSegment rSeg;
nitf::LabelSubheader rSub;
nitf::TRE tre("JITCID");
//tre.print();
std::cout << "HERE!!!!!" << std::endl;
nitf::Reader reader;
nitf::Writer writer;
//open a file
sys::OS os;
std::vector< std::string > files;
for (int i = 1; i < argc; ++i)
{
if (!os.exists(argv[i]))
std::cout << "Error -> File does not exist: " << argv[i] << std::endl;
else
files.push_back(argv[i]);
}
for (std::vector< std::string >::iterator it = files.begin(); it != files.end(); ++it)
{
nitf::IOHandle handle(*it);
nitf::Reader rdr;
nitf::Record rec = rdr.read(handle);
std::cout << "CODEWORDS: " << rec.getHeader().getSecurityGroup().getCodewords().toString() << std::endl;
rec.getHeader().getSecurityGroup().getCodewords() = "TEST";
std::cout << "CODEWORDS: " << rec.getHeader().getSecurityGroup().getCodewords().toString() << std::endl;
nitf::FileSecurity security;
rec.getHeader().setSecurityGroup(security);
std::cout << "CODEWORDS: " << rec.getHeader().getSecurityGroup().getCodewords().toString() << std::endl;
std::cout << "Num Images: " << rec.getImages().getSize() << std::endl;
}
nitf_SubWindow_destruct(&subw);
nitf_Field_destruct(&cField);
nitf_BandInfo_destruct(&cBandInfo);
}
catch(except::Exception& ex)
{
std::cerr << "ERROR: " << ex.getMessage() << std::endl;
return 1;
}
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");
}
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");
}
