/*!

*

* OVERVIEW:

*

* We will retrieve information from the input source and manipulate the data.

* All filters will have a data access point called getTile that can take a

* rectangle/region of interest and a resolution level. Once we have

* retrieved the data we will show documented examples on how to manipulate

* the data.

*

*

* PURPOSE:

*

* 1. Learn how to request data from the connected input and output some basic

* information about the requested area of interest

* 2. Learn how to use ossimImageData object to manipulate pixel data.

* 3. Learn how to query subregions and copy subregions.

* 4. Understand what is a NULL, EMPTY, FULL, and PARTIAL data object.

* this is very import for mosaicking and other pixel

* manipulation filters.

*

*/

// this is the most important class and is called as the first line of all applications.

// without this all the important factories are not created.

//

#include "init/ossimInit.h"

#include "base/data_types/ossimFilename.h"

#include "base/data_types/ossimString.h"

#include "imaging/ossimImageData.h"

#include "imaging/formats/ossimImageHandler.h"

#include "imaging/factory/ossimImageHandlerRegistry.h"

#include "imaging/factory/ossimImageDataFactory.h"

// Base pointer for the passed back object type

//

#include "imaging/formats/ossimImageHandler.h"

// used to get the string name of the scalar type for the handler. The scalar

// type specifies if its unsigned char, float, double, ...etc

//

#include "base/misc/lookup_tables/ossimScalarTypeLut.h"

#include <iterator>

#include <iostream>

void usage();

void printDataStatus(ossimDataObjectStatus status);

void demo1(const ossimFilename& filename);

void demo2(const ossimFilename& filename);

void demo3(const ossimFilename& filename);

int main(int argc, char* argv[])

{

ossimInit::instance()->initialize(argc, argv);

if(argc != 2)

{

usage();

}

else

{

// demo 1 we will access some data from the input and print

// some basic information about the data dn then access the data

// buffers for each band.

//

demo1(ossimFilename(argv[1]));

// Demo 2 just shows ways to allocate the ossimImageData

//

demo2(ossimFilename(argv[1]));

// Demo 3 just show how to load region of a tile

//

demo3(ossimFilename(argv[1]));

}

ossimInit::instance()->finalize();

}

void usage()

{

cout <<"image_data <image file>"<< endl;

}

//

// The data object status is very useful and is used to determine

// if the data is NULL( not initialized), empty (initialized but blank or empty,

// partial(contains some null/invalid values), or full (all valid data).

//

// partial data means you have part of the information with valid data and the

// rest of it is set to the null or invalid pixel value for that band.

//

// full data means that every pixel for each band has valid information.

//

// empty means that no data is present

//

// null means no data and the buffer is null.

//

// For this status to be set on the ossimImageData there is a method

// validate that is called. Typically this is called when you implement

// a filter that changes the stored data.

//

void printDataStatus(ossimDataObjectStatus status)

{

// now lets output some of the information about the tile. The tile

//

switch(status)

{

case OSSIM_NULL:

{

cout << "data status = " << "null" << endl;

break;

}

case OSSIM_EMPTY:

{

cout << "data status = " << "empty" << endl;

break;

}

case OSSIM_PARTIAL:

{

cout << "data status = " << "partial" << endl;

break;

}

case OSSIM_FULL:

{

cout << "data status = " << "full" << endl;

break;

}

default:

{

cout << "data status = " << "unknown" << endl;

}

}

}

// Demo 1 will retrieve a region of interest using the

// ossimIrect which is an integer rectangle.

//

void demo1(const ossimFilename& filename)

