ossim_uint32 ossimImageCombiner::getNumberOfOverlappingImages(const ossimIrect& rect,
ossim_uint32 resLevel)const
{
if(theComputeFullResBoundsFlag)
{
precomputeBounds();
}
double scale = 1.0/std::pow(2.0, (double)resLevel);
ossimDpt scalar(scale, scale);
ossim_uint32 result = 0;
ossim_uint32 maxIndex = getNumberOfInputs();
for(ossim_uint32 inputIndex = 0; inputIndex < maxIndex; ++inputIndex)
{
if(!theFullResBounds[inputIndex].hasNans())
{
ossimIrect boundingRect = theFullResBounds[inputIndex] * scalar;
if(rect.intersects(boundingRect))
{
++result;
}
}
}
return result;
}
void ossimImageCombiner::getOverlappingImages(std::vector<ossim_uint32>& result,
const ossimIrect& rect,
ossim_uint32 resLevel)const
{
if(theComputeFullResBoundsFlag)
{
precomputeBounds();
}
double scale = 1.0/std::pow(2.0, (double)resLevel);
ossimDpt scalar(scale, scale);
ossim_uint32 inputIndex;
ossimIrect boundingRect;
for(inputIndex = 0; inputIndex < getNumberOfInputs(); ++inputIndex)
{
if(!theFullResBounds[inputIndex].hasNans())
{
boundingRect = theFullResBounds[inputIndex]*scalar;
if(rect.intersects(boundingRect))
{
result.push_back(inputIndex);
}
}
}
}
vector<ossimImageCacheBase::ossimFrameEntryData> ossimImageCacheBase::getIntersectingEntries(const ossimIrect& rect)
{
vector<ossimFrameEntryData> result;
// make sure we have the Toc entry to render
if(!isOpen()) return result;
ossimIrect imageRect = getImageRectangle();
if(rect.intersects(imageRect))
{
ossimIrect clipRect = rect.clipToRect(imageRect);
ossimIrect frameRect(clipRect.ul().x/m_frame_width,
clipRect.ul().y/m_frame_height,
clipRect.lr().x/m_frame_width,
clipRect.lr().y/m_frame_height);
for(ossim_int32 row = frameRect.ul().y; row <= frameRect.lr().y; ++row)
{
for(ossim_int32 col = frameRect.ul().x; col <= frameRect.lr().x; ++col)
{
ossimRpfFrameEntry tempEntry = m_frameEntryArray[row][col];
if(tempEntry.exists())
{
result.push_back(ossimFrameEntryData(row,
col,
row*m_frame_height,
col*m_frame_width,
tempEntry));
}
}
}
}
return result;
}
void ossimQtScrollingImageWidget::convertRequest(const ossimIrect& reqRect)
{
if(theRgbChain->getInput())
{
QImage tempImage(theTileSize.x,
theTileSize.y,
32);
tempImage.fill(0);
ossimIrect shiftedCacheRect = theBackingStoreCache.getCacheRect() - theShiftToZeroZero;
ossimIrect tempRect = getAbsoluteViewportRect();
tempImage.setOffset(QPoint(theShiftToZeroZero.x + reqRect.ul().x,
theShiftToZeroZero.y + reqRect.ul().y));
if(reqRect.intersects(shiftedCacheRect))
{
if(reqRect.intersects(theBoundingRect))
{
ossimRefPtr<ossimImageData> data = getTile(reqRect);
if(data.valid() && data->getBuf() &&
(data->getDataObjectStatus()!=OSSIM_EMPTY))
{
fillImage(data, &tempImage);
}
}
}
else
{
return;
}
theBackingStoreCache.addTile(tempImage);
ossimIrect viewClip = reqRect.clipToRect(tempRect);
viewClip = viewClip + theShiftToZeroZero;
int xLoc = viewClip.ul().x;
int yLoc = viewClip.ul().y;
int xSize = theTileSize.x;
int ySize = theTileSize.y;
eraseCursor();
repaintContents(xLoc, yLoc, xSize, ySize, false);
}
}
ossimRefPtr<ossimImageData> ossimKakaduJ2kReader::getTile(
const ossimIrect& rect, ossim_uint32 resLevel)
{
// This tile source bypassed, or invalid res level, return a blank tile.
if(!isSourceEnabled() || !isOpen() || !isValidRLevel(resLevel))
{
return ossimRefPtr<ossimImageData>();
}
if (theTile.valid())
{
// Rectangle must be set prior to getOverviewTile call.
theTile->setImageRectangle(rect);
if (resLevel)
{
if ( getOverviewTile(resLevel, theTile.get() ) == false )
{
theTile->makeBlank();
}
}
else
{
//---
// See if the whole tile is going to be filled, if not, start out with
// a blank tile so data from a previous load gets wiped out.
//---
if ( !rect.completely_within(theImageRect) )
{
// Start with a blank tile.
theTile->makeBlank();
}
//---
// See if any point of the requested tile is in the image.
//---
if ( rect.intersects(theImageRect) )
{
ossimIrect clipRect = rect.clipToRect(theImageRect);
ossimIrect exandedRect = clipRect;
//---
// Shift the upper left corner of the "clip_rect" to the an even
// j2k tile boundry.
//---
exandedRect.stretchToTileBoundary(ossimIpt(theTileSizeX,
theTileSizeY));
// Vertical tile loop.
ossim_int32 y = exandedRect.ul().y;
while (y < exandedRect.lr().y)
{
// Horizontal tile loop.
ossim_int32 x = exandedRect.ul().x;
while (x < exandedRect.lr().x)
{
if ( loadTileFromCache(x, y, clipRect) == false )
{
if ( loadTile(x, y) )
{
//---
// Note: Clip the cache tile to the image clipRect
// since there are j2k tiles that go beyond the image
// dimensions, i.e., edge tiles.
//---
ossimIrect cr =
theCacheTile->getImageRectangle().
clipToRect(clipRect);
theTile->loadTile(theCacheTile->getBuf(),
theCacheTile->getImageRectangle(),
cr,
OSSIM_BSQ);
}
}
x += theTileSizeX; // Go to next tile.
}
y += theTileSizeY; // Go to next row of tiles.
}
// Set the tile status.
theTile->validate();
} // matches: if ( rect.intersects(theImageRect) )
} // r0 block
} // matches: if (theTile.valid())
return theTile;
}
ossimRefPtr<ossimImageData> ossimWatermarkFilter::getTile(
const ossimIrect& tile_rect, ossim_uint32 resLevel)
{
// Lock for the length of this method.
// Check for input.
if (!theInputConnection)
{
if (theTile.valid())
{
theTile->setImageRectangle(tile_rect);
theTile->makeBlank();
}
return theTile;
}
// Fetch a tile from from the input source.
ossimRefPtr<ossimImageData> inputTile =
theInputConnection->getTile(tile_rect, resLevel);
// Check for bypass.
if (theEnableFlag == false) return inputTile;
// Check for weight being 0.0.
if (theWatermarkWeight == 0.0) return inputTile;
//---
// Check for dirty state.
// Note: This is set in initialize if something changes.
//---
if (theDirtyFlag == true)
{
if (allocate() == false) // Something not right if false.
{
return inputTile;
}
}
// We will only watermark (process) within the input bounding rectangle.
if (tile_rect.intersects(theInputBoundingRect) == false)
{
return inputTile;
}
// Capture the rectangle and blank out theTile.
theTile->setImageRectangle(tile_rect);
if (inputTile.valid() &&
(inputTile->getDataObjectStatus() != OSSIM_NULL))
{
// Copy the inputTile to theTile.
theTile->loadTile(inputTile.get());
}
else
{
theTile->makeBlank();
}
// Write the watermarks...
switch(theTile->getScalarType())
{
case OSSIM_UINT8:
{
fill(ossim_uint8(0));
break;
}
case OSSIM_SINT8:
{
fill(ossim_sint8(0));
break;
}
case OSSIM_USHORT11:
case OSSIM_UINT16:
{
fill(ossim_uint16(0));
break;
}
case OSSIM_SINT16:
{
fill(ossim_sint16(0));
break;
}
case OSSIM_UINT32:
{
fill(ossim_uint32(0));
break;
}
case OSSIM_SINT32:
{
fill(ossim_sint32(0));
break;
}
case OSSIM_FLOAT32:
case OSSIM_NORMALIZED_FLOAT:
{
fill(ossim_float32(0));
break;
}
case OSSIM_FLOAT64:
case OSSIM_NORMALIZED_DOUBLE:
{
fill(ossim_float32(0));
break;
}
case OSSIM_SCALAR_UNKNOWN:
default:
{
ossimNotify(ossimNotifyLevel_WARN)
<< "Scalar type = " << theTile->getScalarType()
<< " Not supported by ossimWatermarkFilter" << std::endl;
return inputTile;
}
}
return theTile;
}
ossimRefPtr<ossimImageData> ossimMrSidReader::getTile(
const ossimIrect& rect, ossim_uint32 resLevel)
{
LT_STATUS sts = LT_STS_Uninit;
// This tile source bypassed, or invalid res level, return null tile.
if(!isSourceEnabled() || !isOpen() || !isValidRLevel(resLevel))
{
return ossimRefPtr<ossimImageData>();
}
ossimIrect imageBound = getBoundingRect(resLevel);
if(!rect.intersects(imageBound))
{
return ossimRefPtr<ossimImageData>();
}
// Check for overview.
if( resLevel > theMinDwtLevels )
{
if(theOverview.valid())
{
ossimRefPtr<ossimImageData> tileData = theOverview->getTile(rect, resLevel);
tileData->setScalarType(getOutputScalarType());
return tileData;
}
}
theTile->setImageRectangle(rect);
// Compute clip rectangle with respect to the image bounds.
ossimIrect clipRect = rect.clipToRect(imageBound);
if (rect.completely_within(clipRect) == false)
{
// Not filling whole tile so blank it out first.
theTile->makeBlank();
}
lt_uint16 anOssimBandIndex = 0;
LTIPixel pixel(theReader->getColorSpace(), theNumberOfBands, theReader->getDataType());
LTISceneBuffer sceneBuffer(pixel, clipRect.width(), clipRect.height(), NULL);
if (!theGeometry.valid())
{
theGeometry = getImageGeometry();
}
double mag = theGeometry->decimationFactor(resLevel).lat;
sts = theImageNavigator->setSceneAsULWH(clipRect.ul().x,
clipRect.ul().y,
clipRect.lr().x - clipRect.ul().x + 1,
clipRect.lr().y - clipRect.ul().y + 1, mag);
LTIScene scene = theImageNavigator->getScene();
sts = theReader->read(scene, sceneBuffer);
if (LT_SUCCESS(sts) == true)
{
for(anOssimBandIndex = 0; anOssimBandIndex < theNumberOfBands; anOssimBandIndex++)
{
theTile->loadBand(sceneBuffer.getTotalBandData(anOssimBandIndex),
clipRect, anOssimBandIndex);
}
}
theTile->validate();
return theTile;
}
