//create this image from another image (tile)
void Image::createThisFromImage(Image &image, int tileNum /*=-1*/, int iAlpha /*=-1*/)
{
cleanUp();
_init = Surface::create(image.tileW(), image.tileH(), iAlpha);
//prefill with alpha colour so the final surface contains it where curr see through
drawSolidRect(0,0,image.tileW(),image.tileH(), ALPHA_COLOUR);
if (-1 == tileNum)
setTileSize();
else
setTileSize(image.tileW(), image.tileH());
blitFrom(&image, tileNum); //into this newly created 'copy'
}
Image::Image(std::string filename, int xPos, int yPos)
{
setSurface(filename); //Loads entire image into memory
setRect(xPos, yPos, STDTILE, STDTILE); //Loads part of image specified by x and y position. Standard tilesize
setTileSize(STDTILE, STDTILE); //Uses the default tilesize
setColorKey(0,0,STDCKEY); //Uses the default colorkey
}
Image::Image(std::string filename)
{
setSurface(filename); //Loads entire image into memory
setRect(); //Load entire image into rectangle
setTileSize(surf->w, surf->h); //Sets tilesize using the entire image size
setColorKey(0,0,0); //No colorkey
}
void QQuickContext2DTexture::canvasChanged(const QSize& canvasSize, const QSize& tileSize, const QRect& canvasWindow, const QRect& dirtyRect, bool smooth, bool antialiasing)
{
QSize ts = tileSize;
if (ts.width() > canvasSize.width())
ts.setWidth(canvasSize.width());
if (ts.height() > canvasSize.height())
ts.setHeight(canvasSize.height());
setCanvasSize(canvasSize);
setTileSize(ts);
setCanvasWindow(canvasWindow);
if (canvasSize == canvasWindow.size()) {
m_tiledCanvas = false;
} else {
m_tiledCanvas = true;
}
if (dirtyRect.isValid())
setDirtyRect(dirtyRect);
setSmooth(smooth);
setAntialiasing(antialiasing);
}
bool rspfCacheTileSource::loadState(const rspfKeywordlist& kwl,
const char* prefix)
{
//rspfAppFixedTileCache::instance()->deleteCache(theCacheId);
//theCacheId = rspfAppFixedTileCache::instance()->newTileCache();
deleteRlevelCache();
const char* lookup = kwl.find(prefix, rspfKeywordNames::ENABLE_CACHE_KW);
if(lookup)
{
theCachingEnabled = rspfString(lookup).toBool();
}
lookup = kwl.find(prefix, USE_INPUT_TILE_SIZE_KW);
if(lookup)
{
theUseInputTileSizeFlag = rspfString(lookup).toBool();
}
lookup = kwl.find(prefix, TILE_SIZE_XY_KW);
if (lookup)
{
rspfIpt pt;
pt.toPoint(std::string(lookup));
setTileSize(pt);
}
bool result = rspfImageSourceFilter::loadState(kwl, prefix);
initialize();
return result;
}
//use the surface classes initSurface() fn to set up the image surface
bool Image::initImage(SDL_Surface *newSurface, int iAlpha /* =-1 */)
{
cleanUp();
_init = Surface::initSurface(newSurface, iAlpha);
setTileSize(_surface->w, _surface->h); //default to size of image
return _init;
}
Image::Image(unsigned int w, unsigned int h, int iAlpha /*=-1*/) :
Surface(), _init(false)
{
cleanUp();
_init = create(w, h, iAlpha); //create surface of required size
setTileSize(); //ensure tile size set (at least to size of image)
}
Image::Image(std::string filename, int xPos, int yPos, int width, int height, int rkey, int gkey, int bkey)
{
setSurface(filename);
setRect(xPos, yPos, width, height);
setTileSize(width, height);
setColorKey(rkey, gkey, bkey);
}
void BlueFramework::Engine::BlueMap::applyProperties( const buw::PropertySet& ps )
{
if (ps.contains("size"))
{
int size = ps.getInteger("size");
setTileSize(size);
}
}
QGeoMappingManagerEngineOsm::QGeoMappingManagerEngineOsm(const QMap<QString, QVariant> ¶meters, QGeoServiceProvider::Error *error, QString *errorString)
: QGeoTiledMappingManagerEngine(parameters),
m_parameters(parameters)
{
Q_UNUSED(error)
Q_UNUSED(errorString)
setTileSize(QSize(256,256));
setMinimumZoomLevel(0.0);
setMaximumZoomLevel(18.0);
m_tyleStyleId = "1";
QList<QGraphicsGeoMap::MapType> types;
types << QGraphicsGeoMap::StreetMap;
types << QGraphicsGeoMap::TerrainMap; // used for cyclemap
types << TRANSITMAP;
setSupportedMapTypes(types);
m_nam = new QNetworkAccessManager(this);
#ifdef USE_NETWORK_CACHE
m_cache = new QNetworkDiskCache(this);
QDir dir = QDir::temp();
dir.mkdir("maptiles-osm");
dir.cd("maptiles-osm");
m_cache->setCacheDirectory(dir.path());
#endif
QList<QString> keys = m_parameters.keys();
if (keys.contains("mapping.proxy")) {
QString proxy = m_parameters.value("mapping.proxy").toString();
if (!proxy.isEmpty())
m_nam->setProxy(QNetworkProxy(QNetworkProxy::HttpProxy, proxy, 8080));
}
#ifdef USE_NETWORK_CACHE
if (keys.contains("mapping.cache.directory")) {
QString cacheDir = m_parameters.value("mapping.cache.directory").toString();
if (!cacheDir.isEmpty())
m_cache->setCacheDirectory(cacheDir);
}
if (keys.contains("mapping.cache.size")) {
bool ok = false;
qint64 cacheSize = m_parameters.value("mapping.cache.size").toString().toLongLong(&ok);
if (ok)
m_cache->setMaximumCacheSize(cacheSize);
}
m_nam->setCache(m_cache);
#endif
}
FakeTiledLayerChromium::FakeTiledLayerChromium(CCPrioritizedTextureManager* textureManager)
: TiledLayerChromium()
, m_fakeTextureUpdater(adoptRef(new FakeLayerTextureUpdater))
, m_textureManager(textureManager)
{
setTileSize(tileSize());
setTextureFormat(GraphicsContext3D::RGBA);
setBorderTexelOption(CCLayerTilingData::NoBorderTexels);
setIsDrawable(true); // So that we don't get false positives if any of these tests expect to return false from drawsContent() for other reasons.
}
WhiteTileEngine::WhiteTileEngine(const QMap<QString, QVariant> ¶meters, QObject *parent) :
QGeoTiledMappingManagerEngine(parameters, parent)
{
setTileSize(QSize(128,128));
setMinimumZoomLevel(0.0);
setMaximumZoomLevel(3.0);
QList<QGraphicsGeoMap::MapType> types;
types << QGraphicsGeoMap::StreetMap;
types << QGraphicsGeoMap::TerrainMap;
setSupportedMapTypes(types);
QList<QGraphicsGeoMap::ConnectivityMode> modes;
modes << QGraphicsGeoMap::OfflineMode;
setSupportedConnectivityModes(modes);
}
QGeoTiledMappingManagerEngineQGC::QGeoTiledMappingManagerEngineQGC(const QVariantMap ¶meters, QGeoServiceProvider::Error *error, QString *errorString)
: QGeoTiledMappingManagerEngine()
{
QGeoCameraCapabilities cameraCaps;
cameraCaps.setMinimumZoomLevel(2.0);
cameraCaps.setMaximumZoomLevel(MAX_MAP_ZOOM);
cameraCaps.setSupportsBearing(true);
setCameraCapabilities(cameraCaps);
setTileSize(QSize(256, 256));
QList<QGeoMapType> mapTypes;
mapTypes << QGeoMapType(QGeoMapType::StreetMap, tr("Google Street Map"), tr("Google street map"), false, false, OpenPilot::GoogleMap);
mapTypes << QGeoMapType(QGeoMapType::SatelliteMapDay, tr("Google Satellite Map"),tr("Google satellite map"), false, false, OpenPilot::GoogleSatellite);
mapTypes << QGeoMapType(QGeoMapType::TerrainMap, tr("Google Terrain Map"), tr("Google terrain map"), false, false, OpenPilot::GoogleTerrain);
// TODO:
// Proper google hybrid maps requires collecting two separate bimaps and overlaying them.
//mapTypes << QGeoMapType(QGeoMapType::HybridMap, tr("Google Hybrid Map"), tr("Google hybrid map"), false, false, OpenPilot::GoogleHybrid);
// Bing
mapTypes << QGeoMapType(QGeoMapType::StreetMap, tr("Bing Street Map"), tr("Bing street map"), false, false, OpenPilot::BingMap);
mapTypes << QGeoMapType(QGeoMapType::SatelliteMapDay, tr("Bing Satellite Map"), tr("Bing satellite map"), false, false, OpenPilot::BingSatellite);
mapTypes << QGeoMapType(QGeoMapType::HybridMap, tr("Bing Hybrid Map"), tr("Bing hybrid map"), false, false, OpenPilot::BingHybrid);
mapTypes << QGeoMapType(QGeoMapType::StreetMap, tr("Open Street Map"), tr("Open Street map"), false, false, OpenPilot::OpenStreetMap);
setSupportedMapTypes(mapTypes);
QGeoTileFetcherQGC *tileFetcher = new QGeoTileFetcherQGC(this);
if (parameters.contains(QStringLiteral("useragent"))) {
const QByteArray ua = parameters.value(QStringLiteral("useragent")).toString().toLatin1();
tileFetcher->setUserAgent(ua);
} else
// QGC Default
tileFetcher->setUserAgent("Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US; rv:1.9.1.7) Gecko/20091221 Firefox/3.5.7");
#if QT_VERSION >= 0x050500
_setCache(parameters);
#endif
setTileFetcher(tileFetcher);
*error = QGeoServiceProvider::NoError;
errorString->clear();
#if QT_VERSION >= 0x050500
if (parameters.contains(QStringLiteral("mapping.copyright")))
m_customCopyright = parameters.value(QStringLiteral("mapping.copyright")).toString().toLatin1();
#endif
}
void TilemapComponent::init()
{
VisualComponent::init();
auto tileset = newObject<Tileset>();
auto layer = newObject<TilemapLayer>();
layer->resize(5, 5);
layer->setTileSize(Size(1, 1));
layer->setOrientation(TilemapOrientation::UpFlow);
layer->setTileId(0, 0, 1);
layer->setTileId(1, 1, 1);
layer->setTileId(0, 4, 1);
layer->setTileId(1, 4, 1);
layer->setTileId(2, 4, 1);
layer->setTileId(3, 4, 1);
layer->setTileId(4, 4, 1);
m_tilemap = newObject<TilemapModel>();
m_tilemap->addTileset(tileset);
m_tilemap->addLayer(layer);
}
void rspfCacheTileSource::setProperty(rspfRefPtr<rspfProperty> property)
{
if (!property) return;
rspfString name = property->getName();
if (name == TILE_SIZE_XY_KW)
{
rspfIpt pt;
pt.toPoint(property->valueToString());
if ( (pt.x > 7) && (pt.y > 7) )
{
setTileSize(pt);
}
else
{
rspfNotify(rspfNotifyLevel_NOTICE)
<< "rspfCacheTileSource::setProperty NOTICE:"
<< "\nTile dimensions must be at least 8!"
<< "\nFormat = ( x, y )"
<< std::endl;
}
}
else if(name == rspfKeywordNames::ENABLE_CACHE_KW)
{
setCachingEnabledFlag(property->valueToString().toBool());
}
else if(name == USE_INPUT_TILE_SIZE_KW)
{
theUseInputTileSizeFlag = property->valueToString().toBool();
if(theUseInputTileSizeFlag)
{
deleteRlevelCache();
}
// setCachingEnabledFlag(property->valueToString().toBool());
}
else
{
rspfImageSourceFilter::setProperty(property);
}
}
QT_BEGIN_NAMESPACE
QGeoTiledMappingManagerEngineMapbox::QGeoTiledMappingManagerEngineMapbox(const QVariantMap ¶meters, QGeoServiceProvider::Error *error, QString *errorString)
: QGeoTiledMappingManagerEngine()
{
QGeoCameraCapabilities cameraCaps;
cameraCaps.setMinimumZoomLevel(0.0);
cameraCaps.setMaximumZoomLevel(19.0);
setCameraCapabilities(cameraCaps);
setTileSize(QSize(256, 256));
QList<QGeoMapType> mapTypes;
mapTypes << QGeoMapType(QGeoMapType::CustomMap, tr("Custom"), tr("Mapbox custom map"), false, false, 0);
setSupportedMapTypes(mapTypes);
QGeoTileFetcherMapbox *tileFetcher = new QGeoTileFetcherMapbox(this);
if (parameters.contains(QStringLiteral("useragent"))) {
const QByteArray ua = parameters.value(QStringLiteral("useragent")).toString().toLatin1();
tileFetcher->setUserAgent(ua);
}
if (parameters.contains(QStringLiteral("mapbox.map_id"))) {
const QString id = parameters.value(QStringLiteral("mapbox.map_id")).toString();
tileFetcher->setMapId(id);
}
if (parameters.contains(QStringLiteral("mapbox.format"))) {
const QString format = parameters.value(QStringLiteral("mapbox.format")).toString();
tileFetcher->setFormat(format);
}
if (parameters.contains(QStringLiteral("mapbox.access_token"))) {
const QString token = parameters.value(QStringLiteral("mapbox.access_token")).toString();
tileFetcher->setAccessToken(token);
}
setTileFetcher(tileFetcher);
*error = QGeoServiceProvider::NoError;
errorString->clear();
}
void TiledLayerChromium::updateTileSizeAndTilingOption()
{
const IntSize tileSize(min(defaultTileSize, contentBounds().width()), min(defaultTileSize, contentBounds().height()));
// Tile if both dimensions large, or any one dimension large and the other
// extends into a second tile. This heuristic allows for long skinny layers
// (e.g. scrollbars) that are Nx1 tiles to minimize wasted texture space.
const bool anyDimensionLarge = contentBounds().width() > maxUntiledSize || contentBounds().height() > maxUntiledSize;
const bool anyDimensionOneTile = contentBounds().width() <= defaultTileSize || contentBounds().height() <= defaultTileSize;
const bool autoTiled = anyDimensionLarge && !anyDimensionOneTile;
bool isTiled;
if (m_tilingOption == AlwaysTile)
isTiled = true;
else if (m_tilingOption == NeverTile)
isTiled = false;
else
isTiled = autoTiled;
IntSize requestedSize = isTiled ? tileSize : contentBounds();
const int maxSize = layerTreeHost()->layerRendererCapabilities().maxTextureSize;
IntSize clampedSize = requestedSize.shrunkTo(IntSize(maxSize, maxSize));
setTileSize(clampedSize);
}
QGeoMappingManagerEngineGoogle::QGeoMappingManagerEngineGoogle(const QMap<QString, QVariant> ¶meters, QGeoServiceProvider::Error *error, QString *errorString)
: QGeoTiledMappingManagerEngine(parameters),
m_parameters(parameters),
m_nam(NULL)
{
QNetworkDiskCache *cache = NULL;
Q_UNUSED(error)
Q_UNUSED(errorString)
setTileSize(QSize(256, 256));
setMinimumZoomLevel(0.0);
setMaximumZoomLevel(17.0);
QList<QGraphicsGeoMap::MapType> types;
types << QGraphicsGeoMap::StreetMap;
types << QGraphicsGeoMap::SatelliteMapDay;
setSupportedMapTypes(types);
QList<QGraphicsGeoMap::ConnectivityMode> modes;
modes << QGraphicsGeoMap::OnlineMode;
setSupportedConnectivityModes(modes);
QList<QString> keys = m_parameters.keys();
if (keys.contains("mapping.networkaccessmanager")) {
QNetworkAccessManager *nam;
nam = (QNetworkAccessManager *)m_parameters
.value("mapping.networkaccessmanager").value<void *>();
if (nam)
m_nam = nam;
}
if (!m_nam) {
m_nam = new QNetworkAccessManager(this);
cache = new QNetworkDiskCache(this);
}
if (cache) {
QDir dir = QDir::temp();
dir.mkdir("maptiles-google");
dir.cd("maptiles-google");
cache->setCacheDirectory(dir.path());
}
if (keys.contains("mapping.proxy")) {
QString proxy = m_parameters.value("mapping.proxy").toString();
if (!proxy.isEmpty())
m_nam->setProxy(parseProxy(proxy));
}
if (cache && keys.contains("mapping.cache.directory")) {
QString cacheDir = m_parameters.value("mapping.cache.directory").toString();
if (!cacheDir.isEmpty())
cache->setCacheDirectory(cacheDir);
}
if (cache && keys.contains("mapping.cache.size")) {
bool ok = false;
qint64 cacheSize = m_parameters.value("mapping.cache.size").toString().toLongLong(&ok);
if (ok)
cache->setMaximumCacheSize(cacheSize);
}
if (cache)
m_nam->setCache(cache);
}
QGeoTiledMappingManagerEngineQGC::QGeoTiledMappingManagerEngineQGC(const QVariantMap ¶meters, QGeoServiceProvider::Error *error, QString *errorString)
: QGeoTiledMappingManagerEngine()
{
QGeoCameraCapabilities cameraCaps;
cameraCaps.setMinimumZoomLevel(2.0);
cameraCaps.setMaximumZoomLevel(MAX_MAP_ZOOM);
cameraCaps.setSupportsBearing(true);
setCameraCapabilities(cameraCaps);
setTileSize(QSize(256, 256));
QList<QGeoMapType> mapTypes;
mapTypes << QGeoMapType(QGeoMapType::StreetMap, tr("Google Street Map"), tr("Google street map"), false, false, OpenPilot::GoogleMap);
mapTypes << QGeoMapType(QGeoMapType::SatelliteMapDay, tr("Google Satellite Map"),tr("Google satellite map"), false, false, OpenPilot::GoogleSatellite);
mapTypes << QGeoMapType(QGeoMapType::TerrainMap, tr("Google Terrain Map"), tr("Google terrain map"), false, false, OpenPilot::GoogleTerrain);
// TODO:
// Proper hybrid maps requires collecting two separate bimaps and overlaying them.
//mapTypes << QGeoMapType(QGeoMapType::HybridMap, tr("Google Hybrid Map"), tr("Google hybrid map"), false, false, OpenPilot::GoogleHybrid);
// Bing
mapTypes << QGeoMapType(QGeoMapType::StreetMap, tr("Bing Street Map"), tr("Bing street map"), false, false, OpenPilot::BingMap);
mapTypes << QGeoMapType(QGeoMapType::SatelliteMapDay, tr("Bing Satellite Map"), tr("Bing satellite map"), false, false, OpenPilot::BingSatellite);
mapTypes << QGeoMapType(QGeoMapType::HybridMap, tr("Bing Hybrid Map"), tr("Bing hybrid map"), false, false, OpenPilot::BingHybrid);
mapTypes << QGeoMapType(QGeoMapType::StreetMap, tr("Open Street Map"), tr("Open Street map"), false, false, OpenPilot::OpenStreetMap);
setSupportedMapTypes(mapTypes);
QGeoTileFetcherQGC *tileFetcher = new QGeoTileFetcherQGC(this);
if (parameters.contains(QStringLiteral("useragent"))) {
const QByteArray ua = parameters.value(QStringLiteral("useragent")).toString().toLatin1();
tileFetcher->setUserAgent(ua);
} else
// QGC Default
tileFetcher->setUserAgent("Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US; rv:1.9.1.7) Gecko/20091221 Firefox/3.5.7");
setTileFetcher(tileFetcher);
QString cacheDir;
if (parameters.contains(QStringLiteral("mapping.cache.directory")))
cacheDir = parameters.value(QStringLiteral("mapping.cache.directory")).toString();
else {
cacheDir = QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation) + QLatin1String("/QGCMapCache");
if(!QDir::root().mkpath(cacheDir)) {
qWarning() << "Could not create mapping disk cache directory: " << cacheDir;
cacheDir = QDir::homePath() + QLatin1String("/.qgcmapscache/");
}
}
if(!QDir::root().mkpath(cacheDir))
{
qWarning() << "Could not create mapping disk cache directory: " << cacheDir;
cacheDir.clear();
}
//else {
// qDebug() << "Mapping cache directory:" << cacheDir;
//}
QGeoTileCache* pTileCache = tileCache();
if(pTileCache)
{
int cacheLimit = 0;
//-- Disk Cache
if (parameters.contains(QStringLiteral("mapping.cache.disk.size"))) {
bool ok = false;
cacheLimit = parameters.value(QStringLiteral("mapping.cache.disk.size")).toString().toInt(&ok);
if (!ok)
cacheLimit = 0;
}
if(!cacheLimit)
{
#ifdef __mobile__
cacheLimit = 128 * 1024 * 1024;
#else
cacheLimit = 1024 * 1024 * 1024;
#endif
}
pTileCache->setMaxDiskUsage(cacheLimit);
//-- Memory Cache
cacheLimit = 0;
if (parameters.contains(QStringLiteral("mapping.cache.memory.size"))) {
bool ok = false;
cacheLimit = parameters.value(QStringLiteral("mapping.cache.memory.size")).toString().toInt(&ok);
if (!ok)
cacheLimit = 0;
}
if(!cacheLimit)
{
#ifdef __mobile__
cacheLimit = 16 * 1024 * 1024;
#else
cacheLimit = 128 * 1024 * 1024;
#endif
}
pTileCache->setMaxMemoryUsage(cacheLimit);
}
*error = QGeoServiceProvider::NoError;
errorString->clear();
#if QT_VERSION >= 0x050500
if (parameters.contains(QStringLiteral("mapping.copyright")))
m_customCopyright = parameters.value(QStringLiteral("mapping.copyright")).toString().toLatin1();
#endif
}
CCLayerTilingData::CCLayerTilingData(const IntSize& tileSize, BorderTexelOption border)
: m_tilingData(tileSize, IntSize(), border == HasBorderTexels)
{
setTileSize(tileSize);
}
//-------------------------------------------------------------------------
void TerrainSceneManager::loadConfig(DataStreamPtr& stream)
{
/* Set up the options */
ConfigFile config;
String val;
config.load( stream );
val = config.getSetting( "DetailTile" );
if ( !val.empty() )
setDetailTextureRepeat(atoi(val.c_str()));
val = config.getSetting( "MaxMipMapLevel" );
if ( !val.empty() )
setMaxGeoMipMapLevel(atoi( val.c_str() ));
val = config.getSetting( "PageSize" );
if ( !val.empty() )
setPageSize(atoi( val.c_str() ));
else
OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Missing option 'PageSize'",
"TerrainSceneManager::loadConfig");
val = config.getSetting( "TileSize" );
if ( !val.empty() )
setTileSize(atoi( val.c_str() ));
else
OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Missing option 'TileSize'",
"TerrainSceneManager::loadConfig");
Vector3 v = Vector3::UNIT_SCALE;
val = config.getSetting( "PageWorldX" );
if ( !val.empty() )
v.x = atof( val.c_str() );
val = config.getSetting( "MaxHeight" );
if ( !val.empty() )
v.y = atof( val.c_str() );
val = config.getSetting( "PageWorldZ" );
if ( !val.empty() )
v.z = atof( val.c_str() );
// Scale x/z relative to pagesize
v.x /= mOptions.pageSize - 1;
v.z /= mOptions.pageSize - 1;
setScale(v);
val = config.getSetting( "MaxPixelError" );
if ( !val.empty() )
setMaxPixelError(atoi( val.c_str() ));
mDetailTextureName = config.getSetting( "DetailTexture" );
mWorldTextureName = config.getSetting( "WorldTexture" );
if ( config.getSetting( "VertexColours" ) == "yes" )
mOptions.coloured = true;
if ( config.getSetting( "VertexNormals" ) == "yes" )
mOptions.lit = true;
if ( config.getSetting( "UseTriStrips" ) == "yes" )
setUseTriStrips(true);
if ( config.getSetting( "VertexProgramMorph" ) == "yes" )
setUseLODMorph(true);
val = config.getSetting( "LODMorphStart");
if ( !val.empty() )
setLODMorphStart(atof(val.c_str()));
val = config.getSetting( "CustomMaterialName" );
if ( !val.empty() )
setCustomMaterial(val);
val = config.getSetting( "MorphLODFactorParamName" );
if ( !val.empty() )
setCustomMaterialMorphFactorParam(val);
val = config.getSetting( "MorphLODFactorParamIndex" );
if ( !val.empty() )
setCustomMaterialMorphFactorParam(atoi(val.c_str()));
// Now scan through the remaining settings, looking for any PageSource
// prefixed items
String pageSourceName = config.getSetting("PageSource");
if (pageSourceName == "")
{
OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Missing option 'PageSource'",
"TerrainSceneManager::loadConfig");
}
TerrainPageSourceOptionList optlist;
ConfigFile::SettingsIterator setIt = config.getSettingsIterator();
while (setIt.hasMoreElements())
{
String name = setIt.peekNextKey();
String value = setIt.getNext();
if (StringUtil::startsWith(name, pageSourceName, false))
{
optlist.push_back(TerrainPageSourceOption(name, value));
}
}
// set the page source
selectPageSource(pageSourceName, optlist);
}
QGeoMappingManagerEngineCm::QGeoMappingManagerEngineCm(const QMap<QString, QVariant> ¶meters, QGeoServiceProvider::Error *error, QString *errorString)
: QGeoTiledMappingManagerEngine(parameters),
m_parameters(parameters),
m_host("b.tile.cloudmade.com"),
m_token(QGeoServiceProviderFactoryCm::defaultToken)
{
Q_UNUSED(error)
Q_UNUSED(errorString)
setTileSize(QSize(256,256));
setMinimumZoomLevel(0.0);
setMaximumZoomLevel(18.0);
m_styleId = m_parameters.value("style", "1").toString();
//SL_MAP_TYPE
QList<QGraphicsGeoMap::MapType> types;
types << QGraphicsGeoMap::StreetMap;
setSupportedMapTypes(types);
m_nam = new QNetworkAccessManager(this);
//m_cache = new QNetworkDiskCache(this);
m_cacheSize = DEFAULT_TILE_CACHE_SIZE;
QList<QString> keys = m_parameters.keys();
if (keys.contains("mapping.proxy")) {
QString proxy = m_parameters.value("mapping.proxy").toString();
if (!proxy.isEmpty())
m_nam->setProxy(QNetworkProxy(QNetworkProxy::HttpProxy, proxy, 8080));
}
if (keys.contains("mapping.host")) {
QString host = m_parameters.value("mapping.host").toString();
if (!host.isEmpty())
m_host = host;
}
if (keys.contains("mapping.cache.directory")) {
QString cacheDir = m_parameters.value("mapping.cache.directory").toString();
if (!cacheDir.isEmpty())
m_cacheDir = cacheDir;
//m_cache->setCacheDirectory(cacheDir);
}
else
{
// set default cache dir
// QDir dir = QDir::temp();
QDir dir = QDir(QDesktopServices::storageLocation(QDesktopServices::CacheLocation));
qDebug() << __FUNCTION__ << "Cache at" << dir;
dir.mkdir(DEFAULT_TILE_CACHE_DIR);
// QFileInfo info(dir.absolutePath());
// qDebug() << __FUNCTION__ << "Cache size" << info.size();
dir.cd(DEFAULT_TILE_CACHE_DIR);
//m_cache->setCacheDirectory(dir.path());
m_cacheDir = dir.path();
}
DBG_CM(TILES_M, INFO_L, "Setting tile cache dir to " << m_cacheDir);
if (keys.contains("mapping.cache.size")) {
bool ok = false;
qint64 cacheSize = m_parameters.value("mapping.cache.size").toString().toLongLong(&ok);
if (ok) {
//m_cache->setMaximumCacheSize(cacheSize);
m_cacheSize = cacheSize;
DBG_CM(TILES_M, INFO_L, "Setting tile cache size = " << m_cacheSize);
}
}
// first of all: delete all *.png files that may still be lurking in
// the old cache dir as they may affect the gallery (they are named
// png, but are not real png files)
QDir dir = QDir::temp();
if(dir.cd("maptiles-cm")) {
QStringList pngFilters;
pngFilters << "*.png";
dir.setNameFilters(pngFilters);
QStringList pngList = dir.entryList();
foreach(QString name, pngList)
dir.remove(name);
dir.cd("..");
dir.rmdir("maptiles-cm");
}
// if (m_cacheSize > 0) cleanCacheToSize(m_cacheSize);
}
void BackgroundImageGeometry::calculate(
const LayoutBoxModelObject& obj,
const LayoutBoxModelObject* paintContainer,
const GlobalPaintFlags globalPaintFlags,
const FillLayer& fillLayer,
const LayoutRect& paintRect) {
LayoutUnit left;
LayoutUnit top;
LayoutSize positioningAreaSize;
bool isLayoutView = obj.isLayoutView();
const LayoutBox* rootBox = nullptr;
if (isLayoutView) {
// It is only possible reach here when root element has a box.
Element* documentElement = obj.document().documentElement();
DCHECK(documentElement);
DCHECK(documentElement->layoutObject());
DCHECK(documentElement->layoutObject()->isBox());
rootBox = toLayoutBox(documentElement->layoutObject());
}
const LayoutBoxModelObject& positioningBox =
isLayoutView ? static_cast<const LayoutBoxModelObject&>(*rootBox) : obj;
// Determine the background positioning area and set destRect to the
// background painting area. destRect will be adjusted later if the
// background is non-repeating.
// FIXME: transforms spec says that fixed backgrounds behave like scroll
// inside transforms.
bool fixedAttachment = fillLayer.attachment() == FixedBackgroundAttachment;
if (RuntimeEnabledFeatures::fastMobileScrollingEnabled()) {
// As a side effect of an optimization to blit on scroll, we do not honor
// the CSS property "background-attachment: fixed" because it may result in
// rendering artifacts. Note, these artifacts only appear if we are blitting
// on scroll of a page that has fixed background images.
fixedAttachment = false;
}
if (!fixedAttachment) {
setDestRect(paintRect);
LayoutUnit right;
LayoutUnit bottom;
// Scroll and Local.
if (fillLayer.origin() != BorderFillBox) {
left = LayoutUnit(positioningBox.borderLeft());
right = LayoutUnit(positioningBox.borderRight());
top = LayoutUnit(positioningBox.borderTop());
bottom = LayoutUnit(positioningBox.borderBottom());
if (fillLayer.origin() == ContentFillBox) {
left += positioningBox.paddingLeft();
right += positioningBox.paddingRight();
top += positioningBox.paddingTop();
bottom += positioningBox.paddingBottom();
}
}
if (isLayoutView) {
// The background of the box generated by the root element covers the
// entire canvas and will be painted by the view object, but the we should
// still use the root element box for positioning.
positioningAreaSize =
rootBox->size() - LayoutSize(left + right, top + bottom),
rootBox->location();
// The input paint rect is specified in root element local coordinate
// (i.e. a transform is applied on the context for painting), and is
// expanded to cover the whole canvas. Since left/top is relative to the
// paint rect, we need to offset them back.
left -= paintRect.x();
top -= paintRect.y();
} else {
positioningAreaSize =
paintRect.size() - LayoutSize(left + right, top + bottom);
}
} else {
setHasNonLocalGeometry();
LayoutRect viewportRect = obj.viewRect();
if (fixedBackgroundPaintsInLocalCoordinates(obj, globalPaintFlags)) {
viewportRect.setLocation(LayoutPoint());
} else {
if (FrameView* frameView = obj.view()->frameView())
viewportRect.setLocation(IntPoint(frameView->scrollOffsetInt()));
// Compensate the translations created by ScrollRecorders.
// TODO(trchen): Fix this for SP phase 2. crbug.com/529963.
viewportRect.moveBy(
accumulatedScrollOffsetForFixedBackground(obj, paintContainer));
}
if (paintContainer)
viewportRect.moveBy(
LayoutPoint(-paintContainer->localToAbsolute(FloatPoint())));
setDestRect(viewportRect);
positioningAreaSize = destRect().size();
}
LayoutSize fillTileSize(
calculateFillTileSize(positioningBox, fillLayer, positioningAreaSize));
// It's necessary to apply the heuristic here prior to any further
// calculations to avoid incorrectly using sub-pixel values that won't be
// present in the painted tile.
setTileSize(applySubPixelHeuristicToImageSize(fillTileSize, m_destRect));
EFillRepeat backgroundRepeatX = fillLayer.repeatX();
EFillRepeat backgroundRepeatY = fillLayer.repeatY();
LayoutUnit unsnappedAvailableWidth =
positioningAreaSize.width() - fillTileSize.width();
LayoutUnit unsnappedAvailableHeight =
positioningAreaSize.height() - fillTileSize.height();
positioningAreaSize =
LayoutSize(snapSizeToPixel(positioningAreaSize.width(), m_destRect.x()),
snapSizeToPixel(positioningAreaSize.height(), m_destRect.y()));
LayoutUnit availableWidth = positioningAreaSize.width() - tileSize().width();
LayoutUnit availableHeight =
positioningAreaSize.height() - tileSize().height();
LayoutUnit computedXPosition =
roundedMinimumValueForLength(fillLayer.xPosition(), availableWidth);
if (backgroundRepeatX == RoundFill &&
positioningAreaSize.width() > LayoutUnit() &&
fillTileSize.width() > LayoutUnit()) {
int nrTiles = std::max(
1, roundToInt(positioningAreaSize.width() / fillTileSize.width()));
LayoutUnit roundedWidth = positioningAreaSize.width() / nrTiles;
// Maintain aspect ratio if background-size: auto is set
if (fillLayer.size().size.height().isAuto() &&
backgroundRepeatY != RoundFill) {
fillTileSize.setHeight(fillTileSize.height() * roundedWidth /
fillTileSize.width());
}
fillTileSize.setWidth(roundedWidth);
setTileSize(applySubPixelHeuristicToImageSize(fillTileSize, m_destRect));
setPhaseX(tileSize().width()
? LayoutUnit(roundf(
tileSize().width() -
fmodf((computedXPosition + left), tileSize().width())))
: LayoutUnit());
setSpaceSize(LayoutSize());
}
LayoutUnit computedYPosition =
roundedMinimumValueForLength(fillLayer.yPosition(), availableHeight);
if (backgroundRepeatY == RoundFill &&
positioningAreaSize.height() > LayoutUnit() &&
fillTileSize.height() > LayoutUnit()) {
int nrTiles = std::max(
1, roundToInt(positioningAreaSize.height() / fillTileSize.height()));
LayoutUnit roundedHeight = positioningAreaSize.height() / nrTiles;
// Maintain aspect ratio if background-size: auto is set
if (fillLayer.size().size.width().isAuto() &&
backgroundRepeatX != RoundFill) {
fillTileSize.setWidth(fillTileSize.width() * roundedHeight /
fillTileSize.height());
}
fillTileSize.setHeight(roundedHeight);
setTileSize(applySubPixelHeuristicToImageSize(fillTileSize, m_destRect));
setPhaseY(tileSize().height()
? LayoutUnit(roundf(
tileSize().height() -
fmodf((computedYPosition + top), tileSize().height())))
: LayoutUnit());
setSpaceSize(LayoutSize());
}
if (backgroundRepeatX == RepeatFill) {
setRepeatX(fillLayer, fillTileSize.width(), availableWidth,
unsnappedAvailableWidth, left);
} else if (backgroundRepeatX == SpaceFill &&
tileSize().width() > LayoutUnit()) {
LayoutUnit space = getSpaceBetweenImageTiles(positioningAreaSize.width(),
tileSize().width());
if (space >= LayoutUnit())
setSpaceX(space, availableWidth, left);
else
backgroundRepeatX = NoRepeatFill;
}
if (backgroundRepeatX == NoRepeatFill) {
LayoutUnit xOffset = fillLayer.backgroundXOrigin() == RightEdge
? availableWidth - computedXPosition
: computedXPosition;
setNoRepeatX(left + xOffset);
}
if (backgroundRepeatY == RepeatFill) {
setRepeatY(fillLayer, fillTileSize.height(), availableHeight,
unsnappedAvailableHeight, top);
} else if (backgroundRepeatY == SpaceFill &&
tileSize().height() > LayoutUnit()) {
LayoutUnit space = getSpaceBetweenImageTiles(positioningAreaSize.height(),
tileSize().height());
if (space >= LayoutUnit())
setSpaceY(space, availableHeight, top);
else
backgroundRepeatY = NoRepeatFill;
}
if (backgroundRepeatY == NoRepeatFill) {
LayoutUnit yOffset = fillLayer.backgroundYOrigin() == BottomEdge
? availableHeight - computedYPosition
: computedYPosition;
setNoRepeatY(top + yOffset);
}
if (fixedAttachment)
useFixedAttachment(paintRect.location());
// Clip the final output rect to the paint rect
m_destRect.intersect(paintRect);
// Snap as-yet unsnapped values.
setDestRect(LayoutRect(pixelSnappedIntRect(m_destRect)));
}
void ossimImageSourceSequencer::setTileSize(int width, int height)
{
setTileSize(ossimIpt(width, height));
}
//-----------------------------------------------------------------------------
QGeoTiledMappingManagerEngineQGC::QGeoTiledMappingManagerEngineQGC(const QVariantMap ¶meters, QGeoServiceProvider::Error *error, QString *errorString)
: QGeoTiledMappingManagerEngine()
{
QGeoCameraCapabilities cameraCaps;
cameraCaps.setMinimumZoomLevel(2.0);
cameraCaps.setMaximumZoomLevel(MAX_MAP_ZOOM);
cameraCaps.setSupportsBearing(true);
setCameraCapabilities(cameraCaps);
setTileSize(QSize(256, 256));
/*
* Most of these don't seem kosher at all. This was based on original code from OpenPilot and heavily modified to be used in QGC.
*/
//-- IMPORTANT
// Changes here must reflect those in QGCMapEngine.cpp
QList<QGeoMapType> mapTypes;
mapTypes << QGeoMapType(QGeoMapType::StreetMap, "Google Street Map", "Google street map", false, false, UrlFactory::GoogleMap);
mapTypes << QGeoMapType(QGeoMapType::SatelliteMapDay, "Google Satellite Map", "Google satellite map", false, false, UrlFactory::GoogleSatellite);
mapTypes << QGeoMapType(QGeoMapType::TerrainMap, "Google Terrain Map", "Google terrain map", false, false, UrlFactory::GoogleTerrain);
/* TODO:
* Proper google hybrid maps requires collecting two separate bimaps and overlaying them.
*
* mapTypes << QGeoMapType(QGeoMapType::HybridMap, "Google Hybrid Map", "Google hybrid map", false, false, UrlFactory::GoogleHybrid);
*
*/
// Bing
mapTypes << QGeoMapType(QGeoMapType::StreetMap, "Bing Street Map", "Bing street map", false, false, UrlFactory::BingMap);
mapTypes << QGeoMapType(QGeoMapType::SatelliteMapDay, "Bing Satellite Map", "Bing satellite map", false, false, UrlFactory::BingSatellite);
mapTypes << QGeoMapType(QGeoMapType::HybridMap, "Bing Hybrid Map", "Bing hybrid map", false, false, UrlFactory::BingHybrid);
/* See: https://wiki.openstreetmap.org/wiki/Tile_usage_policy
mapTypes << QGeoMapType(QGeoMapType::StreetMap, "Open Street Map", "Open Street map", false, false, UrlFactory::OpenStreetMap);
*/
// MapQuest
mapTypes << QGeoMapType(QGeoMapType::StreetMap, "MapQuest Street Map", "MapQuest street map", false, false, UrlFactory::MapQuestMap);
mapTypes << QGeoMapType(QGeoMapType::SatelliteMapDay, "MapQuest Satellite Map", "MapQuest satellite map", false, false, UrlFactory::MapQuestSat);
/*
* These are OK as you need your own token for accessing it. Out-of-the box, QGC does not even offer these unless you enter a proper MapBox token.
*/
mapTypes << QGeoMapType(QGeoMapType::StreetMap, "MapBox Street Map", "MapBox Street Map", false, false, UrlFactory::MapBoxStreets);
mapTypes << QGeoMapType(QGeoMapType::SatelliteMapDay, "MapBox Satellite Map", "MapBox Satellite Map", false, false, UrlFactory::MapBoxSatellite);
mapTypes << QGeoMapType(QGeoMapType::CustomMap, "MapBox High Contrast Map", "MapBox High Contrast Map", false, false, UrlFactory::MapBoxHighContrast);
mapTypes << QGeoMapType(QGeoMapType::CustomMap, "MapBox Light Map", "MapBox Light Map", false, false, UrlFactory::MapBoxLight);
mapTypes << QGeoMapType(QGeoMapType::CustomMap, "MapBox Dark Map", "MapBox Dark Map", false, false, UrlFactory::MapBoxDark);
mapTypes << QGeoMapType(QGeoMapType::HybridMap, "MapBox Hybrid Map", "MapBox Hybrid Map", false, false, UrlFactory::MapBoxHybrid);
mapTypes << QGeoMapType(QGeoMapType::CustomMap, "MapBox Wheat Paste Map", "MapBox Wheat Paste Map", false, false, UrlFactory::MapBoxWheatPaste);
mapTypes << QGeoMapType(QGeoMapType::StreetMap, "MapBox Streets Basic Map", "MapBox Streets Basic Map", false, false, UrlFactory::MapBoxStreetsBasic);
mapTypes << QGeoMapType(QGeoMapType::CustomMap, "MapBox Comic Map", "MapBox Comic Map", false, false, UrlFactory::MapBoxComic);
mapTypes << QGeoMapType(QGeoMapType::CustomMap, "MapBox Outdoors Map", "MapBox Outdoors Map", false, false, UrlFactory::MapBoxOutdoors);
mapTypes << QGeoMapType(QGeoMapType::CycleMap, "MapBox Run, Byke and Hike Map", "MapBox Run, Byke and Hike Map", false, false, UrlFactory::MapBoxRunBikeHike);
mapTypes << QGeoMapType(QGeoMapType::CustomMap, "MapBox Pencil Map", "MapBox Pencil Map", false, false, UrlFactory::MapBoxPencil);
mapTypes << QGeoMapType(QGeoMapType::CustomMap, "MapBox Pirates Map", "MapBox Pirates Map", false, false, UrlFactory::MapBoxPirates);
mapTypes << QGeoMapType(QGeoMapType::CustomMap, "MapBox Emerald Map", "MapBox Emerald Map", false, false, UrlFactory::MapBoxEmerald);
setSupportedMapTypes(mapTypes);
//-- Users (QML code) can define a different user agent
if (parameters.contains(QStringLiteral("useragent"))) {
getQGCMapEngine()->setUserAgent(parameters.value(QStringLiteral("useragent")).toString().toLatin1());
}
#if QT_VERSION >= 0x050500
_setCache(parameters);
#endif
setTileFetcher(new QGeoTileFetcherQGC(this));
*error = QGeoServiceProvider::NoError;
errorString->clear();
#if QT_VERSION >= 0x050500
if (parameters.contains(QStringLiteral("mapping.copyright")))
m_customCopyright = parameters.value(QStringLiteral("mapping.copyright")).toString().toLatin1();
#endif
}
//-------------------------------------------------------------------------
bool TerrainSceneManager::setOption( const String & name, const void *value )
{
if (name == "PageSize")
{
setPageSize(*static_cast<const int*>(value));
return true;
}
else if (name == "TileSize")
{
setTileSize(*static_cast<const int*>(value));
return true;
}
else if (name == "PrimaryCamera")
{
setPrimaryCamera(static_cast<const Camera*>(value));
return true;
}
else if (name == "MaxMipMapLevel")
{
setMaxGeoMipMapLevel(*static_cast<const int*>(value));
return true;
}
else if (name == "Scale")
{
setScale(*static_cast<const Vector3*>(value));
return true;
}
else if (name == "MaxPixelError")
{
setMaxPixelError(*static_cast<const int*>(value));
return true;
}
else if (name == "UseTriStrips")
{
setUseTriStrips(*static_cast<const bool*>(value));
return true;
}
else if (name == "VertexProgramMorph")
{
setUseLODMorph(*static_cast<const bool*>(value));
return true;
}
else if (name == "DetailTile")
{
setDetailTextureRepeat(*static_cast<const int*>(value));
return true;
}
else if (name == "LodMorphStart")
{
setLODMorphStart(*static_cast<const Real*>(value));
return true;
}
else if (name == "VertexNormals")
{
setUseVertexNormals(*static_cast<const bool*>(value));
return true;
}
else if (name == "VertexColours")
{
setUseVertexColours(*static_cast<const bool*>(value));
return true;
}
else if (name == "MorphLODFactorParamName")
{
setCustomMaterialMorphFactorParam(*static_cast<const String*>(value));
return true;
}
else if (name == "MorphLODFactorParamIndex")
{
setCustomMaterialMorphFactorParam(*static_cast<const size_t*>(value));
return true;
}
else if (name == "CustomMaterialName")
{
setCustomMaterial(*static_cast<const String*>(value));
return true;
}
else if (name == "WorldTexture")
{
setWorldTexture(*static_cast<const String*>(value));
return true;
}
else if (name == "DetailTexture")
{
setDetailTexture(*static_cast<const String*>(value));
return true;
}
else
{
return OctreeSceneManager::setOption(name, value);
}
return false;
}
void ossimImageSourceSequencer::setTileSize(ossim_int32 width, ossim_int32 height)
{
setTileSize(ossimIpt(width, height));
}
CCLayerTilingData::CCLayerTilingData(const IntSize& tileSize, BorderTexelOption border)
: m_tilingData(max(tileSize.width(), tileSize.height()), 0, 0, border == HasBorderTexels)
{
setTileSize(tileSize);
}
bool ossimImageUtil::initialize(ossimArgumentParser& ap)
{
static const char M[] = "ossimImageUtil::initialize(ossimArgumentParser&)";
if ( traceDebug() )
{
ossimNotify(ossimNotifyLevel_DEBUG) << M << " entered...\n";
}
bool result = true;
if ( (ap.argc() == 1) || ap.read("-h") || ap.read("--help") )
{
usage(ap);
// continue_after_init to false
result = false;
}
else
{
//---
// Start with clean options keyword list.
//---
m_kwl->clear();
while ( 1 ) // While forever loop...
{
// Used throughout below:
std::string ts1;
ossimArgumentParser::ossimParameter sp1(ts1);
std::string ts2;
ossimArgumentParser::ossimParameter sp2(ts2);
if( ap.read("-a") || ap.read("--include-fullres") )
{
setCopyAllFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--compression-quality", sp1) )
{
if ( ts1.size() )
{
setCompressionQuality( ts1 );
}
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--compression-type", sp1) )
{
if ( ts1.size() )
{
setCompressionType( ts1 );
}
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--ch") || ap.read("--create-histogram") )
{
setCreateHistogramFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--chf") || ap.read("--create-histogram-fast") )
{
setCreateHistogramFastFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--create-histogram-r0") )
{
setCreateHistogramR0Flag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("-d", sp1) )
{
setOutputDirectory( ts1 );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--dump-filtered-image-list") )
{
setDumpFilteredImageListFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("-i") || ap.read("--internal-overviews") )
{
setInternalOverviewsFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--of") || ap.read("--output-files") )
{
setOutputFileNamesFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("-o") )
{
setCreateOverviewsFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--ot", sp1) )
{
setOverviewType( ts1 );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--override-filtered-images") )
{
setOverrideFilteredImagesFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("-r") || ap.read("--rebuild-overviews") )
{
setRebuildOverviewsFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--rebuild-histogram") )
{
setRebuildHistogramFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
while(ap.read("--reader-prop", sp1))
{
if (ts1.size())
{
std::string key = READER_PROP_KW;
key += ossimString::toString( getNextReaderPropIndex() ).string();
addOption( key, ts1 );
}
}
if ( ap.argc() < 2 )
{
break;
}
if( ap.read("--scanForMinMax" ) )
{
setScanForMinMax( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--scanForMinMaxNull" ) )
{
setScanForMinMaxNull( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("-s", sp1) )
{
setOverviewStopDimension( ts1 );
if ( ap.argc() < 2 )
{
break;
}
}
if ( ap.read("-tile-size", sp1))
{
setTileSize( ossimString(ts1).toInt32() );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--threads", sp1) )
{
m_kwl->addPair( THREADS_KW, ts1 );
if ( ap.argc() < 2 )
{
break;
}
}
while(ap.read("--writer-prop", sp1))
{
if (ts1.size())
{
std::string key = WRITER_PROP_KW;
key += ossimString::toString( getNextWriterPropIndex() ).string();
addOption( key, ts1 );
}
}
if ( ap.argc() < 2 )
{
break;
}
// End of arg parsing.
ap.reportRemainingOptionsAsUnrecognized();
if ( ap.errors() )
{
ap.writeErrorMessages(ossimNotify(ossimNotifyLevel_NOTICE));
std::string errMsg = "Unknown option...";
throw ossimException(errMsg);
}
break; // Break from while forever.
} // End while (forever) loop.
if(ap.argc() > 1)
{
for (ossim_int32 i = 0; i < (ap.argc()-1); ++i)
{
ossimString kw = "file";
kw += ossimString::toString(i);
std::string value = ap[i+1];
m_kwl->addPair(kw.string(), value, true);
}
}
else
{
if ( getDumpFilterImagesFlag() )
{
// Caller wants to see filtered image names:
dumpFilteredImageList();
}
else
{
usage(ap);
result = false;
}
}
} // not usage
if ( traceDebug() )
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "m_kwl:\n" << *(m_kwl.get()) << "\n"
<< M << " exit result = " << (result?"true":"false")
<< "\n";
}
return result;
}