{

cout << "___________________________________DEMO 1_____________________________________\n";

ossimImageHandler* handler = ossimImageHandlerRegistry::instance()->open(filename);

if(handler)

{

}

else

{

cerr <<"Unable to open image " << filename << endl;

return;

}

// we will query the first 100 by 100 pixel of data from the input

// and compute the average value of each band. We will only allow

// this to happen with unsigned char data.

//

// Rectangles in ossim take absolute coordinates for upper

// left and lower right and does not take an upper left

// point and then a width height. So if I want the data

// starting at point location 0,0 and ending at 100 pixels along

// the x and y direction then we have 0 to 99 along x = 100 and

// 0 to 99 along y = 100.

//

// the second argument to getTile is optional and corresponds

// to the resolution level or overview.

//

ossimIrect regionsOfInterest(0,0, 99, 99);

// the data returned from the call getTile is not owned by you and

// you should not delete the pointer.

//

ossimRefPtr<ossimImageData> data = handler->getTile(regionsOfInterest);

if(data.valid())

{

// output the rectangle of the tile.

cout << "tile rect = " << data->getImageRectangle() << endl;

// output the status of the tile. See printDataStatus above for

// documentation of status.

printDataStatus(data->getDataObjectStatus());

// how many bands are there.

//

cout << "Number of bands = " << data->getNumberOfBands() << endl;

// as in image_open lets use te scalr lut to pint the scalar type as a

// string.

cout << "Pixel scalar type = "

<< ossimScalarTypeLut::instance()->getEntryString(data->getScalarType())

<< endl;

// for each band let's print the min, max and null pixel values

// note: the min max values are not for the tile but for the entire

// input. Typically these are used for tile normalization

// and clamping to data bounds.

//

cout << "min pix: ";

std::copy(data->getMinPix(),

data->getMinPix()+data->getNumberOfBands(),

ostream_iterator<double>(cout, ", "));

cout << "\nmax pix: ";

std::copy(data->getMaxPix(),

data->getMaxPix()+data->getNumberOfBands(),

ostream_iterator<double>(cout, ", "));

cout << "\nnull pix: ";

std::copy(data->getNullPix(),

data->getNullPix()+data->getNumberOfBands(),

ostream_iterator<double>(cout, " "));

cout << endl;

if(data->getScalarType()!=OSSIM_UCHAR)

{

delete handler;

cerr << "Demo 1 only works for uchar data images" << endl;

return;

}

// Now lets compute the average pixel for each band. The data buffer is

// internally stored in osismImageData object as a void* buffer. We must cast

// to the scalar type or work in normalized space. For this example we will

// work the tile in its native type and will not normalize and we will also

// only work with unsigned char or uchar data.

//

// Note: ossimImageData already has a compute mean and sigma. We will re-implement

// some code here

//

// I will implement a more efficient algorithm by only checking for invalid data

// if the status is not full. If its full we don't have to check for

// null value and all we need to do is compute the sum. Although we can just check for null

// all the time and not worry about 2 different loops.

//

int upperBound = data->getWidth()*data->getHeight();

if(data->getDataObjectStatus() == OSSIM_FULL)

{

// since te data is full all pixls are used in the avverage

double totalNumberOfPixels = upperBound;

for(ossim_uint32 bandIndex = 0; bandIndex < data->getNumberOfBands(); ++bandIndex)

{

double sumOfThePixels = 0;

// get access to the raw band data.

ossim_uint8* buf = (ossim_uint8*)data->getBuf(bandIndex);

for(int offset = 0; offset < upperBound; ++offset)

{

sumOfThePixels += *buf;

++buf;

}

if(totalNumberOfPixels > 0)

{

cout << "band " << bandIndex << " average = " << sumOfThePixels/totalNumberOfPixels << endl;

}

else

{

cout << "band " << bandIndex << " average = " << 0.0 << endl;

}

}

}

else if(data->getDataObjectStatus() == OSSIM_PARTIAL)

{

for(ossim_uint32 bandIndex = 0; bandIndex < data->getNumberOfBands(); ++bandIndex)

{

double totalNumberOfPixels = 0;

double sumOfThePixels = 0;

ossim_uint8* buf = (ossim_uint8*)data->getBuf(bandIndex);

ossim_uint8 np = (ossim_uint8)data->getNullPix(bandIndex);

for(int offset = 0; offset < upperBound; ++offset)

{

if(np != *buf)

{

sumOfThePixels += *buf;

++totalNumberOfPixels;

}

++buf;

}

if(totalNumberOfPixels > 0)

{

cout << "band " << bandIndex << " average = " << sumOfThePixels/totalNumberOfPixels << endl;

}

else

{

cout << "band " << bandIndex << " average = " << 0.0 << endl;

}

}

}

}

cout << "___________________________________END DEMO 1_____________________________________\n";

delete handler;

}

// Demo 2 will show how to create your own data objects

// there are several ways to do this.

void demo2(const ossimFilename& filename)

