rspfRefPtr<rspfImageData> rspfCacheTileSource::getTile( const rspfIrect& tileRect, rspf_uint32 resLevel) { rspfRefPtr<rspfImageData> result = 0; if ( theInputConnection ) { if ( isSourceEnabled() ) { if(!theTile.valid()) { allocate(); } if (theTile.valid()) { theTile->setImageRectangle(tileRect); theTile->makeBlank(); // see if we can get a valid cache at the given resolution level if(getCacheId(resLevel) < 0) { return theInputConnection->getTile(tileRect, resLevel); } result = fillTile(resLevel); } } else // Not enabled... { result = theInputConnection->getTile(tileRect, resLevel); } } // End: if ( theInputConnection ) return result; }
void Map::loadTilesSync(QList<Tile> &list) { QList<Download> dl; for (int i = 0; i < list.size(); i++) { Tile &t = list[i]; QString file = tileFile(t); QFileInfo fi(file); if (!fi.exists()) dl.append(Download(tileUrl(t), file)); else loadTileFile(t, file); } if (dl.empty()) return; QEventLoop wait; connect(&Downloader::instance(), SIGNAL(finished()), &wait, SLOT(quit())); if (Downloader::instance().get(dl)) wait.exec(); for (int i = 0; i < list.size(); i++) { Tile &t = list[i]; if (t.pixmap().isNull()) { QString file = tileFile(t); QFileInfo fi(file); if (!(fi.exists() && loadTileFile(t, file))) fillTile(t); } } }
double SRTMProvider::getAltitude(double lat, double lon) { double altitude = 0.0; // Defaultwert für Höhe ist NN index = latLonToIndex(int(floor(lat)), int(floor(lon))); SRTMTile *tile = new SRTMTile(index); lock.lockForRead(); if(tileCache.contains(index)){ tile = tileCache[index]; } else { lock.unlock(); lock.lockForWrite(); if(fillTile(index, &tile)){ tileCache.insert(index, tile); } else{ lock.unlock(); return altitude; } } //lock.unlock(); //lock.lockForRead(); altitude = tile->getAltitudeFromLatLon(lat, lon); lock.unlock(); return altitude; }
void Oubliette::paintOubliette(QPainter *p, const QRect &paintRect) { // snap down int tile_x1 = paintRect.x() / TileWidth; int tile_y1 = paintRect.y() / TileHeight; // snap up int tile_x2 = (paintRect.x() + paintRect.width()) / TileWidth + TileWidth; int tile_y2 = (paintRect.y() + paintRect.height()) / TileHeight + TileHeight; OublietteLevel *level = m_oubliettePlan.level(m_currentLevel); for (int y = tile_y1; y <= tile_y2; ++y) { for (int x = tile_x1; x <= tile_x2; ++x) { fillTile(p, x, y, level->tile(x, y)); } } }
void Map::loadTilesAsync(QList<Tile> &list) { QList<Download> dl; for (int i = 0; i < list.size(); i++) { Tile &t = list[i]; QString file = tileFile(t); QFileInfo fi(file); if (!fi.exists()) { fillTile(t); dl.append(Download(tileUrl(t), file)); } else loadTileFile(t, file); } if (!dl.empty()) Downloader::instance().get(dl); }
void makeTileSet(std::vector<int>& tiles, int width, std::vector<float>& tuv, float timeStratQuality) { assert(timeStratQuality >= 0 && timeStratQuality <= 1); assert(width >= 4); assert((int)tuv.size() == 3*width*width); // Radius of region over which to evenly distribute samples int r = 2; if(width < 8) r = 1; // Number of tile colors const int ncol = 3; // Edge tile width int eWidth = r + r%2; // Corner tile width int cWidth = 2*r + eWidth; int fullwidth = width + eWidth; // Working space for computing tiles. std::vector<int> tileStor(fullwidth*fullwidth, -1); int* tile = cbegin(tileStor); // First, create corner tiles // -------------------------- int cSize = cWidth*cWidth; std::vector<int> cornerStor(cSize*3,-1); int* corners[] = { cbegin(cornerStor), cbegin(cornerStor) + cSize, cbegin(cornerStor) + 2*cSize }; fillTile(tile, width, width, r, cbegin(tuv), timeStratQuality); copyBlock2d(corners[0], cWidth, tile, width, 0,0, 0,0, cWidth,cWidth); if(2*cWidth <= width) { // cWidth is small enough that we can cut out two more corner tiles // from the original tile copyBlock2d(corners[1], cWidth, tile, width, 0,0, width/2,0, cWidth,cWidth); copyBlock2d(corners[2], cWidth, tile, width, 0,0, width/2,width/2, cWidth,cWidth); } else { // else need to optimize a new tile to cut out each corner, to avoid // duplication of sample patterns tileStor.assign(tileStor.size(), -1); fillTile(tile, width, width, r, cbegin(tuv), timeStratQuality); copyBlock2d(corners[1], cWidth, tile, width, 0,0, 0,0, cWidth,cWidth); tileStor.assign(tileStor.size(), -1); fillTile(tile, width, width, r, cbegin(tuv), timeStratQuality); copyBlock2d(corners[2], cWidth, tile, width, 0,0, 0,0, cWidth,cWidth); } // Overwrite sections of the corner tiles with -1 (the invalid index) This // makes sure the corner tiles take up the minimum number of tuv indices // possible. for(int j = 0; j < cWidth; ++j) { for(int i = 0; i < cWidth; ++i) { if((i < r || i >= cWidth-r) && (j < r || j >= cWidth-r)) { corners[0][j*cWidth + i] = -1; corners[1][j*cWidth + i] = -1; corners[2][j*cWidth + i] = -1; } } } // Second, create edge tiles // ------------------------- int eLen = width - cWidth; int eSize = eLen*eWidth; int nEdges = ncol*ncol; // number of horizontal or vertical edges std::vector<int> edgeStor(eSize*2*nEdges,-1); std::vector<int*> horizEdges(nEdges); std::vector<int*> vertEdges(nEdges); for(int iedge = 0; iedge < nEdges; ++iedge) { horizEdges[iedge] = &edgeStor[eSize*iedge]; vertEdges[iedge] = &edgeStor[eSize*(iedge+nEdges)]; // Corner indices for current edges int c1 = iedge % ncol; int c2 = iedge / ncol; // Insert corner samples into top left and top right of tile: // // +--------------+ // |C C| C = corner // |CCeeeeeeeeeeCC| e = edge to be extracted // |CCeeeeeeeeeeCC| // |C C| // | | // . . int cw2 = cWidth/2; tileStor.assign(tileStor.size(), -1); copyBlock2d(tile, width, corners[c1], cWidth, 0,0, cw2,0, cw2,cWidth); copyBlock2d(tile, width, corners[c2], cWidth, width-cw2,0, 0,0, cw2,cWidth); // optimize tile & extract newly optimized edge fillTile(tile, width, width, r, cbegin(tuv), timeStratQuality); copyBlock2d(horizEdges[iedge], eLen, tile, width, 0,0, cw2,r, eLen,eWidth); // Now do the same thing for the vertical edges. tileStor.assign(tileStor.size(), -1); copyBlock2d(tile, width, corners[c1], cWidth, 0,0, 0,cw2, cWidth,cw2); copyBlock2d(tile, width, corners[c2], cWidth, 0,width-cw2, 0,0, cWidth,cw2); fillTile(tile, width, width, r, cbegin(tuv), timeStratQuality); copyBlock2d(vertEdges[iedge], eWidth, tile, width, 0,0, r,cw2, eWidth,eLen); } // Third, create the full tiles // ---------------------------- // We now have a consistent set of coloured corners and all possible // associated edges. Fill in the tiles themselves using these corners & // edges as the boundaries // Record tile positions which need to have the indices de-duplicated. std::vector<int> deDupInd; deDupInd.reserve(2*width*eWidth - eWidth*eWidth); int ew2 = eWidth/2; for(int j = 0; j < width; ++j) for(int i = 0; i < width; ++i) { if((i < ew2 || i >= width-ew2) || (j < ew2 || j >= width-ew2)) deDupInd.push_back((j+ew2)*fullwidth + i+ew2); } int nsamps = width*width; int ntiles = ncol*ncol*ncol*ncol; tiles.assign(nsamps*ntiles,-1); for(int itile = 0; itile < ntiles; ++itile) { // Fill in tile boundaries to look something like // // c1 c2 // CCCeeeeeeCCC // CCCeeeeeeCCC // CC--------CC // ee--------ee // ee--------ee // CC--------CC // CCCeeeeeeCCC // CCCeeeeeeCCC // c3 c4 // // corner indices int c1 = itile % ncol; int c2 = (itile/ncol) % ncol; int c3 = (itile/(ncol*ncol)) % ncol; int c4 = itile/(ncol*ncol*ncol); // Fill in corners tileStor.assign(tileStor.size(), -1); int cw = cWidth-r; copyBlock2d(tile, fullwidth, corners[c1], cWidth, 0,0, r,r, cw,cw); copyBlock2d(tile, fullwidth, corners[c2], cWidth, fullwidth-cw,0, 0,r, cw,cw); copyBlock2d(tile, fullwidth, corners[c2], cWidth, 0,fullwidth-cw, r,0, cw,cw); copyBlock2d(tile, fullwidth, corners[c2], cWidth, fullwidth-cw,fullwidth-cw, 0,0, cw,cw); // Fill in edges copyBlock2d(tile, fullwidth, horizEdges[ncol*c2 + c1], eLen, cw,0, 0,0, eLen,eWidth); copyBlock2d(tile, fullwidth, horizEdges[ncol*c4 + c3], eLen, cw,fullwidth-eWidth, 0,0, eLen,eWidth); copyBlock2d(tile, fullwidth, vertEdges[ncol*c3 + c1], eWidth, 0,cw, 0,0, eWidth,eLen); copyBlock2d(tile, fullwidth, vertEdges[ncol*c4 + c2], eWidth, fullwidth-eWidth,cw, 0,0, eWidth,eLen); // Remove duplicate indices inside the central width x width region std::sort(deDupInd.begin(), deDupInd.end(), IndirectLessFunctor(tile)); for(int k = 0, kend=deDupInd.size()-1; k < kend; ++k) { int currSamp = tile[deDupInd[k]]; if(tile[deDupInd[k+1]] == currSamp) { // currSamp is a duplicate of the next sample index, choose // the next closest sample instead, as measured by the // distance in time-lens space. float t = tuv[3*currSamp]; float u = tuv[3*currSamp+1]; float v = tuv[3*currSamp+2]; float tWeight = 4*timeStratQuality; float uvWeight = 1 - timeStratQuality; float minDist2 = FLT_MAX; int bestReplacement = -1; for(int isamp = 0; isamp < nsamps; ++isamp) { if(isamp == currSamp) continue; float dt = t - tuv[3*isamp]; float du = u - tuv[3*isamp+1]; float dv = v - tuv[3*isamp+2]; float dist2 = tWeight*dt*dt + uvWeight*(du*du + dv*dv); if(dist2 < minDist2) { // isamp looks promising out of the ones we've tried // so far, but check that it's not already used before // storing it. bool valid = true; // simple linear search. This shouldn't be called very // many times. for(int i = 0, iend = deDupInd.size(); i < iend; ++i) { if(tile[deDupInd[i]] == isamp) { valid = false; break; } } if(valid) { bestReplacement = isamp; minDist2 = dist2; } } } assert(bestReplacement != -1); tile[deDupInd[k]] = bestReplacement; } } // Optimize tile & save the result fillTile(tile, fullwidth, width, r, cbegin(tuv), timeStratQuality); copyBlock2d(&tiles[nsamps*itile], width, tile, fullwidth, 0,0, eWidth/2,eWidth/2, width,width); } }
ossimRefPtr<ossimImageData> ossimShiftFilter::getTile( const ossimIrect& tileRect, ossim_uint32 resLevel) { ossimRefPtr<ossimImageData> result = 0; if ( theInputConnection ) { ossimRefPtr<ossimImageData> inputTile = theInputConnection->getTile( tileRect, resLevel ); if ( inputTile.get() && isSourceEnabled() && !ossim::isnan(m_null) && !ossim::isnan(m_min) && !ossim::isnan(m_max) ) { // Get its status of the input tile. ossimDataObjectStatus tile_status = inputTile->getDataObjectStatus(); if ( tile_status != OSSIM_NULL ) { if ( !m_tile ) { allocate(); // First time through. } if ( tile_status != OSSIM_EMPTY ) { // Set the origin,bands of the output tile. m_tile->setImageRectangle(tileRect); switch(inputTile->getScalarType()) { case OSSIM_UINT8: { fillTile( ossim_uint8(0), inputTile.get(), m_tile.get() ); break; } case OSSIM_SINT8: { fillTile( ossim_sint8(0), inputTile.get(), m_tile.get() ); break; } case OSSIM_UINT16: case OSSIM_USHORT11: { fillTile( ossim_uint16(0), inputTile.get(), m_tile.get() ); break; } case OSSIM_SINT16: { fillTile( ossim_sint16(0), inputTile.get(), m_tile.get() ); break; } case OSSIM_SINT32: { fillTile( ossim_sint32(0), inputTile.get(), m_tile.get() ); break; } case OSSIM_UINT32: { fillTile( ossim_uint32(0), inputTile.get(), m_tile.get() ); break; } case OSSIM_FLOAT32: case OSSIM_NORMALIZED_FLOAT: { fillTile( ossim_float32(0), inputTile.get(), m_tile.get() ); break; } case OSSIM_FLOAT64: case OSSIM_NORMALIZED_DOUBLE: { fillTile( ossim_float64(0), inputTile.get(), m_tile.get() ); break; } case OSSIM_SCALAR_UNKNOWN: default: { ossimNotify(ossimNotifyLevel_WARN) << "ossimShiftFilter::getTile ERROR Unhandled scalar!" << endl; break; } } // Matches: switch(inputTile->getScalarType()) m_tile->validate(); } else { m_tile->makeBlank(); } result = m_tile; } // Matches: if ( tile_status != OSSIM_NULL ) } // Matches: if ( inputTile.get() ... ) if ( !result && inputTile.get() ) { result = inputTile; } } // Matches: if ( theInputConnection ) return result; }
bool ossimPngReader::getTile(ossimImageData* result, ossim_uint32 resLevel) { bool status = false; //--- // 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) { if(m_outputScalarType == OSSIM_UINT16) { //--- // Temp fix: // The overview handler could return a tile of OSSIM_USHORT11 if // the max sample value was not set to 2047. // // To prevent a scalar mismatch set //--- result->setScalarType(m_outputScalarType); } } 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. m_tile->makeBlank(); } if (getImageRectangle(0).intersects(tile_rect)) { // Make a clip rect. ossimIrect clip_rect = tile_rect.clipToRect(getImageRectangle(0)); // This will validate the tile at the end. fillTile(clip_rect, result); } } result->unref(); // Decrement ref count. } return status; }