NRTAPI(NRT_DATA *) nrt_List_get(nrt_List * list, int index, nrt_Error * error) { int i = 0; if (list) { nrt_ListIterator iter = nrt_List_begin(list); nrt_ListIterator end = nrt_List_end(list); for (i = 0; i < index && nrt_ListIterator_notEqualTo(&iter, &end); ++i) nrt_ListIterator_increment(&iter); if (i == index && nrt_ListIterator_notEqualTo(&iter, &end)) { return nrt_ListIterator_get(&iter); } else { nrt_Error_init(error, "Object not found at index", NRT_CTXT, NRT_ERR_INVALID_OBJECT); return NULL; } } else { nrt_Error_init(error, "Invalid list -> NULL", NRT_CTXT, NRT_ERR_INVALID_OBJECT); return NULL; } }
NRTAPI(nrt_Uint32) nrt_List_size(nrt_List * list) { nrt_Uint32 size = 0; if (list) { nrt_ListIterator iter = nrt_List_begin(list); nrt_ListIterator end = nrt_List_end(list); while (nrt_ListIterator_notEqualTo(&iter, &end)) { ++size; nrt_ListIterator_increment(&iter); } } return size; }
NRTAPI(nrt_ListIterator) nrt_List_at(nrt_List * chain, int i) { nrt_ListIterator list_iterator = nrt_List_begin(chain); nrt_ListIterator end = nrt_List_end(chain); int j; for (j = 0; j < i; j++) { if (nrt_ListIterator_equals(&list_iterator, &end)) { list_iterator.current = NULL; break; } nrt_ListIterator_increment(&list_iterator); } return list_iterator; }
NRTAPI(nrt_List *) nrt_List_clone(nrt_List * source, NRT_DATA_ITEM_CLONE cloner, nrt_Error * error) { nrt_List *l = NULL; if (source) { nrt_ListIterator iter = nrt_List_begin(source); nrt_ListIterator end = nrt_List_end(source); l = nrt_List_construct(error); if (!l) return NULL; while (nrt_ListIterator_notEqualTo(&iter, &end)) { /* Foreach item in each list... */ NRT_DATA *data = nrt_ListIterator_get(&iter); /* Use the function pointer to clone the object... */ NRT_DATA *newData = (NRT_DATA *) cloner(data, error); if (!newData) return NULL; /* ... and then insert it with the key into the new table */ if (!nrt_List_pushBack(l, newData, error)) { /* destruct the created list. NOTE - there is no way for us to * destroy the NRT_DATA* chunks that have already been cloned */ nrt_List_destruct(&l); return NULL; } nrt_ListIterator_increment(&iter); } } else { nrt_Error_initf(error, NRT_CTXT, NRT_ERR_INVALID_OBJECT, "Trying to clone NULL pointer"); } return l; }
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); }