void ossimTiledElevationDatabase::getBoundingRect(
ossimRefPtr<ossimImageGeometry> geom, ossimGrect& boundingRect) const
{
if ( geom.valid() )
{
std::vector<ossimGpt> corner(4);
if ( geom->getCornerGpts(corner[0], corner[1], corner[2], corner[3]) )
{
ossimGpt ulGpt(corner[0]);
ossimGpt lrGpt(corner[0]);
for ( ossim_uint32 i = 1; i < 4; ++i )
{
if ( corner[i].lon < ulGpt.lon ) ulGpt.lon = corner[i].lon;
if ( corner[i].lat > ulGpt.lat ) ulGpt.lat = corner[i].lat;
if ( corner[i].lon > lrGpt.lon ) lrGpt.lon = corner[i].lon;
if ( corner[i].lat < lrGpt.lat ) lrGpt.lat = corner[i].lat;
}
boundingRect = ossimGrect(ulGpt, lrGpt);
}
else
{
boundingRect.makeNan();
}
}
}
//*****************************************************************************
// METHOD: ossimHsvGridRemapEngine::computeSourceValue
//
//*****************************************************************************
void ossimHsvGridRemapEngine::computeSourceValue(
ossimRefPtr<ossimImageData>& source, void* result)
{
static const char MODULE[]="ossimHsvGridRemapEngine::computeSourceValue";
if (traceExec()) CLOG << "entering..." << endl;
//***
// This engine defines "value" as the HSV vector corresponding to the mean
// RGB pixel value of the source data:
//***
ossimRgbVector rgb_vector;
rgb_vector.setR((unsigned char) source->computeAverageBandValue(0));
rgb_vector.setG((unsigned char) source->computeAverageBandValue(1));
rgb_vector.setB((unsigned char) source->computeAverageBandValue(2));
//***
// Assign the HSV components to the result vector:
//***
ossimHsvVector hsv_vector (rgb_vector);
((double*)result)[0] = (double) hsv_vector.getH();
((double*)result)[1] = (double) hsv_vector.getS();
((double*)result)[2] = (double) hsv_vector.getV();
if (traceExec()) CLOG << "returning..." << endl;
return;
}
void ossimBandSelector::setProperty(ossimRefPtr<ossimProperty> property)
{
if(!property) return;
if(property->getName() == "bandSelection")
{
ossimString str = property->valueToString();
std::vector<ossimString> str_vec;
std::vector<ossim_uint32> int_vec;
str.split( str_vec, " " );
for ( ossim_uint32 i = 0; i < str_vec.size(); ++i )
{
if(!str_vec[i].empty())
{
int_vec.push_back( str_vec[i].toUInt32() );
}
}
setOutputBandList( int_vec );
}
else
{
ossimImageSourceFilter::setProperty(property);
}
}
void ossimImageUtil::createHistogram(ossimRefPtr<ossimImageHandler>& ih)
{
static const char M[] = "ossimImageUtil::createHistogram #1";
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG) << M << " entered...\n";
}
if ( ih.valid() )
{
// Get the entry list:
std::vector<ossim_uint32> entryList;
ih->getEntryList(entryList);
bool useEntryIndex = false;
if ( entryList.size() )
{
if ( (entryList.size() > 1) || (entryList[0] != 0) ) useEntryIndex = true;
}
for(ossim_uint32 idx = 0; idx < entryList.size(); ++idx)
{
createHistogram(ih, entryList[idx], useEntryIndex);
}
}
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG) << M << " exited...\n";
}
}
void ossimImageToPlaneNormalFilter::setProperty(ossimRefPtr<ossimProperty> property)
{
ossimString name = property->getName();
if(name == "smoothnessFactor")
{
theSmoothnessFactor = property->valueToString().toDouble();
initialize();
}
else if(name == "xscale")
{
theXScale = property->valueToString().toDouble();
initialize();
}
else if(name == "yscale")
{
theYScale = property->valueToString().toDouble();
initialize();
}
else if(name == "autoTrackScaleFlag")
{
theTrackScaleFlag = property->valueToString().toDouble();
initialize();
}
else
{
ossimImageSourceFilter::setProperty(property);
}
}
void ossimLasReader::setProperty(ossimRefPtr<ossimProperty> property)
{
if ( property.valid() )
{
if ( property->getName() == SCALE_KW )
{
ossimString s;
property->valueToString(s);
ossim_float64 d = s.toFloat64();
if ( ossim::isnan(d) == false )
{
setScale( d );
}
}
else if ( property->getName() == SCAN_KW )
{
ossimString s;
property->valueToString(s);
m_scan = s.toBool();
}
else
{
ossimImageHandler::setProperty(property);
}
}
}
// Create overview for image:
void ossimImageUtil::createOverview(ossimRefPtr<ossimImageHandler>& ih,
bool& consumedHistogramOptions,
bool& /* consumedCmmOptions */)
{
static const char M[] = "ossimImageUtil::createOverview #1";
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG) << M << " entered...\n";
}
if ( ih.valid() )
{
// Get the entry list:
std::vector<ossim_uint32> entryList;
ih->getEntryList(entryList);
bool useEntryIndex = false;
if ( entryList.size() )
{
if ( (entryList.size() > 1) || (entryList[0] != 0) ) useEntryIndex = true;
}
// Create the overview builder:
ossimString overviewType;
getOverviewType( overviewType.string() );
ossimRefPtr<ossimOverviewBuilderBase> ob =
ossimOverviewBuilderFactoryRegistry::instance()->createBuilder(overviewType);
if ( ob.valid() )
{
// Set up any overview builder options that don't involve histograms.
ossimPropertyInterface* pi = dynamic_cast<ossimPropertyInterface*>( ob.get() );
if ( pi ) setProps(pi);
ossim_uint32 stopDimension = getOverviewStopDimension();
if ( stopDimension ) ob->setOverviewStopDimension(stopDimension);
ob->setScanForMinMax( scanForMinMax() );
ob->setScanForMinMaxNull( scanForMinMaxNull() );
for(ossim_uint32 idx = 0; idx < entryList.size(); ++idx)
{
createOverview(ih, ob, entryList[idx], useEntryIndex, consumedHistogramOptions);
}
}
else
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ERROR:\nCould not create builder for: "<< overviewType << std::endl;
outputOverviewWriterTypes();
}
}
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG) << M << " exited...\n";
}
}
//---
// For std::sort of ElevationDatabaseListType
// e.g.: std::sort( dbList.begin(), dbList.end(), dbSort );
//---
bool dbSort(ossimRefPtr<ossimElevationDatabase> a, ossimRefPtr<ossimElevationDatabase> b)
{
bool result = false;
if ( a.valid() && b.valid() )
{
result = ( a->getMeanSpacingMeters() < b->getMeanSpacingMeters() );
}
return result;
}
void ossimEdgeFilter::setProperty(ossimRefPtr<ossimProperty> property)
{
if(!property) return;
if(property->getName() == PROP_EDGE_FILTER)
{
theFilterType = property->valueToString();
}
}
void ossimEdgeFilter::runLocalMax8Filter(T /* dummyVariable */,
ossimRefPtr<ossimImageData> inputData)
{
ossim_uint32 bandIdx = 0;
ossim_uint32 numberOfBands = inputData->getNumberOfBands();
ossim_uint32 x = 0;
ossim_uint32 y = 0;
ossim_uint32 width = theTile->getWidth();
ossim_uint32 height = theTile->getHeight();
ossim_int32 rowIncrement = inputData->getWidth();
ossim_int32 rowIncrement2 = 2*inputData->getWidth();
for(bandIdx = 0; bandIdx < numberOfBands; ++bandIdx)
{
//inputBuf has a 1 pixel edge compared to outputBuf
T* inputBuf = static_cast<T*>(inputData->getBuf(bandIdx));
T* outputBuf = static_cast<T*>(theTile->getBuf(bandIdx));
T np = static_cast<T>(inputData->getNullPix(bandIdx)); //changed to input Null
if(inputBuf&&outputBuf)
{
//one pass: maybe faster if changed to two passes
T* outB;
T* inB;
outB = outputBuf;
inB = inputBuf;
for(y = 0; y < height; ++y)
{
for(x = 0; x < width; ++x)
{
if (inB[1+rowIncrement] != np)
{
*outB = max<T>(
max<T>(
max<T>(inB[0],inB[1]),
max<T>(inB[2],inB[rowIncrement])),
max<T>(
max<T>(inB[rowIncrement+2],inB[rowIncrement2]),
max<T>(inB[rowIncrement2+1],inB[rowIncrement2+2])
));
}
else
{
*outB = np;
}
++outB;
++inB;
}
inB+=2; //go to next line, jump due to edge
}
}
}
theTile->validate();
}
ossim_uint32 ossimMultiResLevelHistogram::getNumberOfBands(ossim_uint32 resLevel) const
{
const ossimRefPtr<ossimMultiBandHistogram> h = getMultiBandHistogram(resLevel);
if (h.valid())
{
return h->getNumberOfBands();
}
return 0;
}
bool ossimOpjCompressor::setProperty(ossimRefPtr<ossimProperty> property)
{
bool consumed = false;
if ( property.valid() )
{
ossimString key = property->getName();
if ( traceDebug() )
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimOpjCompressor::setProperty DEBUG:"
<< "\nkey: " << key
<< " values: " << property->valueToString() << std::endl;
}
if (key == ossimKeywordNames::COMPRESSION_QUALITY_KW)
{
setQualityTypeString(property->valueToString());
consumed = true;
}
else if ( (key == LEVELS_KW) || (key == "Clevels") )
{
m_levels = property->valueToString().toInt32();
consumed = true;
}
else if( (key == REVERSIBLE_KW) || (key == "Creversible") )
{
setReversibleFlag(property->valueToString().toBool());
consumed = true;
}
else if (key == ADD_ALPHA_CHANNEL_KW)
{
m_alpha = property->valueToString().toBool();
consumed = true;
}
else if ( key == THREADS_KW)
{
m_threads = property->valueToString().toInt32();
consumed = true;
}
else if ( (key == "Clayers") ||
(key == "Cprecincts") )
{
// Generic options passed through kdu_params::parse_string.
// Make in the form of "key=value" for kdu_params::parse_string.
ossimString option = key;
option += "=";
option += property->valueToString();
// Add to list.
m_options.push_back(option);
consumed = true;
}
}
return consumed;
}
void ossimRgbImage::setCurrentImageData(ossimRefPtr<ossimImageData>& imageData)
{
if(imageData.valid())
{
if((imageData->getScalarType() == OSSIM_UCHAR)&&
(imageData->getDataObjectStatus()!=OSSIM_NULL))
{
theImageData = imageData;
initialize();
}
}
}
const ossimRefPtr<ossimHistogram> ossimMultiResLevelHistogram::getHistogram(ossim_uint32 band,
ossim_uint32 resLevel)const
{
const ossimRefPtr<ossimMultiBandHistogram> temp = getMultiBandHistogram(resLevel);
if(temp.valid())
{
return temp->getHistogram(band);
}
return (ossimHistogram*)0;
}
void ossimMaskFilter::setProperty(ossimRefPtr<ossimProperty> property)
{
if( property.valid() )
{
if(property->getName() == MASK_FILTER_MASK_TYPE_KW)
{
setMaskType(property->valueToString());
}
else
{
ossimImageCombiner::setProperty(property);
}
}
}
void ossimPlanetQtLegendAnimationPathItem::loadXml(ossimRefPtr<ossimXmlNode> node,
std::vector<ossimPlanetOperation*>& activityList)
{
if(!node.valid()) return;
ossimString tempValue;
if(node->getChildTextValue(tempValue, "name"))
{
setText(0, tempValue.c_str());
}
if(node->getChildTextValue(tempValue, "path"))
{
setAnimationPathFromString(tempValue);
}
}
// Private method:
bool ossimTiledElevationDatabase::isDirectoryBasedImage(ossimRefPtr<ossimImageHandler> ih)
{
bool result = false;
if ( ih.valid() )
{
// Get the image handler name.
ossimString imageHandlerName = ih->getClassName();
if ( (imageHandlerName == "ossimAdrgTileSource") ||
(imageHandlerName == "ossimCibCadrgTileSource") )
{
result = true;
}
}
return result;
}
void ossimPlanetCacheTextureLayer::getMetadata(ossimRefPtr<ossimXmlNode> metadata)const
{
if(m_textureLayer.valid())
{
m_textureLayer->getMetadata(metadata.get());
}
}
void ossimCFARFilter::setProperty(ossimRefPtr<ossimProperty> property)
{
if(!property) return;
ossimString name = property->getName();
if(name == "aperture_size")
{
}
else
{
ossimImageSourceFilter::setProperty(property);
}
}
void ossimBumpShadeTileSource::setProperty(ossimRefPtr<ossimProperty> property)
{
ossimString name = property->getName();
if(name == "lightSourceElevationAngle")
{
m_lightSourceElevationAngle = property->valueToString().toDouble();
}
else if(name == "lightSourceAzimuthAngle")
{
m_lightSourceAzimuthAngle = property->valueToString().toDouble();
}
else
{
ossimImageCombiner::setProperty(property);
}
}
void ossimPngReader::setProperty(ossimRefPtr<ossimProperty> property)
{
if ( property.valid() )
{
if ( property->getName().string() == USE_ALPHA_KW )
{
ossimString s;
property->valueToString(s);
m_useAlphaChannelFlag = s.toBool();
}
else
{
ossimImageHandler::setProperty(property);
}
}
}
void ossimTableRemapper::remapFromNormalizedTable(
ossimRefPtr<ossimImageData>& inputTile)
{
if (!theNormBuf) // First time...
{
theNormBuf = new ossim_float64[theTile->getSize()];
}
// Normalize and copy the source tile to a buffer.
inputTile->copyTileToNormalizedBuffer(theNormBuf);
const ossim_uint32 BANDS = theTile->getNumberOfBands();
const ossim_uint32 PPB = theTile->getSizePerBand(); // pixels per band
//---
// NOTE:
// If (theTableBandCount == one) that means we only have one band; or,
// the user wanted to remap all bands using the same table...
//---
const ossim_uint32 BAND_OFFSET = (theTableBandCount == 1) ? 0 : PPB;
// remap table (rt)
ossim_float64* rt = reinterpret_cast<ossim_float64*>(&theTable.front());
ossim_float64* buf = theNormBuf;
ossim_float64 p = 0.0;
for (ossim_uint32 band = 0; band < BANDS; ++band)
{
for (ossim_uint32 pixel = 0; pixel < PPB; ++pixel)
{
// Get the source pixel...
ossim_uint32 idx
= static_cast<ossim_uint32>(buf[pixel]*theTableBinCount+0.5);
if((idx < theTableBinCount))
{
// If within range use to index the remap table; else, null.
p = (idx < theTableBinCount) ? rt[idx] : 0.0;
}
// else if(idx < 0)
// {
// p = 0.0;
// }
else
{
p = 1.0;
}
// Range check (in case table bad) and assign to destination pixel.
buf[pixel] = (p >= 0.0) ? ( (p <=1.0) ? p : 1) : 0.0;
}
// Go to next band.
rt += BAND_OFFSET;
buf += PPB;
}
// Un-normalize and copy the buffer to the destination tile.
theTile->copyNormalizedBufferToTile(theNormBuf);
}
void ossimIndexToRgbLutFilter::setProperty(ossimRefPtr<ossimProperty> property)
{
if(property.valid())
{
ossimString value = property->valueToString();
value = value.trim();
if(property->getName() == "LUT file")
{
setLut(ossimFilename(property->valueToString()));
}
else
{
ossimImageSourceFilter::setProperty(property);
}
}
}
void ossimFftFilter::setProperty(ossimRefPtr<ossimProperty> property)
{
if(!property) return;
if(property->getName() == "FFT Direction")
{
if(theTile.valid())
{
theTile = NULL;
}
setDirectionType(property->valueToString());
}
else
{
ossimImageSourceFilter::setProperty(property);
}
}
template <class T> void ossimTiledElevationDatabase::fillGrid(T /* dummyTemplate */,
ossimRefPtr<ossimImageData> data)
{
if ( data.valid() )
{
// Copy to grid reversing the lines as the ossimDblGrid's origin is the SW corner.
const ossim_float64 NP = data->getNullPix(0);
const T* buf = static_cast<T*>(data->getBuf(0));
if ( buf )
{
const ossimIpt SIZE( data->getWidth(), data->getHeight() );
ossim_int32 bufIdx = (SIZE.y-1) * data->getWidth();
ossim_int32 grdY = 0;
for (ossim_int32 y = SIZE.y-1; y >= 0; --y)
{
for (ossim_int32 x = 0; x < SIZE.x; ++ x)
{
ossim_float64 v = static_cast<ossim_float64>(buf[bufIdx+x]);
m_grid->setNode(x, grdY, (v!=NP?v:ossim::nan()) );
}
bufIdx -= data->getWidth();
++grdY;
}
}
}
}
ossimRefPtr<ossimImageData> ossimMaskFilter::executeMaskFilter(ossimRefPtr<ossimImageData> imageSourceData,
ossimRefPtr<ossimImageData> maskSourceData)
{
if(!theTile)
{
theTile = (ossimImageData*)imageSourceData->dup();
if(!theTile->getBuf())
{
theTile->initialize();
}
}
else
{
ossim_uint32 tw = theTile->getWidth();
ossim_uint32 th = theTile->getHeight();
ossim_uint32 dw = imageSourceData->getWidth();
ossim_uint32 dh = imageSourceData->getHeight();
theTile->setWidthHeight(imageSourceData->getWidth(),
imageSourceData->getHeight());
theTile->setOrigin(imageSourceData->getOrigin());
if((tw*th) != (dw*dh))
{
theTile->initialize();
}
theTile->setDataObjectStatus(imageSourceData->getDataObjectStatus());
}
theTile->loadTile(imageSourceData.get());
theTile->setDataObjectStatus(imageSourceData->getDataObjectStatus());
switch(theMaskType)
{
case OSSIM_MASK_TYPE_SELECT:
{
return executeMaskFilterSelect(theTile,
maskSourceData);
}
case OSSIM_MASK_TYPE_INVERT:
{
return executeMaskFilterInvertSelect(theTile,
maskSourceData);
}
case OSSIM_MASK_TYPE_WEIGHTED:
{
return executeMaskFilterWeighted(theTile,
maskSourceData);
}
}
return imageSourceData;
}
ossimRefPtr<ossimImageData> ossimFixedTileCache::addTile(ossimRefPtr<ossimImageData> imageData,
bool duplicateData)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(theMutex);
ossimRefPtr<ossimImageData> result = NULL;
if(!imageData.valid())
{
return result;
}
if(!imageData->getBuf())
{
return result;
}
ossim_int32 id = computeId(imageData->getOrigin());
if(id < 0)
{
return result;
}
std::map<ossim_int32, ossimFixedTileCacheInfo>::iterator tileIter =
theTileMap.find(id);
if(tileIter==theTileMap.end())
{
if(duplicateData)
{
result = (ossimImageData*)imageData->dup();
}
else
{
result = imageData;
}
ossimFixedTileCacheInfo cacheInfo(result, id);
theCacheSize += imageData->getDataSizeInBytes();
theTileMap.insert(make_pair(id, cacheInfo));
if(theUseLruFlag)
{
theLruQueue.push_back(id);
}
}
return result;
}
void oms::SingleImageChain::setImageViewTransform(ossimRefPtr<ossimImageViewTransform> imageViewTransform)
{
theViewCutter->setEnableFlag(false);
theViewImageCutter->setEnableFlag(false);
theRenderer->setImageViewTransform(imageViewTransform.get());
theRenderer->setEnableFlag(true);
ossimRefreshEvent evt(theRenderer);
theRenderer->propagateEventToOutputs(evt);
}
void ossimXmlNode::addChildNode(ossimRefPtr<ossimXmlNode> node)
{
if(node->theParentNode)
{
node->theParentNode->removeChild(node);
}
node->theParentNode = this;
theChildNodes.push_back(node.get());
}
void ossimCFARFilter::setProperty(ossimRefPtr<ossimProperty> property)
{
if(!property) return;
ossimString name = property->getName();
if(name == "threshold")
{
theThreshold = property->valueToString().toDouble();
}
else if(name == "Kernel")
{
ossimMatrixProperty* matrixProperty = PTR_CAST(ossimMatrixProperty,
property.get());
if(matrixProperty)
{
for(ossim_int32 r = 0; r < 5; r++)
{
for(ossim_int32 c = 0; c < 5; c++)
{
theKernel[r][c] = (*matrixProperty)(r,c);
}
}
/*
theKernel[0][0] = (*matrixProperty)(0,0);
theKernel[1][0] = (*matrixProperty)(1,0);
theKernel[2][0] = (*matrixProperty)(2,0);
theKernel[0][1] = (*matrixProperty)(0,1);
theKernel[1][1] = (*matrixProperty)(1,1);
theKernel[2][1] = (*matrixProperty)(2,1);
theKernel[0][2] = (*matrixProperty)(0,2);
theKernel[1][2] = (*matrixProperty)(1,2);
theKernel[2][2] = (*matrixProperty)(2,2);
*/
}
else
{
ossimImageSourceFilter::setProperty(property);
}
}
else
{
ossimImageSourceFilter::setProperty(property);
}
}