void ossimHistogramRemapper::initializeClips(ossim_uint32 bands)
{
//---
// NOTE: This method does not set theDirtyFlag by design.
//---
if (bands)
{
theNormalizedLowClipPoint.resize(bands);
theNormalizedHighClipPoint.resize(bands);
theMidPoint.resize(bands);
theMinOutputValue.resize(bands);
theMaxOutputValue.resize(bands);
for (ossim_uint32 band = 0; band < bands; ++band)
{
theNormalizedLowClipPoint[band] = 0.0;
theNormalizedHighClipPoint[band] = 1.0;
theMidPoint[band] = 0.0;
// Must have an output scalar type for getMin/Max call.
if (theOutputScalarType != OSSIM_SCALAR_UNKNOWN)
{
theMinOutputValue[band] = getMinPixelValue(band);
theMaxOutputValue[band] = getMaxPixelValue(band);
}
else
{
theMinOutputValue[band] = 0.0;
theMaxOutputValue[band] = 0.0;
}
}
}
}
void ossimLasReader::initTile()
{
const ossim_uint32 BANDS = getNumberOfOutputBands();
m_tile = new ossimImageData(this,
getOutputScalarType(),
BANDS,
getTileWidth(),
getTileHeight());
for(ossim_uint32 band = 0; band < BANDS; ++band)
{
m_tile->setMinPix(getMinPixelValue(band), band);
m_tile->setMaxPix(getMaxPixelValue(band), band);
m_tile->setNullPix(getNullPixelValue(band), band);
}
m_tile->initialize();
}
void ossimHistogramRemapper::verifyEnabled()
{
//---
// Since this filter can be constructed with no input connection do not
// output and error, simply return.
//---
if (theInputConnection)
{
// Start off bypassed.
setBypassFlag(true);
if (theStretchMode != STRETCH_UNKNOWN)
{
const ossim_uint32 BANDS =
(ossim_uint32)theNormalizedLowClipPoint.size();
for (ossim_uint32 band = 0; band < BANDS; ++band)
{
const double MIN = getMinPixelValue(band);
const double MAX = getMaxPixelValue(band);
if ( theNormalizedLowClipPoint[band] != 0.0 ||
theNormalizedHighClipPoint[band] != 1.0 ||
// theMidPoint != 0.0 || ????
theMinOutputValue[band] != MIN ||
theMaxOutputValue[band] != MAX )
{
// Need to turn filter on.
setBypassFlag(false);
break;
}
}
}
}
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimHistogramRemapper::verifyEnabled theBypassFlag: "
<< (theBypassFlag ? "true" : "false") << endl;
}
}
ossim_float64 ossimHistogramRemapper::getLowClipPoint(ossim_uint32 zero_based_band) const
{
if(zero_based_band >= getNumberOfInputBands() ||
!theHistogram || zero_based_band >= theNormalizedLowClipPoint.size())
{
return ossim::nan();
}
if (theNormalizedLowClipPoint[zero_based_band] == 0.0)
{
return getMinPixelValue(zero_based_band);
}
ossimRefPtr<ossimHistogram> h = getHistogram(zero_based_band);
if (h.valid())
{
ossim_float64 d =
h->LowClipVal(theNormalizedLowClipPoint[zero_based_band]);
return floor(d);
}
return ossim::nan();
}
void ossimCFARFilter::computeNullMinMax()
{
const ossim_uint32 BANDS = getNumberOfOutputBands();
theNullPixValue.resize(BANDS);
theMinPixValue.resize(BANDS);
theMaxPixValue.resize(BANDS);
ossim_float64 defaultNull = ossim::defaultNull(getOutputScalarType());
ossim_float64 defaultMin = ossim::defaultMin(getOutputScalarType());
ossim_float64 defaultMax = ossim::defaultMax(getOutputScalarType());
for (ossim_uint32 band = 0; band < BANDS; ++band)
{
if(theInputConnection)
{
ossim_float64 inputNull = theInputConnection->getNullPixelValue(band);
ossim_float64 inputMin = theInputConnection->getMinPixelValue(band);
ossim_float64 inputMax = theInputConnection->getMaxPixelValue(band);
ossim_float64 tempMin = 0.0;
ossim_float64 tempMax = 0.0;
ossim_float64 k = 0.0;
for(int i=0;i<5;++i)
{
for(int j=0;j<5;++j)
{
k=theKernel[i][j];
tempMin += (k<0.0) ? k*inputMax : k*inputMin;
tempMax += (k>0.0) ? k*inputMax : k*inputMin;
}
}
if((inputNull < getMinPixelValue(band)) ||
(inputNull > getMaxPixelValue(band)))
{
theNullPixValue[band] = inputNull;
}
else
{
theNullPixValue[band] = defaultNull;
}
if((tempMin >= defaultMin) && (tempMin <= defaultMax))
{
theMinPixValue[band] = tempMin;
}
else
{
theMinPixValue[band] = defaultMin;
}
if((tempMax >= defaultMin) && (tempMax <= defaultMax))
{
theMaxPixValue[band] = tempMax;
}
else
{
theMaxPixValue[band] = defaultMax;
}
}
else // No input connection...
{
theNullPixValue[band] = defaultNull;
theMinPixValue[band] = defaultMin;
theMaxPixValue[band] = defaultMax;
}
} // End of band loop.
}
template<class T> void ossimCFARFilter::convolveFull(
T,
ossimRefPtr<ossimImageData> inputData,
ossimRefPtr<ossimImageData> outputData)
{
// let's set up some temporary variables so we don't
// have to call the functions in loops. Iknow that compilers
// typically optimize this out but if we are in debug mode
// with no optimization it will still run fast
//
double sum = 0.0,sqrsum = 0.0,variance = 0.0;
ossim_int32 inputW = static_cast<ossim_int32>(inputData->getWidth());
ossim_uint32 outputW = outputData->getWidth();
ossim_uint32 outputH = outputData->getHeight();
ossim_uint32 numberOfBands = inputData->getNumberOfBands();
ossimIpt outputOrigin = outputData->getOrigin();
ossimIpt inputOrigin = inputData->getOrigin();
ossim_int32 startInputOffset = std::abs(outputOrigin.y - inputOrigin.y)*
inputW + std::abs(outputOrigin.x - inputOrigin.x);
ossim_int32 ulKernelStart = -(2*inputW) - 2;
ossim_int32 ul1KernelStart = -inputW - 1;
ossim_int32 leftKernelStart = -2;
ossim_int32 ll1KernelStart = inputW - 1;
ossim_int32 llKernelStart = (2*inputW) - 2;
//populate kernel offset indices
ossim_int32 KernelStart[BOXSIZE];
T* KernelStartBuf[BOXSIZE];
for(ossim_uint16 i=0;i<BOXSIZE;i++)
{
int offset = i-(BOXSIZE/2);
KernelStart[i] = offset*inputW + offset;
KernelStartBuf[i] = NULL;
}
T* ulKernelStartBuf = NULL;
T* ul1KernelStartBuf = NULL;
T* leftKernelStartBuf = NULL;
T* ll1KernelStartBuf = NULL;
T* llKernelStartBuf = NULL;
for(ossim_uint32 band = 0; band < numberOfBands; ++band)
{
T* inputBuf = static_cast<T*>(inputData->getBuf(band))+startInputOffset;
T* outputBuf = static_cast<T*>(outputData->getBuf(band));
T maxPix = static_cast<T>(getMaxPixelValue(band));
T minPix = static_cast<T>(getMinPixelValue(band));
if(inputBuf&&outputBuf)
{
for(ossim_uint32 row = 0; row < outputW; ++row)
{
ossim_int32 rowOffset = inputW*row;
ulKernelStartBuf = inputBuf + (rowOffset + ulKernelStart);
ul1KernelStartBuf = inputBuf + (rowOffset + ul1KernelStart);
leftKernelStartBuf = inputBuf + (rowOffset + leftKernelStart);
ll1KernelStartBuf = inputBuf + (rowOffset + ll1KernelStart);
llKernelStartBuf = inputBuf + (rowOffset + llKernelStart);
for(ossim_uint16 i=0;i<BOXSIZE;i++)
{
KernelStartBuf[i] = inputBuf + (rowOffset + KernelStart[i]);
}
for(ossim_uint32 col = 0; col < outputH; ++col)
{
//calculate mean
sum = 0.0;
sqrsum = 0.0;
for(ossim_uint32 r=0; r<5; ++r)
sum += theKernel[0][r]*(double)ulKernelStartBuf[r];
for(ossim_uint32 r=0; r<5; ++r)
sum += theKernel[1][r]*(double)ul1KernelStartBuf[r];
for(ossim_uint32 r=0; r<5; ++r)
sum += theKernel[2][r]*(double)leftKernelStartBuf[r];
for(ossim_uint32 r=0; r<5; ++r)
sum += theKernel[3][r]*(double)ll1KernelStartBuf[r];
for(ossim_uint32 r=0; r<5; ++r)
sum += theKernel[4][r]*(double)llKernelStartBuf[r];
/*
for(ossim_uint16 i=0;i<BOXSIZE;i++)
{
for(ossim_uint32 r=0; r<5; ++r)
{
sum += theKernel[i][r]*(double)KernelStartBuf[i][r];
sqrsum += theKernel[i][r]*(double)KernelStartBuf[i][r]
*(double)KernelStartBuf[i][r];
}
}
*/
//calculate mean of squares
for(ossim_uint32 r=0; r<5; ++r)
sqrsum += theKernel[0][r]*(double)ulKernelStartBuf[r]
*(double)ulKernelStartBuf[r];
for(ossim_uint32 r=0; r<5; ++r)
sqrsum += theKernel[1][r]*(double)ul1KernelStartBuf[r]
*(double)ul1KernelStartBuf[r];
for(ossim_uint32 r=0; r<5; ++r)
sqrsum += theKernel[2][r]*(double)leftKernelStartBuf[r]
*(double)leftKernelStartBuf[r];
for(ossim_uint32 r=0; r<5; ++r)
sqrsum += theKernel[3][r]*(double)ll1KernelStartBuf[r]
*(double)ll1KernelStartBuf[r];
for(ossim_uint32 r=0; r<5; ++r)
sqrsum += theKernel[4][r]*(double)llKernelStartBuf[r]
*(double)llKernelStartBuf[r];
//calculate variance
variance = sqrsum - (sum*sum);
//calculate k-value
sum = ((double)leftKernelStartBuf[2] - sum)/sqrt(variance);
//Threshold k-value
if(sum < theThreshold)
sum = minPix;
else
sum = maxPix;
/*
sum = theKernel[0][0]*(double)ulKernelStartBuf[0] +
theKernel[0][1]*(double)ulKernelStartBuf[1] +
theKernel[0][2]*(double)ulKernelStartBuf[2] +
theKernel[1][0]*(double)leftKernelStartBuf[0] +
theKernel[1][1]*(double)leftKernelStartBuf[1] +
theKernel[1][2]*(double)leftKernelStartBuf[2] +
theKernel[2][0]*(double)llKernelStartBuf[0] +
theKernel[2][1]*(double)llKernelStartBuf[1] +
theKernel[2][2]*(double)llKernelStartBuf[2];
*/
if(sum > maxPix)
{
*outputBuf = maxPix;
}
else if(sum < minPix)
{
*outputBuf = minPix;
}
else
{
*outputBuf = static_cast<T>(sum);
}
//
// Need to implement the convolution here.
//
++ulKernelStartBuf;
++ul1KernelStartBuf;
++leftKernelStartBuf;
++ll1KernelStartBuf;
++llKernelStartBuf;
++outputBuf;
}
}
}
}
}
template<class T> void rspf3x3ConvolutionFilter::convolveFull(
T,
rspfRefPtr<rspfImageData> inputData,
rspfRefPtr<rspfImageData> outputData)
{
// let's set up some temporary variables so we don't
// have to call the functions in loops. Iknow that compilers
// typically optimize this out but if we are in debug mode
// with no optimization it will still run fast
//
double sum = 0.0;
rspf_int32 inputW = static_cast<rspf_int32>(inputData->getWidth());
rspf_uint32 outputW = outputData->getWidth();
rspf_uint32 outputH = outputData->getHeight();
rspf_uint32 numberOfBands = inputData->getNumberOfBands();
rspfIpt outputOrigin = outputData->getOrigin();
rspfIpt inputOrigin = inputData->getOrigin();
rspf_int32 startInputOffset = std::abs(outputOrigin.y - inputOrigin.y)*
inputW + std::abs(outputOrigin.x - inputOrigin.x);
rspf_int32 ulKernelStart = -inputW - 1;
rspf_int32 leftKernelStart = -1;
rspf_int32 llKernelStart = inputW - 1;
T* ulKernelStartBuf = NULL;
T* leftKernelStartBuf = NULL;
T* llKernelStartBuf = NULL;
for(rspf_uint32 band = 0; band < numberOfBands; ++band)
{
T* inputBuf = static_cast<T*>(inputData->getBuf(band))+startInputOffset;
T* outputBuf = static_cast<T*>(outputData->getBuf(band));
T maxPix = static_cast<T>(getMaxPixelValue(band));
T minPix = static_cast<T>(getMinPixelValue(band));
if(inputBuf&&outputBuf)
{
for(rspf_uint32 row = 0; row < outputW; ++row)
{
rspf_int32 rowOffset = inputW*row;
ulKernelStartBuf = inputBuf + (rowOffset + ulKernelStart);
leftKernelStartBuf = inputBuf + (rowOffset + leftKernelStart);
llKernelStartBuf = inputBuf + (rowOffset + llKernelStart);
for(rspf_uint32 col = 0; col < outputH; ++col)
{
sum = theKernel[0][0]*(double)ulKernelStartBuf[0] +
theKernel[0][1]*(double)ulKernelStartBuf[1] +
theKernel[0][2]*(double)ulKernelStartBuf[2] +
theKernel[1][0]*(double)leftKernelStartBuf[0] +
theKernel[1][1]*(double)leftKernelStartBuf[1] +
theKernel[1][2]*(double)leftKernelStartBuf[2] +
theKernel[2][0]*(double)llKernelStartBuf[0] +
theKernel[2][1]*(double)llKernelStartBuf[1] +
theKernel[2][2]*(double)llKernelStartBuf[2];
if(sum > maxPix)
{
*outputBuf = maxPix;
}
else if(sum < minPix)
{
*outputBuf = minPix;
}
else
{
*outputBuf = static_cast<T>(sum);
}
//
// Need to implement the convolution here.
//
++ulKernelStartBuf;
++leftKernelStartBuf;
++llKernelStartBuf;
++outputBuf;
}
}
}
}
}
void ossimTileToIplFilter::CopyIplImageToTile(T dummyVariable, ossimRefPtr<ossimImageData> inputTile, IplImage *output)
{
// Determine if tile is full or partially filled
ossimDataObjectStatus status = inputTile->getDataObjectStatus();
uchar *outputData = (uchar *)output->imageData;
int outputStep = output->widthStep/sizeof(uchar);
int pixVal;
long outputOffset = 0;
T maxPix = static_cast<T>(getMaxPixelValue(0));
T minPix = static_cast<T>(getMinPixelValue(0));
T np = static_cast<T>(inputTile->getNullPix(0));
if (status == OSSIM_PARTIAL)
{
for (ossim_uint32 bandIdx = 0; bandIdx < inputTile->getNumberOfBands(); ++bandIdx)
{
T* outBuf = static_cast<T*>(inputTile->getBuf(bandIdx));
if (outBuf)
{
outputOffset = 0;
for (long y = 0; y < output->height; ++y)
{
for (long x = 0; x < output->width; ++x)
{
if (!inputTile->isNull(outputOffset))
{
pixVal = (int)round(outputData[y * outputStep + x]);
if (pixVal > maxPix)
*outBuf = maxPix;
else if (pixVal < 0)
*outBuf = minPix;
else
*outBuf = static_cast<T>(pixVal);
}
else
inputTile->setNull(outputOffset);
++outBuf;
++outputOffset;
}
}
}
}
}
else
{
for (ossim_uint32 bandIdx = 0; bandIdx < inputTile->getNumberOfBands(); ++bandIdx)
{
T* outBuf = (T*)(inputTile->getBuf(bandIdx));
if (outBuf)
{
for (int y = 0; y < output->height; ++y)
{
for (int x = 0; x < output->width; ++x)
{
pixVal = (int)round(outputData[y * outputStep + x]);
if (pixVal > maxPix)
*outBuf = (maxPix);
else if (pixVal < 0)
*outBuf = (minPix);
else
*outBuf = static_cast<T>(pixVal);
// Increment the output buffer to the next pixel value
++outBuf;
}
}
}
else
*outBuf = np;
}
}
}