{

cout << "___________________________________DEMO 2_____________________________________\n";

ossimImageHandler* handler = ossimImageHandlerRegistry::instance()->open(filename);

if(!handler)

{

cerr << "Unable to open file " << filename << " for demo 2\n";

return;

}

// Create image data using the factory technique.

// This might be the best way to do it. We might have optimized

// implementations for certain input types. For instance you might

// want to create an ossimImageData that is optimized for 3 band

// ossim_uint8 data.

//

// there other create methods but this takes as its

// first argument a source that owns this data object

// and the second argument is the input source to use

// to help instantiate the object. Please refer to

// ossim_core/imaging/factory/ossimImageDataFactory

// for further implementation

//

ossimRefPtr<ossimImageData> data = ossimImageDataFactory::instance()->create(NULL,

handler);

// note: the data is not initialized/allocated. We have

// a concept of a NULL or un initialized tile so all the

// meta data is carried with it but just don't take up space

// by allocating the buffer. The number of bands, the rectangle

// of interest, min, max, null are all set.

//

// We will now initialize the data. The initialize will

// allocate the buffer based on the number of bands, width,

// height and scalar type and then will set the buffer to

// the null pixel value and set the status OSSIM_EMPTY.

//

data->initialize();

// if you ever want to see if the initialization has been

// done then you must call isInitialize.

//

cout << "data initialized: " << data->isInitialize() << endl;

// To make a duplicate copy of the ossimImageData the easiest

// way to do this is to call the dup method.

//

ossimRefPtr<ossimImageData> dupData = (ossimImageData*)data->dup();

ossimIrect newRect(10,20,200,200);

// this particualr method will reallocate the tile

// if already initialized and set it to the new

// rectangle of interest.

//

dupData->setImageRectangle(newRect);

// allocating without the factory

//

ossimRefPtr<ossimImageData> data2 = new ossimImageData(NULL, // owner of the data object

OSSIM_UCHAR, // what scalar type

3, // number of bands

128, // width

128); // height

data2->initialize();

// delete the allocated data objects.

cout << "___________________________________END DEMO 2_____________________________________\n";

}

// Demo 3 will show how to create your own data objects

// there are several ways to do this.

void demo3(const ossimFilename& filename)

{

cout << "___________________________________DEMO 3_____________________________________\n";

ossimImageHandler* handler = ossimImageHandlerRegistry::instance()->open(filename);

if(!handler)

{

cerr << "Unable to open file " << filename << " for demo 2\n";

return;

}

// lets just get some data. we will get a 128 by

// 128 tile that has upper left origin at 10, 10.

//

ossimRefPtr<ossimImageData> data = handler->getTile(ossimIrect(10,

10,

10 + 127,

10 + 127));

if(data.valid())

{

cout << "Data rectangle = " << data->getImageRectangle() << endl;

ossimRefPtr<ossimImageData> data2 = ossimImageDataFactory::instance()->create(0,

handler);

data2->setImageRectangle(ossimIrect(0,0,127,127));

data2->initialize();

cout << "Data 2 rectangle = " << data2->getImageRectangle() << endl;

cout << "loading data2 rectangle\n";

// now load the data 2 region with data. Notice the

// tile overlaps the data tile and only the

// overlapping region is copied.

//

data2->loadTile(data.get());

// now we can use the raw load tile where you supply the

// rectangle. Now if you do this your buffer is assumed

// to have the same number of bands.

//

// Now you must pass in the interleave type of your buffer

// The ossimImageData has interleave band sequential, OSSIM_BSQ

// which means the bands are sequential in memory where

// all of band 1 data followed by all of band 2 ... etc.

// The other interleave type are OSSIM_BIP or band

// interleaved by pixel. For instance if you had an RGB

// data object then it would be RGB, RGB, RGB ... etc.

// The final interleave type is by line OSSIM_BIL. This

// just says band 1 line1 followed by band2 line2 ... etc until all

// lines are stored.

//

data2->loadTile(data->getBuf(),

data->getImageRectangle(),

OSSIM_BSQ);

// I manipulated the buffer so lets validate it for future

// use. I would only validate after you get done doing your

// data manipulation.

//

data2->validate();

cout << "status after load is should be partial \n";

printDataStatus(data2->getDataObjectStatus());

// loadBand has simalar arguments but allows

// you to do band loads.

//

for(ossim_uint32 band = 0; band < data->getNumberOfBands(); ++band)

{

data2->loadBand(data->getBuf(band),

data->getImageRectangle(),

band);

}

data2->validate();

// please refer to ossim_core/imaging/ossimImageData.h for

// other load methods

//

}

cout << "___________________________________END DEMO 3_____________________________________\n";

}