static SkPaint make_paint() {
SkPaint paint;
paint.setHinting(make_paint_hinting());
paint.setAntiAlias(make_bool());
paint.setDither(make_bool());
paint.setLinearText(make_bool());
paint.setSubpixelText(make_bool());
paint.setLCDRenderText(make_bool());
paint.setEmbeddedBitmapText(make_bool());
paint.setAutohinted(make_bool());
paint.setVerticalText(make_bool());
paint.setUnderlineText(make_bool());
paint.setStrikeThruText(make_bool());
paint.setFakeBoldText(make_bool());
paint.setDevKernText(make_bool());
paint.setFilterQuality(make_filter_quality());
paint.setStyle(make_paint_style());
paint.setColor(make_color());
paint.setStrokeWidth(make_scalar());
paint.setStrokeMiter(make_scalar());
paint.setStrokeCap(make_paint_cap());
paint.setStrokeJoin(make_paint_join());
paint.setColorFilter(make_color_filter());
paint.setXfermodeMode(make_xfermode());
paint.setPathEffect(make_path_effect());
paint.setMaskFilter(make_mask_filter());
SkAutoTUnref<SkTypeface> typeface(
SkTypeface::CreateFromName(make_font_name().c_str(), make_typeface_style()));
paint.setTypeface(typeface);
SkLayerRasterizer::Builder rasterizerBuilder;
SkPaint paintForRasterizer;
if (R(2) == 1) {
paintForRasterizer = make_paint();
}
rasterizerBuilder.addLayer(paintForRasterizer);
SkAutoTUnref<SkRasterizer> rasterizer(rasterizerBuilder.detachRasterizer());
paint.setRasterizer(rasterizer);
paint.setImageFilter(make_image_filter());
SkAutoDataUnref data(make_3Dlut(nullptr, make_bool(), make_bool(), make_bool()));
SkAutoTUnref<SkAnnotation> annotation(
SkAnnotation::Create(make_string().c_str(), data));
paint.setAnnotation(annotation);
paint.setTextAlign(make_paint_align());
paint.setTextSize(make_scalar());
paint.setTextScaleX(make_scalar());
paint.setTextSkewX(make_scalar());
paint.setTextEncoding(make_paint_text_encoding());
return paint;
}
void extractExamplesForView(const TrackList<SiftFeature>& tracks,
const cv::Mat& F,
const CameraProperties& camera1,
const CameraProperties& camera2,
const std::string& image_format,
const std::string& view,
int time,
const std::vector<double>& scales,
const std::vector<double>& angles) {
// March along epipolar line.
DistortedEpipolarRasterizer rasterizer(camera2, F);
rasterizer.init();
cv::Mat K1(camera1.matrix());
cv::Mat K1_inv = K1.inv();
TrackList<SiftFeature>::const_iterator track;
for (track = tracks.begin(); track != tracks.end(); ++track) {
Track<SiftFeature>::const_iterator iter = track->find(time);
CHECK(iter != track->end()) << "Track does not contain the current frame";
const SiftFeature& feature = iter->second;
cv::Point2d y1(feature.position.x, feature.position.y);
// Undo intrinsics, undistort, and re-apply intrinsics.
cv::Point2d x1 = affineTransformImagePoint(y1, K1_inv);
x1 = undistort(x1, camera1.distort_w);
x1 = affineTransformImagePoint(x1, K1);
// Extract the pixels of the epipolar line.
std::vector<cv::Point> line;
rasterizer.compute(x1, line);
// Load first image.
cv::Mat image;
std::string image_file = makeImageFilename(image_format, view, time);
bool ok = readGrayImage(image_file, image);
CHECK(ok) << "Could not load image";
std::deque<std::deque<SiftFeature> > features;
extractFeaturesAlongLine(line, image, scales, angles, features);
}
}
bool OsmAnd::OfflineMapRasterTileProvider_Software_P::obtainTile(const TileId tileId, const ZoomLevel zoom, std::shared_ptr<const MapTile>& outTile, const IQueryController* const queryController)
{
// Obtain offline map data tile
std::shared_ptr< const OfflineMapDataTile > dataTile;
owner->dataProvider->obtainTile(tileId, zoom, dataTile);
if (!dataTile)
{
outTile.reset();
return true;
}
#if OSMAND_PERFORMANCE_METRICS
const auto dataRasterization_Begin = std::chrono::high_resolution_clock::now();
#endif // OSMAND_PERFORMANCE_METRICS
// Allocate rasterization target
auto rasterizationSurface = new SkBitmap();
rasterizationSurface->setConfig(SkBitmap::kARGB_8888_Config, outputTileSize, outputTileSize);
if (!rasterizationSurface->allocPixels())
{
delete rasterizationSurface;
LogPrintf(LogSeverityLevel::Error, "Failed to allocate buffer for ARGB8888 rasterization surface %dx%d", outputTileSize, outputTileSize);
return false;
}
SkBitmapDevice rasterizationTarget(*rasterizationSurface);
// Create rasterization canvas
SkCanvas canvas(&rasterizationTarget);
// Perform actual rendering
if (!dataTile->nothingToRasterize)
{
Rasterizer rasterizer(dataTile->rasterizerContext);
rasterizer.rasterizeMap(canvas, true, nullptr, queryController);
}
#if OSMAND_PERFORMANCE_METRICS
const auto dataRasterization_End = std::chrono::high_resolution_clock::now();
const std::chrono::duration<float> dataRasterization_Elapsed = dataRasterization_End - dataRasterization_Begin;
if (!dataTile->nothingToRasterize)
{
LogPrintf(LogSeverityLevel::Info,
"%d map objects in %dx%d@%d: rasterization %fs",
dataTile->mapObjects.count(), tileId.x, tileId.y, zoom, dataRasterization_Elapsed.count());
}
else
{
LogPrintf(LogSeverityLevel::Info,
"%d map objects in %dx%d@%d: nothing to rasterize (%fs)",
dataTile->mapObjects.count(), tileId.x, tileId.y, zoom, dataRasterization_Elapsed.count());
}
#endif // OSMAND_PERFORMANCE_METRICS
// If there is no data to rasterize, tell that this tile is not available
if (dataTile->nothingToRasterize)
{
delete rasterizationSurface;
outTile.reset();
return true;
}
// Or supply newly rasterized tile
auto tile = new Tile(rasterizationSurface, dataTile);
outTile.reset(tile);
return true;
}
bool OsmAnd::OfflineMapSymbolProvider_P::obtainSymbols(
const TileId tileId, const ZoomLevel zoom,
std::shared_ptr<const MapSymbolsTile>& outTile,
std::function<bool (const std::shared_ptr<const Model::MapObject>& mapObject)> filter)
{
// Obtain offline map data tile
std::shared_ptr< const OfflineMapDataTile > dataTile;
owner->dataProvider->obtainTile(tileId, zoom, dataTile);
// If tile has nothing to be rasterized, mark that data is not available for it
if (!dataTile || dataTile->nothingToRasterize)
{
// Mark tile as empty
outTile.reset();
return true;
}
// Create rasterizer
Rasterizer rasterizer(dataTile->rasterizerContext);
// Rasterize symbols
QList< std::shared_ptr<const RasterizedSymbolsGroup> > rasterizedSymbolsGroups;
rasterizer.rasterizeSymbolsWithoutPaths(rasterizedSymbolsGroups, filter, nullptr);
// Convert results
QList< std::shared_ptr<const MapSymbolsGroup> > symbolsGroups;
for(const auto& rasterizedGroup : constOf(rasterizedSymbolsGroups))
{
// Create group
const auto constructedGroup = new MapSymbolsGroup(rasterizedGroup->mapObject);
std::shared_ptr<const MapSymbolsGroup> group(constructedGroup);
// Convert all symbols inside group
for(const auto& rasterizedSymbol : constOf(rasterizedGroup->symbols))
{
if (const auto pinnedSymbol = std::dynamic_pointer_cast<const RasterizedPinnedSymbol>(rasterizedSymbol))
{
const auto symbol = new MapPinnedSymbol(
group, constructedGroup->mapObject,
pinnedSymbol->bitmap,
pinnedSymbol->order,
pinnedSymbol->content,
pinnedSymbol->languageId,
pinnedSymbol->minDistance,
pinnedSymbol->location31,
pinnedSymbol->offset);
assert(static_cast<bool>(symbol->bitmap));
constructedGroup->symbols.push_back(qMove(std::shared_ptr<const MapSymbol>(symbol)));
}
else if (const auto symbolOnPath = std::dynamic_pointer_cast<const RasterizedSymbolOnPath>(rasterizedSymbol))
{
const auto symbol = new MapSymbolOnPath(
group, constructedGroup->mapObject,
symbolOnPath->bitmap,
symbolOnPath->order,
symbolOnPath->content,
symbolOnPath->languageId,
symbolOnPath->minDistance,
symbolOnPath->glyphsWidth);
assert(static_cast<bool>(symbol->bitmap));
constructedGroup->symbols.push_back(qMove(std::shared_ptr<const MapSymbol>(symbol)));
}
}
// Add constructed group to output
symbolsGroups.push_back(qMove(group));
}
// Create output tile
outTile.reset(new Tile(symbolsGroups, dataTile));
return true;
}
void render(geometry_type& geom,Image32& image) const
{
ScanlineRasterizerAA<Image32> rasterizer(image);
rasterizer.render<SHIFT8>(geom,fill_);
}
void rasterize(std::ostream &output, const OsmAnd::EyePiece::Configuration& cfg)
#endif
{
// Obtain and configure rasterization style context
OsmAnd::MapStyles stylesCollection;
for(auto itStyleFile = cfg.styleFiles.cbegin(); itStyleFile != cfg.styleFiles.cend(); ++itStyleFile)
{
const auto& styleFile = *itStyleFile;
if(!stylesCollection.registerStyle(styleFile.absoluteFilePath()))
output << xT("Failed to parse metadata of '") << QStringToStlString(styleFile.fileName()) << xT("' or duplicate style") << std::endl;
}
std::shared_ptr<const OsmAnd::MapStyle> style;
if(!stylesCollection.obtainStyle(cfg.styleName, style))
{
output << xT("Failed to resolve style '") << QStringToStlString(cfg.styleName) << xT("'") << std::endl;
return;
}
if(cfg.dumpRules)
style->dump();
OsmAnd::ObfsCollection obfsCollection;
obfsCollection.watchDirectory(cfg.obfsDir);
// Collect all map objects (this should be replaced by something like RasterizerViewport/RasterizerContext)
QList< std::shared_ptr<const OsmAnd::Model::MapObject> > mapObjects;
OsmAnd::AreaI bbox31(
OsmAnd::Utilities::get31TileNumberY(cfg.bbox.top),
OsmAnd::Utilities::get31TileNumberX(cfg.bbox.left),
OsmAnd::Utilities::get31TileNumberY(cfg.bbox.bottom),
OsmAnd::Utilities::get31TileNumberX(cfg.bbox.right)
);
const auto& obfDI = obfsCollection.obtainDataInterface();
OsmAnd::MapFoundationType mapFoundation;
obfDI->obtainMapObjects(&mapObjects, &mapFoundation, bbox31, cfg.zoom, nullptr);
bool basemapAvailable;
obfDI->obtainBasemapPresenceFlag(basemapAvailable);
// Calculate output size in pixels
const auto tileWidth = OsmAnd::Utilities::getTileNumberX(cfg.zoom, cfg.bbox.right) - OsmAnd::Utilities::getTileNumberX(cfg.zoom, cfg.bbox.left);
const auto tileHeight = OsmAnd::Utilities::getTileNumberY(cfg.zoom, cfg.bbox.bottom) - OsmAnd::Utilities::getTileNumberY(cfg.zoom, cfg.bbox.top);
const auto pixelWidth = qCeil(tileWidth * cfg.tileSide);
const auto pixelHeight = qCeil(tileHeight * cfg.tileSide);
output << xT("Will rasterize ") << mapObjects.count() << xT(" objects onto ") << pixelWidth << xT("x") << pixelHeight << xT(" bitmap") << std::endl;
// Allocate render target
SkBitmap renderSurface;
renderSurface.setConfig(cfg.is32bit ? SkBitmap::kARGB_8888_Config : SkBitmap::kRGB_565_Config, pixelWidth, pixelHeight);
if(!renderSurface.allocPixels())
{
output << xT("Failed to allocated render target ") << pixelWidth << xT("x") << pixelHeight;
return;
}
SkBitmapDevice renderTarget(renderSurface);
// Create render canvas
SkCanvas canvas(&renderTarget);
// Perform actual rendering
std::shared_ptr<OsmAnd::RasterizerEnvironment> rasterizerEnv(new OsmAnd::RasterizerEnvironment(style, cfg.densityFactor));
std::shared_ptr<OsmAnd::RasterizerContext> rasterizerContext(new OsmAnd::RasterizerContext(rasterizerEnv));
OsmAnd::Rasterizer::prepareContext(*rasterizerContext, bbox31, cfg.zoom, mapFoundation, mapObjects);
OsmAnd::Rasterizer rasterizer(rasterizerContext);
if(cfg.drawMap)
{
rasterizer.rasterizeMap(canvas);
}
/*if(cfg.drawText)
OsmAnd::Rasterizer::rasterizeText(rasterizerContext, !cfg.drawMap, canvas, nullptr);*/
// Save rendered area
if(!cfg.output.isEmpty())
{
std::unique_ptr<SkImageEncoder> encoder(CreatePNGImageEncoder());
encoder->encodeFile(cfg.output.toLocal8Bit(), renderSurface, 100);
}
return;
}
