bool ossimGui::StaticTileImageCache::addTile(const QImage& image)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(m_mutex);
bool result = false;
ossimIrect tileRect(image.offset().x(),
image.offset().y(),
image.offset().x() + (image.width()-1),
image.offset().y() + (image.height()-1));
ossimIrect cacheRect = m_cacheRect;
if(tileRect.intersects(cacheRect))
{
ossimIrect clipRect = tileRect.clipToRect(cacheRect);
// now fill the clipped rect
ossim_uint32 srcY = clipRect.ul().y-tileRect.ul().y;
ossim_uint32 srcX = clipRect.ul().x-tileRect.ul().x;
ossim_uint32 destY = clipRect.ul().y-cacheRect.ul().y;
ossim_uint32 destX = clipRect.ul().x-cacheRect.ul().x;
ossimIpt offset = tileRect.ul() - cacheRect.ul();
ossim_uint32 x,y;
for(y = 0; y < clipRect.height(); ++y)
{
ossim_uint32* cachePtr = ((ossim_uint32*)m_cache->scanLine(y+destY))+destX;
ossim_uint32* tilePtr = ((ossim_uint32*)image.scanLine(y+srcY))+srcX;
for(x = 0; x < clipRect.width(); ++x)
{
*cachePtr = *tilePtr;
++cachePtr;
++tilePtr;
}
}
ossimIpt tilePoint(tileRect.ul());
for(y = 0; y < tileRect.height(); y+=m_tileSize.y)
{
tilePoint.x = tileRect.ul().x;
for(x = 0; x < tileRect.width(); x+=m_tileSize.x)
{
ossim_int32 idx = getTileIndex(m_cacheRect, m_numberOfTiles, tilePoint);
if(idx>=0)
{
m_validTileArray[idx] = true;
}
tilePoint.x+= m_tileSize.x;
}
tilePoint.y+=m_tileSize.y;
}
result = true;
}
return result;
}
bool ossimQtStaticTileImageCache::addTile(QImage& image)
{
bool result = false;
if(((image.offset().x()%theTileSize.x)==0)&&
((image.offset().y()%theTileSize.y)==0)&&
(image.width() == theTileSize.x)&&
(image.height() == theTileSize.y))
{
ossimIrect tileRect(image.offset().x(),
image.offset().y(),
image.offset().x() + (image.width()-1),
image.offset().y() + (image.height()-1));
ossimIrect cacheRect = getCacheRect();
if(tileRect.completely_within(cacheRect))
{
QRgb* tilePtr = (QRgb*)image.bits();
ossimIpt offset = tileRect.ul() - cacheRect.ul();
int x = 0;
int y = 0;
for(y = 0; y < theTileSize.y; ++y)
{
QRgb* cachePtr = ((QRgb*)theCache.scanLine(y+offset.y))+offset.x;
for(x = 0; x < theTileSize.x; ++x)
{
*cachePtr = *tilePtr;
++cachePtr;
++tilePtr;
}
}
ossim_int32 idx = getTileIndex(tileRect.ul());
theValidTileArray[idx] = true;
result = true;
}
}
return result;
}
void ossimGui::StaticTileImageCache::getSubImage(QImage& image)const
{
QPoint ulSubImage(image.offset().x(),
image.offset().y());
QPoint ulCache(m_cache->offset().x(),
m_cache->offset().y());
image = m_cache->copy(ulSubImage.x() - ulCache.x(),
ulSubImage.y() - ulCache.y(),
image.width(),
image.height());
}
void ossimQtStaticTileImageCache::getSubImage(QImage& image)const
{
QPoint ulSubImage(image.offset().x(),
image.offset().y());
QPoint ulCache(theCache.offset().x(),
theCache.offset().y());
image = theCache.copy(ulSubImage.x() - ulCache.x(),
ulSubImage.y() - ulCache.y(),
image.width(),
image.height());
}
bool Q_INTERNAL_WIN_NO_THROW QPNGImageWriter::writeImage(const QImage& image, volatile int quality_in, const QString &description,
int off_x_in, int off_y_in)
{
QPoint offset = image.offset();
int off_x = off_x_in + offset.x();
int off_y = off_y_in + offset.y();
png_structp png_ptr;
png_infop info_ptr;
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,0,0,0);
if (!png_ptr) {
return false;
}
png_set_error_fn(png_ptr, 0, 0, qt_png_warning);
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_write_struct(&png_ptr, 0);
return false;
}
if (setjmp(png_jmpbuf(png_ptr))) {
png_destroy_write_struct(&png_ptr, &info_ptr);
return false;
}
int quality = quality_in;
if (quality >= 0) {
if (quality > 9) {
qWarning("PNG: Quality %d out of range", quality);
quality = 9;
}
png_set_compression_level(png_ptr, quality);
}
png_set_write_fn(png_ptr, (void*)this, qpiw_write_fn, qpiw_flush_fn);
int color_type = 0;
if (image.colorCount()) {
if (image.isGrayscale())
color_type = PNG_COLOR_TYPE_GRAY;
else
color_type = PNG_COLOR_TYPE_PALETTE;
}
else if (image.format() == QImage::Format_Grayscale8)
color_type = PNG_COLOR_TYPE_GRAY;
else if (image.hasAlphaChannel())
color_type = PNG_COLOR_TYPE_RGB_ALPHA;
else
color_type = PNG_COLOR_TYPE_RGB;
png_set_IHDR(png_ptr, info_ptr, image.width(), image.height(),
image.depth() == 1 ? 1 : 8, // per channel
color_type, 0, 0, 0); // sets #channels
if (gamma != 0.0) {
png_set_gAMA(png_ptr, info_ptr, 1.0/gamma);
}
if (image.format() == QImage::Format_MonoLSB)
png_set_packswap(png_ptr);
if (color_type == PNG_COLOR_TYPE_PALETTE) {
// Paletted
int num_palette = qMin(256, image.colorCount());
png_color palette[256];
png_byte trans[256];
int num_trans = 0;
for (int i=0; i<num_palette; i++) {
QRgb rgba=image.color(i);
palette[i].red = qRed(rgba);
palette[i].green = qGreen(rgba);
palette[i].blue = qBlue(rgba);
trans[i] = qAlpha(rgba);
if (trans[i] < 255) {
num_trans = i+1;
}
}
png_set_PLTE(png_ptr, info_ptr, palette, num_palette);
if (num_trans) {
png_set_tRNS(png_ptr, info_ptr, trans, num_trans, 0);
}
}
// Swap ARGB to RGBA (normal PNG format) before saving on
// BigEndian machines
if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
png_set_swap_alpha(png_ptr);
}
// Qt==ARGB==Big(ARGB)==Little(BGRA). But RGB888 is RGB regardless
if (QSysInfo::ByteOrder == QSysInfo::LittleEndian
&& image.format() != QImage::Format_RGB888) {
png_set_bgr(png_ptr);
}
if (off_x || off_y) {
png_set_oFFs(png_ptr, info_ptr, off_x, off_y, PNG_OFFSET_PIXEL);
}
if (frames_written > 0)
png_set_sig_bytes(png_ptr, 8);
if (image.dotsPerMeterX() > 0 || image.dotsPerMeterY() > 0) {
png_set_pHYs(png_ptr, info_ptr,
image.dotsPerMeterX(), image.dotsPerMeterY(),
PNG_RESOLUTION_METER);
}
set_text(image, png_ptr, info_ptr, description);
png_write_info(png_ptr, info_ptr);
if (image.depth() != 1)
png_set_packing(png_ptr);
if (color_type == PNG_COLOR_TYPE_RGB && image.format() != QImage::Format_RGB888)
png_set_filler(png_ptr, 0,
QSysInfo::ByteOrder == QSysInfo::BigEndian ?
PNG_FILLER_BEFORE : PNG_FILLER_AFTER);
if (looping >= 0 && frames_written == 0) {
uchar data[13] = "NETSCAPE2.0";
// 0123456789aBC
data[0xB] = looping%0x100;
data[0xC] = looping/0x100;
png_write_chunk(png_ptr, const_cast<png_bytep>((const png_byte *)"gIFx"), data, 13);
}
if (ms_delay >= 0 || disposal!=Unspecified) {
uchar data[4];
data[0] = disposal;
data[1] = 0;
data[2] = (ms_delay/10)/0x100; // hundredths
data[3] = (ms_delay/10)%0x100;
png_write_chunk(png_ptr, const_cast<png_bytep>((const png_byte *)"gIFg"), data, 4);
}
int height = image.height();
int width = image.width();
switch (image.format()) {
case QImage::Format_Mono:
case QImage::Format_MonoLSB:
case QImage::Format_Indexed8:
case QImage::Format_Grayscale8:
case QImage::Format_RGB32:
case QImage::Format_ARGB32:
case QImage::Format_RGB888:
{
png_bytep* row_pointers = new png_bytep[height];
for (int y=0; y<height; y++)
row_pointers[y] = const_cast<png_bytep>(image.constScanLine(y));
png_write_image(png_ptr, row_pointers);
delete [] row_pointers;
}
break;
default:
{
QImage::Format fmt = image.hasAlphaChannel() ? QImage::Format_ARGB32 : QImage::Format_RGB32;
QImage row;
png_bytep row_pointers[1];
for (int y=0; y<height; y++) {
row = image.copy(0, y, width, 1).convertToFormat(fmt);
row_pointers[0] = const_cast<png_bytep>(row.constScanLine(0));
png_write_rows(png_ptr, row_pointers, 1);
}
}
break;
}
png_write_end(png_ptr, info_ptr);
frames_written++;
png_destroy_write_struct(&png_ptr, &info_ptr);
return true;
}
