bool ossimBandSelector::outputBandsWithinInputRange() const
{
if(theInputConnection)
{
const ossim_uint32 HIGHEST_BAND = getNumberOfInputBands() - 1;
const ossim_uint32 OUTPUT_BANDS = (ossim_uint32)theOutputBandList.size();
for (ossim_uint32 i=0; i<OUTPUT_BANDS; ++i)
{
if (theOutputBandList[i] > HIGHEST_BAND)
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossimBandSelector::outputBandsWithinInputRange() ERROR:"
<< "Output band great than highest input band. "
<< theOutputBandList[i] << " > " << HIGHEST_BAND << "."
<< std::endl;
return false;
}
}
return true;
}
else
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossimBandSelector::outputBandsWithinInputRange() ERROR:"
<< "Method called prior to initialization!" << std::endl;
}
return false;
}
ossimFilename ossimLandsatTileSource::getBandFilename(ossim_uint32 idx)const
{
ossim_uint32 maxIdx = getNumberOfInputBands();
if(!theFfHdr||(idx > maxIdx))
{
return "";
}
ossimFilename path = getFilename().path();
ossimString filename = theFfHdr->getBandFilename(idx);
filename = filename.trim();
ossimFilename file = path.dirCat(filename);
if (file.exists())
{
return file;
}
// Try downcased name.
file = path.dirCat(filename.downcase());
if (file.exists())
{
return file;
}
// Try upcase name.
file = path.dirCat(filename.upcase());
if (file.exists())
{
return file;
}
return ossimFilename();
}
void ossimHistogramRemapper::setHighNormalizedClipPoint(
const ossim_float64& clip, ossim_uint32 zero_based_band)
{
const ossim_uint32 BANDS = getNumberOfInputBands();
if (zero_based_band >= BANDS)
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossimHistogramRemapper::setHighNormalizedClipPoint ERROR:"
<< "\nband " << zero_based_band << " is out of range!"
<< "\nhighest band: " << (BANDS-1) << endl;
}
if (theNormalizedHighClipPoint.size() != BANDS)
{
initializeClips();
}
if ( clip != theNormalizedHighClipPoint[zero_based_band] &&
clip > theNormalizedLowClipPoint[zero_based_band] )
{
theDirtyFlag = true;
theNormalizedHighClipPoint[zero_based_band] = clip;
}
}
void ossimHistogramRemapper::setMaxOutputValue(const ossim_float64& value,
ossim_uint32 zero_based_band)
{
if (theInputConnection)
{
const ossim_uint32 BANDS = getNumberOfInputBands();
if (zero_based_band >= BANDS)
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossimHistogramRemapper::setMidPoint ERROR:"
<< "\nband " << zero_based_band << " is out of range!"
<< "\nhighest band: " << (BANDS-1) << endl;
}
if (theMaxOutputValue.size() != BANDS)
{
initializeClips();
}
if ( value != theMaxOutputValue[zero_based_band] &&
value <= theInputConnection->getMaxPixelValue(zero_based_band) &&
value > theMinOutputValue[zero_based_band] )
{
theDirtyFlag = true;
theMaxOutputValue[zero_based_band] = value;
}
}
}
int toprsGadlReader::getNumberOfOutputBands() const
{
int result = 0;
if( isIndexTo3Band() )
{
if ( m_preservePaletteIndexesFlag )
{
result = 1; // Passing palette indexes not expanded rgb values.
}
else
{
result = 3;
}
}
else if (theAlphaChannelFlag)
{
result = 3;
}
else
{
// the number of outputs will be the same as the number of inputs
result = getNumberOfInputBands();
}
return result;
}
void ossimHistogramRemapper::setHighClipPoint(const ossim_float64& clip)
{
const ossim_uint32 BANDS = getNumberOfInputBands();
for (ossim_uint32 band = 0; band < BANDS; ++band)
{
setHighClipPoint(clip, band);
}
}
void ossimHistogramRemapper::setMaxOutputValue(const ossim_float64& value)
{
const ossim_uint32 BANDS = getNumberOfInputBands();
for (ossim_uint32 band = 0; band < BANDS; ++band)
{
setMaxOutputValue(value, band);
}
}
ossim_uint32 ossimBandSelector::getNumberOfOutputBands() const
{
if(theEnableFlag)
{
return (ossim_uint32)theOutputBandList.size();
}
return getNumberOfInputBands();
}
void rspfEnviTileSource::setDefaultBandList()
{
if ( isBandSelector() )
{
rspfString value;
value.string() = m_enviHdr.getMap().findKey( std::string("default bands") );
if ( value.size() )
{
std::vector<rspfString> strLst;
value.split( strLst, rspfString(","));
if ( strLst.size() )
{
const rspf_uint32 INPUT_BANDS = getNumberOfInputBands();
std::vector<rspfString>::const_iterator i = strLst.begin();
std::vector<rspf_uint32> bands;
rspf_uint32 band = 0;
while ( i != strLst.end() )
{
band = (*i).toUInt32();
if ( band )
{
// Assuming "default bands" are one based. Totally a hunch... (drb)
--band;
}
else
{
rspfNotify(rspfNotifyLevel_WARN)
<< "rspfEnviTileSource::setDefaultBandList WARN!"
<< "\nDetected zero based bands in \"default bands\" from header!"
<< std::endl;
}
if ( band < INPUT_BANDS )
{
bands.push_back( band );
}
else
{
bands.clear(); // Out of range.
break;
}
++i;
}
if ( bands.size() )
{
rspfImageHandler::setOutputBandList(bands, m_outputBandList);
}
}
}
}
if ( m_outputBandList.empty() )
{
// Initialized to identity (input = output):
rspfImageSource::getOutputBandList( m_outputBandList );
}
}
double ossimMemoryImageSource::getNullPixelValue(ossim_uint32 band)const
{
if(m_image.valid())
{
if(band < getNumberOfInputBands())
{
return m_image->getNullPix(band);
}
}
return ossimImageSource::getNullPixelValue(band);
}
ossim_float64 ossimHistogramRemapper::getHighClipPoint() const
{
if (theNormalizedHighClipPoint.size() == 0 || !theHistogram)
{
return ossim::nan();
}
ossim_float64 d = 0.0;
const ossim_uint32 BANDS = getNumberOfInputBands();
for (ossim_uint32 band = 0; band < BANDS; ++band)
{
d += getHighClipPoint(band);
}
return (d / BANDS);
}
void ossimImageSource::getOutputBandList(std::vector<ossim_uint32>& bandList) const
{
const ossim_uint32 INPUT_BANDS = getNumberOfInputBands();
if ( INPUT_BANDS )
{
bandList.resize( INPUT_BANDS );
for ( ossim_uint32 band = 0; band < INPUT_BANDS; ++band )
{
bandList[band] = band;
}
}
else
{
bandList.clear();
}
}
ossim_float64 ossimHistogramRemapper::getMaxOutputValue(ossim_uint32 zero_based_band) const
{
if (theMaxOutputValue.size() == 0 ||
zero_based_band >= getNumberOfInputBands())
{
return ossim::nan();
}
if (zero_based_band >= theMaxOutputValue.size())
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossimHistogramRemapper::getMaxOutputValue ERROR:"
<< "\nband " << zero_based_band << " is out of range!"
<< "\nhighest band: " << (theMaxOutputValue.size()-1)
<< endl;
return ossim::nan();
}
return theMaxOutputValue[zero_based_band];
}
ossim_float64 ossimHistogramRemapper::getHighNormalizedClipPoint(ossim_uint32 zero_based_band) const
{
if (theNormalizedHighClipPoint.size() == 0 ||
zero_based_band >= getNumberOfInputBands())
{
return ossim::nan();
}
if (zero_based_band >= theNormalizedHighClipPoint.size())
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossimHistogramRemapper::getHighNormalizedClipPoint ERROR:"
<< "\nband " << zero_based_band << " is out of range!"
<< "\nhighest band: " << (theNormalizedHighClipPoint.size()-1)
<< endl;
return ossim::nan();
}
return theNormalizedHighClipPoint[zero_based_band];
}
ossim_float64 ossimHistogramRemapper::getHighClipPoint(ossim_uint32 zero_based_band) const
{
if(zero_based_band >= getNumberOfInputBands() ||
!theHistogram || zero_based_band >= theNormalizedHighClipPoint.size())
{
return ossim::nan();
}
if (theNormalizedHighClipPoint[zero_based_band] == 1.0)
{
return getMaxPixelValue(zero_based_band);
}
ossimRefPtr<ossimHistogram> h = getHistogram(zero_based_band);
if (h.valid())
{
ossim_float64 d =
h->HighClipVal(1.0-theNormalizedHighClipPoint[zero_based_band]);
return ceil(d);
}
return ossim::nan();
}
bool toprsImageReader::setOutputBandList( const std::vector<int>& inBandList, std::vector<int>& outBandList )
{
bool result = false;
const int INPUT_BANDS = getNumberOfInputBands();
const int OUTPUT_BANDS = inBandList.size();
if ( INPUT_BANDS && OUTPUT_BANDS )
{
result = true;
outBandList.resize( OUTPUT_BANDS );
for ( int band = 0; band < OUTPUT_BANDS; ++band )
{
if ( inBandList[band] < INPUT_BANDS )
{
outBandList[band] = inBandList[band];
}
else // Out of range...
{
result = false;
break;
}
}
//xizhi
//if ( result && theOverview.valid() )
//{
//result = theOverview->setOutputBandList( inBandList );
//}
}
if ( result == false )
{
toprsImageSource::getOutputBandList( outBandList ); // Set to identity.
}
return result;
}
void ossimHistogramRemapper::setMidPoint(const ossim_float64& value,
ossim_uint32 zero_based_band)
{
const ossim_uint32 BANDS = getNumberOfInputBands();
if (zero_based_band >= BANDS)
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossimHistogramRemapper::setMidPoint ERROR:"
<< "\nband " << zero_based_band << " is out of range!"
<< "\nhighest band: " << (BANDS-1) << endl;
}
if (theMidPoint.size() != BANDS)
{
initializeClips();
}
if (theMidPoint[zero_based_band] != value)
{
theDirtyFlag = true;
theMidPoint[zero_based_band] = value;
}
}
bool ossimH5Reader::getTile(ossimImageData* result, ossim_uint32 resLevel)
{
bool status = false;
m_mutex.lock();
//---
// Not open, this tile source bypassed, or invalid res level,
// return a blank tile.
//---
if( isOpen() && isSourceEnabled() && isValidRLevel(resLevel) &&
result && (result->getNumberOfBands() == getNumberOfOutputBands()) )
{
result->ref(); // Increment ref count.
//---
// Check for overview tile. Some overviews can contain r0 so always
// call even if resLevel is 0. Method returns true on success, false
// on error.
//---
status = getOverviewTile(resLevel, result);
if (!status) // Did not get an overview tile.
{
status = true;
ossimIrect tile_rect = result->getImageRectangle();
if ( ! tile_rect.completely_within(getImageRectangle(0)) )
{
// We won't fill totally so make blank first.
result->makeBlank();
}
if (getImageRectangle(0).intersects(tile_rect))
{
// Make a clip rect.
ossimIrect clipRect = tile_rect.clipToRect(getImageRectangle(0));
if (tile_rect.completely_within( clipRect) == false)
{
// Not filling whole tile so blank it out first.
result->makeBlank();
}
// Create buffer to hold the clip rect for a single band.
ossim_uint32 clipRectSizeInBytes = clipRect.area() *
ossim::scalarSizeInBytes( m_entries[m_currentEntry].getScalarType() );
vector<char> dataBuffer(clipRectSizeInBytes);
// Get the data.
for (ossim_uint32 band = 0; band < getNumberOfInputBands(); ++band)
{
// Hdf5 file to buffer:
m_entries[m_currentEntry].getTileBuf(&dataBuffer.front(), clipRect, band);
if ( m_entries[m_currentEntry].getScalarType() == OSSIM_FLOAT32 )
{
//---
// NPP VIIRS data has null of "-999.3".
// Scan and fix non-standard null value.
//---
const ossim_float32 NP = getNullPixelValue(band);
const ossim_uint32 COUNT = clipRect.area();
ossim_float32* float_buffer = (ossim_float32*)&dataBuffer.front();
for ( ossim_uint32 i = 0; i < COUNT; ++i )
{
if ( float_buffer[i] <= -999.0 ) float_buffer[i] = NP;
}
}
// Buffer to tile:
result->loadBand((void*)&dataBuffer.front(), clipRect, band);
}
// Validate the tile, i.e. full, partial, empty.
result->validate();
}
else // No intersection...
{
result->makeBlank();
}
}
result->unref(); // Decrement ref count.
}
m_mutex.unlock();
return status;
}
ossim_uint32 ossimH5Reader::getNumberOfOutputBands()const
{
// Currently not band selectable.
return getNumberOfInputBands();
}
bool toprsGadlReader::open()
{
if(isOpen())
{
close();
}
std::string driverNameTmp;
if (theSubDatasets.size() == 0)
{
// Note: Cannot feed GDALOpen a NULL string!
if (theImageFile.size())
{
theDataset = GDALOpen(theImageFile.c_str(), GA_ReadOnly);
if( theDataset == 0 )
{
return false;
}
}
else
{
return false;
}
// Check if it is nitf data for deciding whether or not open each sub-dataset
//This will be removed eventually when toprs can handle 2GB nitf file.
GDALDriverH driverTmp = GDALGetDatasetDriver(theDataset);
bool isNtif = false;
if (driverTmp != 0)
{
driverNameTmp = std::string(GDALGetDriverShortName(driverTmp));
std::transform(driverNameTmp.begin(), driverNameTmp.end(), driverNameTmp.begin(), [&](char ch){return toupper(ch);});
if (driverNameTmp == "NITF")
{
isNtif = true;
}
}
// Check for sub data sets...
char** papszMetadata = GDALGetMetadata( theDataset, "SUBDATASETS" );
if( CSLCount(papszMetadata) > 0 )
{
theSubDatasets.clear();
for( int i = 0; papszMetadata[i] != 0; ++i )
{
std::string os = papszMetadata[i];
if (os.find("_NAME=") != std::string::npos)
{
//Sub sets have already been set. Open each sub-dataset really slow down the process
//specially for hdf data which sometimes has over 100 sub-datasets. Since following code
//only for ntif cloud checking, so only open each sub-dataset here if the dataset is
//nitf. This will be removed eventually when toprs can handle 2GB nitf file.
//Otherwise open a sub-dataset when setCurrentEntry() gets called.
if (isNtif)
{
GDALDatasetH subDataset = GDALOpen(filterSubDatasetsString(os).c_str(),
GA_ReadOnly);
if ( subDataset != 0 )
{
// "Worldview ingest should ignore subimages when NITF_ICAT=CLOUD"
// Hack: Ignore NITF subimages marked as cloud layers.
std::string nitfIcatTag( GDALGetMetadataItem( subDataset, "NITF_ICAT", "" ) );
if ( nitfIcatTag.find("CLOUD") == std::string::npos )
{
theSubDatasets.push_back(filterSubDatasetsString(os));
}
}
GDALClose(subDataset);
}
else
{
theSubDatasets.push_back(filterSubDatasetsString(os));
}
}
}
//---
// Have multiple entries. We're going to default to open the first
// entry like cidcadrg.
//---
close();
theDataset = GDALOpen(theSubDatasets[theEntryNumberToRender].c_str(),
GA_ReadOnly);
if (theDataset == 0)
{
return false;
}
} // End of has subsets block.
} // End of "if (theSubdatasets.size() == 0)"
else
{
// Sub sets have already been set.
theDataset = GDALOpen(theSubDatasets[theEntryNumberToRender].c_str(),
GA_ReadOnly);
if (theDataset == 0)
{
return false;
}
}
// Set the driver.
theDriver = GDALGetDatasetDriver( theDataset );
if(!theDriver) return false;
theGdtType = GDT_Byte;
theOutputGdtType = GDT_Byte;
if(getNumberOfInputBands() < 1 )
{
if(CSLCount(GDALGetMetadata(theDataset, "SUBDATASETS")))
{
std::cout
<< "torsGdalReader::open WARNING:"
<< "\nHas multiple sub datasets and need to set the data before"
<< " we can get to the bands" << std::endl;
}
close();
std::cout
<< "torsGdalReader::open WARNING:"
<< "\nNo band data present in torsGdalReader::open" << std::endl;
return false;
}
toprs_int32 i = 0;
GDALRasterBandH bBand = GDALGetRasterBand( theDataset, 1 );
theGdtType = GDALGetRasterDataType(bBand);
char** papszMetadata = GDALGetMetadata( bBand, NULL );
if (CSLCount(papszMetadata) > 0)
{
for(int i = 0; papszMetadata[i] != NULL; i++ )
{
std::string metaStr = papszMetadata[i];
if (metaStr.find("AREA_OR_POINT") != std::string::npos)
{
//std::string pixel_is_point_or_area = metaStr.split("=")[1];
//pixel_is_point_or_area.downcase();
//if (pixel_is_point_or_area.contains("area"))
// thePixelType = TOPRS_PIXEL_IS_AREA;
break;
}
}
}
if(!isIndexed(1))
{
for(i = 0; i < GDALGetRasterCount(theDataset); ++i)
{
if(theGdtType != GDALGetRasterDataType(GDALGetRasterBand( theDataset,i+1 )))
{
std::cout
<< "torsGdalReader::open WARNING"
<< "\nWe currently do not support different scalar type bands."
<< std::endl;
close();
return false;
}
}
}
theOutputGdtType = theGdtType;
switch(theGdtType)
{
case GDT_CInt16:
{
// theOutputGdtType = GDT_Int16;
theIsComplexFlag = true;
break;
}
case GDT_CInt32:
{
// theOutputGdtType = GDT_Int32;
theIsComplexFlag = true;
break;
}
case GDT_CFloat32:
{
// theOutputGdtType = GDT_Float32;
theIsComplexFlag = true;
break;
}
case GDT_CFloat64:
{
// theOutputGdtType = GDT_Float64;
theIsComplexFlag = true;
break;
}
default:
{
theIsComplexFlag = false;
break;
}
}
if((std::string(GDALGetDriverShortName( theDriver )) == "PNG")&&
(getNumberOfInputBands() == 4))
{
theAlphaChannelFlag = true;
}
populateLut();
computeMinMax();
completeOpen();
theTile = toprsImgFactory::instance()->create(this);
theSingleBandTile = toprsImgFactory::instance()->create(getInputScalarType(), 1);
if ( m_preservePaletteIndexesFlag )
{
theTile->setIndexedFlag(true);
theSingleBandTile->setIndexedFlag(true);
}
theTile->initialize();
theSingleBandTile->initialize();
theGdalBuffer.resize(0);
if(theIsComplexFlag)
{
theGdalBuffer.resize(theSingleBandTile->getSizePerBandInBytes()*2);
}
theImageBound = toprsIRect(0
,0
,GDALGetRasterXSize(theDataset)-1
,GDALGetRasterYSize(theDataset)-1);
int xSize=0, ySize=0;
GDALGetBlockSize(GDALGetRasterBand( theDataset, 1 ),
&xSize,
&ySize);
if (driverNameTmp.find("JPIP")!= std::string::npos || driverNameTmp.find("JP2")!= std::string::npos)
{
m_isBlocked = ((xSize > 1)&&(ySize > 1));
}
else
{
m_isBlocked = false;
}
//if(m_isBlocked)
//{
// setRlevelCache();
//}
return true;
}
//*******************************************************************
// Public method:
//*******************************************************************
ossimRefPtr<ossimImageGeometry> ossimAdrgTileSource::getImageGeometry()
{
if ( !theGeometry )
{
// Check for external geom:
theGeometry = getExternalImageGeometry();
if ( !theGeometry )
{
// origin of latitude
ossim_float64 originLatitude = (m_AdrgHeader->maxLatitude() +
m_AdrgHeader->minLatitude()) / 2.0;
// central meridian.
ossim_float64 centralMeridian = (m_AdrgHeader->maxLongitude() +
m_AdrgHeader->minLongitude()) / 2.0;
//---
// Compute the pixel size in latitude and longitude direction. This will
// be full image extents divided by full image lines and samples.
//---
// Samples in full image (used to compute degPerPixelX).
ossim_float64 samples = m_AdrgHeader->samples();
// Lines in full image (used to compute degPerPixelX).
ossim_float64 lines = m_AdrgHeader->lines();
// Degrees in latitude direction of the full image.
ossim_float64 degrees_in_lat_dir = m_AdrgHeader->maxLatitude() -
m_AdrgHeader->minLatitude();
// Degrees in longitude direction of the full image.
ossim_float64 degrees_in_lon_dir = m_AdrgHeader->maxLongitude() -
m_AdrgHeader->minLongitude();
ossim_float64 degPerPixelY = degrees_in_lat_dir / lines;
ossim_float64 degPerPixelX = degrees_in_lon_dir / samples;
//---
// The tie is determined with the following assumptions that need to be
// verified:
// 1) Rows and columns start at 1.
// 2) The min / max latitudes longitudes go to the edge of the pixel.
// 3) Latitude decreases by degPerPixelY with each line.
// 4) Longitude increases by degPerPixelX with each sample.
//---
ossim_float64 ul_lat = (m_AdrgHeader->maxLatitude() -
( (m_AdrgHeader->startRow() - 1) *
degPerPixelY ) - ( degPerPixelY * 0.5 ) );
ossim_float64 ul_lon = (m_AdrgHeader->minLongitude() +
( (m_AdrgHeader->startCol() -1) *
degPerPixelX ) + ( degPerPixelX * 0.5 ) );
// projection type
ossimKeywordlist kwl;
const char* prefix = 0;
kwl.add(prefix,
ossimKeywordNames::TYPE_KW,
"ossimEquDistCylProjection",
true);
// datum.
kwl.add(prefix,
ossimKeywordNames::DATUM_KW,
"WGE",
true);
// origin latitude
kwl.add(prefix,
ossimKeywordNames::ORIGIN_LATITUDE_KW,
originLatitude,
true);
// central meridin
kwl.add(prefix,
ossimKeywordNames::CENTRAL_MERIDIAN_KW,
centralMeridian,
true);
// Save the tie point.
kwl.add(prefix,
ossimKeywordNames::TIE_POINT_XY_KW,
ossimDpt(ul_lon, ul_lat).toString().c_str(),
true);
kwl.add(prefix,
ossimKeywordNames::TIE_POINT_UNITS_KW,
ossimUnitTypeLut::instance()->getEntryString(OSSIM_DEGREES),
true);
// Save the scale.
kwl.add(prefix,
ossimKeywordNames::TIE_POINT_LAT_KW,
ul_lat,
true);
kwl.add(prefix,
ossimKeywordNames::TIE_POINT_LON_KW,
ul_lon,
true);
// Save the scale.
kwl.add(prefix,
ossimKeywordNames::PIXEL_SCALE_XY_KW,
ossimDpt(degPerPixelX, degPerPixelY).toString().c_str(),
true);
kwl.add(prefix,
ossimKeywordNames::PIXEL_SCALE_UNITS_KW,
ossimUnitTypeLut::instance()->getEntryString(OSSIM_DEGREES),
true);
// lines
kwl.add(prefix,
ossimKeywordNames::NUMBER_LINES_KW,
getNumberOfLines());
// samples
kwl.add(prefix,
ossimKeywordNames::NUMBER_SAMPLES_KW,
getNumberOfSamples());
// res sets
kwl.add(prefix,
ossimKeywordNames::NUMBER_REDUCED_RES_SETS_KW,
getNumberOfDecimationLevels());
// bands
kwl.add(prefix,
ossimKeywordNames::NUMBER_INPUT_BANDS_KW,
getNumberOfInputBands());
// bands
kwl.add(prefix,
ossimKeywordNames::NUMBER_OUTPUT_BANDS_KW,
getNumberOfOutputBands());
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "\nminLon: " << m_AdrgHeader->minLon()
<< "\nminLond: " << m_AdrgHeader->minLongitude()
<< "\nminLat: " << m_AdrgHeader->minLat()
<< "\nminLatd: " << m_AdrgHeader->minLatitude()
<< "\nmaxLon: " << m_AdrgHeader->maxLon()
<< "\nmaxLond: " << m_AdrgHeader->maxLongitude()
<< "\nmaxLat: " << m_AdrgHeader->maxLat()
<< "\nmaxLatd: " << m_AdrgHeader->maxLatitude()
<< "\nstartRow: " << m_AdrgHeader->startRow()
<< "\nstartCol: " << m_AdrgHeader->startCol()
<< "\nstopRow: " << m_AdrgHeader->stopRow()
<< "\nstopCol: " << m_AdrgHeader->stopCol()
<< "\nfull image lines: " << lines
<< "\nfull image samples: " << samples
<< "\nkwl:\n" << kwl
<< std::endl;
}
ossimProjection* new_proj = ossimProjectionFactoryRegistry::instance()->createProjection(kwl);
theGeometry = new ossimImageGeometry;
theGeometry->setProjection(new_proj); // assumes management of projection instance
} // matches (after getExternalImageGeometry()): if ( !theGeometry )
// Set image things the geometry object should know about.
initImageParameters( theGeometry.get() );
} // matches: if ( !theGeometry )
return theGeometry;
}
bool ossimPointCloudImageHandler::getTile(ossimImageData* result, ossim_uint32 resLevel)
{
// check for all systems go and valid args:
if (!m_pch.valid() || !result || (result->getScalarType() != OSSIM_FLOAT32)
|| (result->getDataObjectStatus() == OSSIM_NULL) || m_gsd.hasNans())
{
return false;
}
// Overviews achieved with GSD setting. This may be too slow.
ossimDpt gsd (m_gsd);
if (resLevel > 0)
getGSD(gsd, resLevel);
// Establish the ground and image rects for this tile:
const ossimIrect img_tile_rect = result->getImageRectangle();
const ossimIpt tile_offset (img_tile_rect.ul());
const ossim_uint32 tile_width = img_tile_rect.width();
const ossim_uint32 tile_height = img_tile_rect.height();
const ossim_uint32 tile_size = img_tile_rect.area();
ossimGpt gnd_ul, gnd_lr;
ossimDpt dpt_ul (img_tile_rect.ul().x - 0.5, img_tile_rect.ul().y - 0.5);
ossimDpt dpt_lr (img_tile_rect.lr().x + 0.5, img_tile_rect.lr().y + 0.5);
theGeometry->rnToWorld(dpt_ul, resLevel, gnd_ul);
theGeometry->rnToWorld(dpt_lr, resLevel, gnd_lr);
const ossimGrect gnd_rect (gnd_ul, gnd_lr);
// Create array of buckets to store accumulated point data.
ossim_uint32 numBands = result->getNumberOfBands();
if (numBands > getNumberOfInputBands())
{
// This should never happen;
ossimNotify(ossimNotifyLevel_FATAL)
<< "ossimPointCloudImageHandler::getTile() ERROR: \n"
<< "More bands were requested than was available from the point cloud source. Returning "
<< "blank tile." << endl;
result->makeBlank();
return false;
}
std::map<ossim_int32, PcrBucket*> accumulator;
// initialize a point block with desired fields as requested in the reader properties
ossimPointBlock pointBlock (this);
pointBlock.setFieldCode(componentToFieldCode());
m_pch->rewind();
ossimDpt ipt;
ossimGpt pos;
#define USE_GETBLOCK
#ifdef USE_GETBLOCK
m_pch->getBlock(gnd_rect, pointBlock);
for (ossim_uint32 id=0; id<pointBlock.size(); ++id)
{
pos = pointBlock[id]->getPosition();
theGeometry->worldToRn(pos, resLevel, ipt);
ipt.x = ossim::round<double,double>(ipt.x) - tile_offset.x;
ipt.y = ossim::round<double,double>(ipt.y) - tile_offset.y;
ossim_int32 bucketIndex = ipt.y*tile_width + ipt.x;
if ((bucketIndex >= 0) && (bucketIndex < (ossim_int32)tile_size))
addSample(accumulator, bucketIndex, pointBlock[id]);
}
#else // using getFileBlock
ossim_uint32 numPoints = m_pch->getNumPoints();
if (numPoints > ossimPointCloudHandler::DEFAULT_BLOCK_SIZE)
numPoints = ossimPointCloudHandler::DEFAULT_BLOCK_SIZE;
// Loop to read all point blocks:
do
{
pointBlock.clear();
m_pch->getNextFileBlock(pointBlock, numPoints);
//m_pch->normalizeBlock(pointBlock);
for (ossim_uint32 id=0; id<pointBlock.size(); ++id)
{
// Check that each point in read block is inside the ROI before accumulating it:
pos = pointBlock[id]->getPosition();
if (gnd_rect.pointWithin(pos))
{
theGeometry->worldToRn(pos, resLevel, ipt);
ipt.x = ossim::round<double,double>(ipt.x) - tile_offset.x;
ipt.y = ossim::round<double,double>(ipt.y) - tile_offset.y;
ossim_int32 bucketIndex = ipt.y*tile_width + ipt.x;
if ((bucketIndex >= 0) && (bucketIndex < (ossim_int32)tile_size))
addSample(accumulator, bucketIndex, pointBlock[id]);
}
}
} while (pointBlock.size() == numPoints);
#endif
// Finished accumulating, need to normalize and fill the tile.
// We must always blank out the tile as we may not have a point for every pixel.
normalize(accumulator);
ossim_float32** buf = new ossim_float32*[numBands];
std::map<ossim_int32, PcrBucket*>::iterator accum_iter;
ossim_float32 null_pixel = OSSIM_DEFAULT_NULL_PIX_FLOAT;
result->setNullPix(null_pixel);
for (ossim_uint32 band = 0; band < numBands; band++)
{
ossim_uint32 index = 0;
buf[band] = result->getFloatBuf(band);
for (ossim_uint32 y = 0; y < tile_height; y++)
{
for (ossim_uint32 x = 0; x < tile_width; x++)
{
accum_iter = accumulator.find(index);
if (accum_iter != accumulator.end())
buf[band][index] = accum_iter->second->m_bucket[band];
else
buf[band][index] = null_pixel;
++index;
}
}
}
delete [] buf;
buf = 0;
std::map<ossim_int32, PcrBucket*>::iterator pcr_iter = accumulator.begin();
while (pcr_iter != accumulator.end())
{
delete pcr_iter->second;
pcr_iter++;
}
result->validate();
return true;
}
void ossimHistogramRemapper::setupTable()
{
const ossim_uint32 BANDS = getNumberOfInputBands();
if (theNormalizedLowClipPoint.size() == 0)
{
initializeClips(BANDS);
}
ossim_uint32 values_per_band = 0;
ossim_uint32 bytes_per_pixel = 0;
switch (theOutputScalarType)
{
case OSSIM_UINT8:
values_per_band = 256; // 2 ^ 8
bytes_per_pixel = 1;
theTableType = ossimTableRemapper::NATIVE;
break;
case OSSIM_USHORT11:
values_per_band = 2048; // 2 ^ 11
bytes_per_pixel = 2;
theTableType = ossimTableRemapper::NATIVE;
break;
case OSSIM_UINT16:
case OSSIM_SINT16:
values_per_band = 65536; // 2 ^ 16
bytes_per_pixel = 2;
theTableType = ossimTableRemapper::NATIVE;
break;
case OSSIM_NORMALIZED_FLOAT:
case OSSIM_FLOAT:
bytes_per_pixel = 4;
break;
case OSSIM_NORMALIZED_DOUBLE:
case OSSIM_DOUBLE:
bytes_per_pixel = 8;
theTableType = ossimTableRemapper::NORMALIZED;
break;
default:
break;
}
if ( theOutputScalarType == OSSIM_FLOAT ||
theOutputScalarType == OSSIM_DOUBLE ||
theOutputScalarType == OSSIM_NORMALIZED_FLOAT ||
theOutputScalarType == OSSIM_NORMALIZED_DOUBLE )
{
for (ossim_uint32 band = 0; band < BANDS; ++band)
{
ossimRefPtr<ossimHistogram> h = getHistogram(band);
if (h.valid())
{
if (h->GetRes() > static_cast<ossim_int32>(values_per_band))
{
values_per_band = h->GetRes();
}
}
}
}
theTableBinCount = values_per_band;
theTableBandCount = BANDS;
// Check the size of the table prior to deletion and making a new one.
ossim_uint32 size_in_bytes = values_per_band * BANDS * bytes_per_pixel;
if(theTable.empty() || (theTable.size() != size_in_bytes))
{
theTable.resize(size_in_bytes);
}
ossimImageSource* input = dynamic_cast<ossimImageSource*>(getInput());
double minPix = ossim::defaultMin(getOutputScalarType());
double maxPix = ossim::defaultMax(getOutputScalarType());
if(input)
{
//---
// Last check for NaNs in key data members and set to some default if so.
// This could occur if someone stripped a keyword list down to a minimal
// set of keywords.
//---
for (ossim_uint32 band = 0; band < BANDS; ++band)
{
minPix = input->getMinPixelValue(band);
maxPix = input->getMaxPixelValue(band);
if ( ossim::isnan(theMinOutputValue[band]) )
{
theMinOutputValue[band] = minPix;
}
if ( ossim::isnan(theMaxOutputValue[band]) )
{
theMaxOutputValue[band] = maxPix;
}
}
}
else
{
//---
// Last check for NaNs in key data members and set to some default if so.
// This could occur if someone stripped a keyword list down to a minimal
// set of keywords.
//---
for (ossim_uint32 band = 0; band < BANDS; ++band)
{
if ( ossim::isnan(theMinOutputValue[band]) )
{
theMinOutputValue[band] = minPix;
}
if ( ossim::isnan(theMaxOutputValue[band]) )
{
theMaxOutputValue[band] = maxPix;
}
}
}
}
rspf_uint32 rspfImageSource::getNumberOfOutputBands() const
{
return getNumberOfInputBands();
}
template <class T> void ossimHistogramRemapper::buildLinearTable(T /* dummy */)
{
// This builds a native table.
theTableType = ossimTableRemapper::NATIVE;
const ossim_uint32 BANDS = getNumberOfInputBands();
// Sanity check.
if (theNormalizedLowClipPoint.size() != BANDS || !getHistogram(0).valid())
{
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossimHistogramRemapper::buildTable ERROR!"
<< " Line: " << __LINE__ << endl;
}
return;
}
T* table = reinterpret_cast<T*>(&theTable.front());
ossim_uint32 index = 0;
// Finally, build the table...
for (ossim_uint32 band = 0; band < BANDS; ++band)
{
ossimRefPtr<ossimHistogram> h = getHistogram(band);
if (h.get())
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimHistogramRemapper::buildLinearTable DEBUG:"
<< "\nband: " << band
<< "\nmean: " << h->GetMean()
<< "\nstddev: " << h->GetStandardDev()
<< endl;
}
}
else
{
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossimHistogramRemapper::buildTable ERROR!"
<< " Line: " << __LINE__ << endl;
}
return;
}
const T NULL_PIX = static_cast<T>(getNullPixelValue(band));
const T MIN_PIX = static_cast<T>(theMinOutputValue[band]);
const T MAX_PIX = static_cast<T>(theMaxOutputValue[band]);
ossim_float64 min_clip_value =
h->LowClipVal(theNormalizedLowClipPoint[band]);
ossim_float64 max_clip_value =
h->HighClipVal(1.0-theNormalizedHighClipPoint[band]);
min_clip_value = floor(min_clip_value);
max_clip_value = ceil(max_clip_value);
ossim_float64 gain = (MAX_PIX-MIN_PIX+1)/(max_clip_value-min_clip_value);
table[index] = NULL_PIX;
++index;
for (ossim_uint32 pix = 1; pix < theTableBinCount; ++pix)
{
ossim_float64 p = pix;
if (p <= min_clip_value)
{
p = MIN_PIX;
}
else if (p >= max_clip_value)
{
p = MAX_PIX;
}
else
{
p = ((p - min_clip_value) * gain) + MIN_PIX - 1.0;
}
if(p == NULL_PIX)
{
p = MIN_PIX;
}
table[index] = static_cast<T>(p+0.5);
++index;
}
} // End of band loop.
// Clear the dirty flag so the table's not rebuilt on the next getTile.
theDirtyFlag = false;
}
template <class T> void ossimHistogramRemapper::buildAutoLinearMinMaxTableTemplate(T /* dummy */)
{
const ossim_uint32 BANDS = getNumberOfInputBands();
// Sanity check.
if (theNormalizedLowClipPoint.size() != BANDS || !getHistogram(0).valid())
{
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossimHistogramRemapper::buildAutoLinearMinMaxTableTemplate ERROR!"
<< " Line: " << __LINE__ << endl;
}
return;
}
for (ossim_uint32 band = 0; band < BANDS; ++band)
{
ossimRefPtr<ossimHistogram> h = getHistogram(band);
T nullPix = static_cast<T>(getNullPixelValue(band));
if(h.valid())
{
ossim_uint32 n = h->GetRes();
ossim_float64 low = h->GetMinVal();
ossim_float64 high = h->GetMaxVal();
if(n > 0)
{
double newCount = 0.0;
double nextPercentage = 0.0;
double percentage = 0.0;
int idx = 0;
float * counts = h->GetCounts();
double count = h->ComputeArea();
for(idx = 0; idx < (ossim_int32)(n-1); ++idx)
{
if(nullPix != idx)
{
newCount += counts[idx];
}
percentage = newCount / count;
nextPercentage =
(newCount + counts[idx+1]) / count;
if (std::fabs(percentage - 0.006) <
std::fabs(nextPercentage - 0.006))
{
low = idx+1;
break;
}
}
newCount = 0.0;
for (idx = n-1; idx > 0; idx--)
{
newCount += counts[idx];
percentage = newCount / count;
nextPercentage =
(newCount + counts[idx-1]) / count;
if (std::fabs(percentage - 0.006) <
std::fabs(nextPercentage - 0.006))
{
high=idx-1;
break;
}
}
if(low > high)
{
low = 0;
high = n - 1;
}
setLowClipPoint(low, band);
setHighClipPoint(high, band);
}
}
}
buildLinearTable();
}
void ossimHistogramRemapper::buildLinearTableStdFromMean()
{
const ossim_uint32 BANDS = getNumberOfInputBands();
// Sanity check.
if (theNormalizedLowClipPoint.size() != BANDS || !getHistogram(0).valid())
{
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossimHistogramRemapper::buildTable ERROR!"
<< " Line: " << __LINE__ << endl;
}
return;
}
ossim_float64 multiplier = 1.0;
if (theStretchMode == LINEAR_2STD_FROM_MEAN)
{
multiplier = 2.0;
}
else if (theStretchMode == LINEAR_3STD_FROM_MEAN)
{
multiplier = 3.0;
}
// Finally, build the table...
for (ossim_uint32 band = 0; band < BANDS; ++band)
{
ossimRefPtr<ossimHistogram> h = getHistogram(band);
ossim_float64 mean = 0.0;
ossim_float64 stdDev = 0.0;
if(h.valid())
{
mean = h->GetMean();
stdDev = h->GetStandardDev();
}
ossim_float64 lowClip = mean - (stdDev * multiplier);
ossim_float64 highClip = mean + (stdDev * multiplier);
// Clamp to min/max.
if (lowClip < theMinOutputValue[band])
{
lowClip = theMinOutputValue[band];
}
if (highClip > theMaxOutputValue[band])
{
highClip = theMaxOutputValue[band];
}
setLowClipPoint(lowClip, band);
setMidPoint(mean, band);
setHighClipPoint(highClip, band);
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimHistogramRemapper::buildLinearStdFromMean DEBUG:"
<< "\nband: " << band
<< "\nmean: " << mean
<< "\nstddev: " << stdDev
<< "\nlow clip: " << lowClip
<< "\nhigh clip: " << highClip
<< endl;
}
}
buildLinearTable();
}
ossim_uint32 ossimNetCdfReader::getNumberOfOutputBands()const
{
return getNumberOfInputBands();
}
ossim_uint32 ossimImageSource::getNumberOfOutputBands() const
{
return getNumberOfInputBands();
}
void ossimHistogramRemapper::initializeClips()
{
initializeClips(getNumberOfInputBands());
}