osmstyle.cpp

#include "osmstyle.h"
#include <QHash>
#include <algorithm>
using namespace TagEnum;
using namespace LOD;

OsmStyle::OsmStyle()
{
    initStyles();
}

void OsmStyle::initStyles()
{
    m_fillStyles.clear();
    m_lineStyles.clear();
    m_lineStyleIndex.clear();

    auto addFill = [&](int type, QColor color, int lodMin, int lodMax, qreal opacity = 1.0, int zIndex = 0, float majorZ = 0.0f, double distThresh = 1e9) {
        m_fillStyles.append({type, color, lodMin, lodMax, opacity, zIndex, majorZ, distThresh});
    };

    auto addLine = [&](int type, LineType lineType, qreal width, QColor color, qreal opacity, qreal realWidth,
                       bool showArrow, bool showOneway, const QVector<qreal>& dashes, const QColor& dashBg,
                       qreal offset, float majorZ, int lodMin, int lodMax, int order, double distThresh) {
        LineStyle ls = {type, lineType, width, color, QColor(), 0, false, lodMin, lodMax, order, opacity, realWidth, offset, showArrow, showOneway, dashes, dashBg, majorZ, distThresh};
        m_lineStyles.append(ls);
    };

    auto addCasing = [&](int type, LineType casingType, qreal width, QColor color, qreal offset, float majorZ,
                         int lodMin, int lodMax, int order, double distThresh, qreal realWidth = 0, qreal opacity = 0.95) {
        LineStyle ls = {type, casingType, width, color, QColor(), 0, false, lodMin, lodMax, order, opacity, realWidth, offset, false, false, QVector<qreal>(), QColor(), majorZ, distThresh};
        m_lineStyles.append(ls);
    };

    addFill(BUILDING, QColor(220, 220, 210), LOD_CITY, LOD_DETAIL, 1.0, 0, 2.0f);
    addFill(LANDUSE_RESIDENTIAL, QColor(240, 235, 225), LOD_CITY, LOD_DETAIL, 0.9, 0, 1.5f);
    addFill(LANDUSE_COMMERCIAL, QColor(230, 200, 180), LOD_CITY, LOD_DETAIL, 0.9, 0, 1.5f);
    addFill(LANDUSE_INDUSTRIAL, QColor(200, 200, 200), LOD_CITY, LOD_DETAIL, 0.9, 0, 1.5f);
    addFill(LANDUSE_FOREST, QColor(100, 160, 100), LOD_PROVINCE, LOD_DETAIL, 0.85, 0, 1.0f);
    addFill(LANDUSE_GRASS, QColor(150, 200, 150), LOD_TOWN, LOD_DETAIL, 0.9, 0, 1.0f);
    addFill(LANDUSE_MEADOW, QColor(180, 220, 180), LOD_TOWN, LOD_DETAIL, 0.9, 0, 1.0f);
    addFill(LANDUSE_RECREATION_GROUND, QColor(120, 180, 120), LOD_CITY, LOD_DETAIL, 0.9, 0, 1.0f);
    addFill(LANDUSE_ALLOTMENTS, QColor(160, 210, 160), LOD_STREET, LOD_DETAIL, 0.9, 0, 1.0f);
    addFill(LANDUSE_CEMETERY, QColor(200, 200, 200), LOD_TOWN, LOD_DETAIL, 0.9, 0, 1.0f);
    addFill(LANDUSE_ORCHARD, QColor(170, 200, 150), LOD_TOWN, LOD_DETAIL, 0.9, 0, 1.0f);
    addFill(LANDUSE_VINEYARD, QColor(180, 190, 150), LOD_TOWN, LOD_DETAIL, 0.9, 0, 1.0f);
    addFill(LANDUSE_FARMLAND, QColor(220, 230, 200), LOD_PROVINCE, LOD_DETAIL, 0.85, 0, 1.0f);
    addFill(NATURAL_WATER, QColor(100, 150, 220), LOD_COUNTRY, LOD_DETAIL, 0.95, 0, 0.5f);
    addFill(NATURAL_WOOD, QColor(80, 140, 80), LOD_PROVINCE, LOD_DETAIL, 0.85, 0, 1.0f);
    addFill(NATURAL_GRASSLAND, QColor(130, 180, 130), LOD_PROVINCE, LOD_DETAIL, 0.85, 0, 1.0f);
    addFill(NATURAL_SAND, QColor(240, 230, 200), LOD_TOWN, LOD_DETAIL, 0.9, 0, 1.0f);
    addFill(NATURAL_BEACH, QColor(255, 245, 220), LOD_TOWN, LOD_DETAIL, 0.9, 0, 1.0f);
    addFill(NATURAL_SCRUB, QColor(160, 180, 140), LOD_TOWN, LOD_DETAIL, 0.85, 0, 1.0f);
    addFill(NATURAL_HEATH, QColor(150, 170, 150), LOD_TOWN, LOD_DETAIL, 0.85, 0, 1.0f);
    addFill(NATURAL_WETLAND, QColor(100, 180, 150), LOD_PROVINCE, LOD_DETAIL, 0.85, 0, 1.0f);
    addFill(LEISURE_PARK, QColor(120, 190, 120), LOD_CITY, LOD_DETAIL, 0.95, 0, 1.0f);
    addFill(LEISURE_GOLF_COURSE, QColor(140, 200, 140), LOD_TOWN, LOD_DETAIL, 0.95, 0, 1.0f);
    addFill(LEISURE_STADIUM, QColor(200, 180, 220), LOD_CITY, LOD_DETAIL, 0.95, 0, 2.0f);
    addFill(LEISURE_WATER_PARK, QColor(100, 180, 220), LOD_TOWN, LOD_DETAIL, 0.95, 0, 1.0f);
    addFill(LEISURE_GARDEN, QColor(160, 210, 160), LOD_STREET, LOD_DETAIL, 0.95, 0, 1.0f);
    addFill(HISTORIC_CASTLE, QColor(180, 160, 140), LOD_TOWN, LOD_DETAIL, 1.0, 0, 2.5f);
    addFill(HISTORIC_RUINS, QColor(160, 150, 140), LOD_TOWN, LOD_DETAIL, 0.95, 0, 2.5f);

    addLine(WATERWAY, LineType::NORMAL, 0.15, QColor(100, 180, 255), 0.9, 0, false, false, QVector<qreal>(), QColor(), 0, 3.0f, LOD_TOWN, LOD_DETAIL, 10, 100000);
    addLine(WATERWAY_RIVER, LineType::NORMAL, 0.25, QColor(100, 180, 255), 0.9, 0, false, false, QVector<qreal>(), QColor(), 0, 3.0f, LOD_PROVINCE, LOD_DETAIL, 11, 100000);
    addLine(WATERWAY_CANAL, LineType::NORMAL, 0.18, QColor(100, 180, 255), 0.9, 0, false, false, QVector<qreal>(), QColor(), 0, 3.0f, LOD_PROVINCE, LOD_DETAIL, 12, 100000);
    addLine(WATERWAY_STREAM, LineType::NORMAL, 0.08, QColor(100, 180, 255), 0.9, 0, false, false, QVector<qreal>(), QColor(), 0, 3.0f, LOD_TOWN, LOD_DETAIL, 13, 100000);
    addLine(WATERWAY_DRAIN, LineType::NORMAL, 0.06, QColor(100, 180, 255), 0.9, 0, false, false, QVector<qreal>(), QColor(), 0, 3.0f, LOD_TOWN, LOD_DETAIL, 14, 100000);

    addLine(RAILWAY, LineType::NORMAL, 0.1, QColor(120, 120, 120), 0.95, 0, false, false, QVector<qreal>{8.0, 6.0}, QColor(), 0, 3.0f, LOD_CITY, LOD_DETAIL, 20, 500000);
    addLine(HIGHWAY_PATH, LineType::NORMAL, 0.1, QColor(150, 220, 150), 0.9, 1.5, true, true, QVector<qreal>(), QColor(), 0, 2.0f, LOD_STREET, LOD_DETAIL, 25, 10000);
    addLine(HIGHWAY_FOOTWAY, LineType::NORMAL, 0.1, QColor(150, 220, 150), 0.9, 1.5, true, true, QVector<qreal>(), QColor(), 0, 2.0f, LOD_STREET, LOD_DETAIL, 26, 10000);
    addLine(HIGHWAY_CYCLEWAY, LineType::NORMAL, 0.15, QColor(150, 220, 150), 0.9, 2.5, true, true, QVector<qreal>(), QColor(), 0, 2.5f, LOD_STREET, LOD_DETAIL, 27, 10000);
    addLine(HIGHWAY_STEPS, LineType::NORMAL, 0.1, QColor(150, 220, 150), 0.9, 1.5, true, true, QVector<qreal>(), QColor(), 0, 2.0f, LOD_STREET, LOD_DETAIL, 28, 10000);
    addLine(HIGHWAY_TRAFFIC_SIGNALS, LineType::NORMAL, 0.08, QColor(255, 165, 0), 0.9, 0, false, false, QVector<qreal>(), QColor(), 0, 2.0f, LOD_STREET, LOD_DETAIL, 29, 10000);
    addLine(HIGHWAY_TRACK, LineType::NORMAL, 0.15, QColor(200, 200, 200), 0.9, 3.5, true, true, QVector<qreal>(), QColor(), 0, 3.0f, LOD_TOWN, LOD_DETAIL, 30, 50000);
    addLine(HIGHWAY_SERVICE, LineType::NORMAL, 0.2, QColor(200, 200, 200), 0.9, 4.0, true, true, QVector<qreal>(), QColor(), 0, 4.0f, LOD_TOWN, LOD_DETAIL, 35, 50000);
    addLine(HIGHWAY_PEDESTRIAN, LineType::NORMAL, 0.2, QColor(240, 230, 210), 0.95, 4.5, true, true, QVector<qreal>(), QColor(), 0, 4.0f, LOD_STREET, LOD_DETAIL, 36, 50000);
    addLine(HIGHWAY_LIVING_STREET, LineType::NORMAL, 0.25, QColor(240, 240, 240), 0.95, 5.0, true, true, QVector<qreal>(), QColor(), 0, 5.0f, LOD_STREET, LOD_DETAIL, 37, 50000);
    addLine(HIGHWAY_RESIDENTIAL, LineType::NORMAL, 0.25, QColor(240, 240, 240), 0.95, 5.5, true, true, QVector<qreal>(), QColor(), 0, 6.0f, LOD_CITY, LOD_DETAIL, 40, 100000);
    addLine(HIGHWAY_UNCLASSIFIED, LineType::NORMAL, 0.28, QColor(240, 240, 240), 0.95, 6.0, true, true, QVector<qreal>(), QColor(), 0, 6.5f, LOD_CITY, LOD_DETAIL, 42, 100000);
    addLine(HIGHWAY_TERTIARY, LineType::NORMAL, 0.3, QColor(220, 220, 220), 0.95, 7.5, true, true, QVector<qreal>(), QColor(), 0, 8.0f, LOD_PROVINCE, LOD_DETAIL, 50, 200000);
    addLine(HIGHWAY_SECONDARY, LineType::NORMAL, 0.35, QColor(255, 220, 100), 0.95, 9.5, true, true, QVector<qreal>(), QColor(), 0, 10.0f, LOD_PROVINCE, LOD_DETAIL, 60, 500000);
    addCasing(HIGHWAY_PRIMARY, LineType::CASING, 0.55, QColor(220, 140, 60), 0, 12.0f, LOD_PROVINCE, LOD_DETAIL, 69, 1000000, 15.0);
    addLine(HIGHWAY_PRIMARY, LineType::NORMAL, 0.35, QColor(255, 180, 80), 0.95, 12.0, true, true, QVector<qreal>(), QColor(), 0, 10.0f, LOD_PROVINCE, LOD_DETAIL, 70, 1000000);
    addCasing(HIGHWAY_TRUNK, LineType::CASING, 0.65, QColor(200, 80, 40), 0, 18.0f, LOD_COUNTRY, LOD_DETAIL, 79, 2000000, 20.0);
    addLine(HIGHWAY_TRUNK, LineType::NORMAL, 0.45, QColor(255, 120, 60), 0.95, 18.0, true, true, QVector<qreal>(), QColor(), 0, 15.0f, LOD_COUNTRY, LOD_DETAIL, 80, 2000000);
    addCasing(HIGHWAY_MOTORWAY, LineType::CASING, 0.75, QColor(200, 60, 30), 0, 25.0f, LOD_COUNTRY, LOD_DETAIL, 89, 5000000, 25.0);
    addLine(HIGHWAY_MOTORWAY, LineType::NORMAL, 0.55, QColor(255, 100, 50), 0.95, 22.0, true, true, QVector<qreal>(), QColor(), 0, 22.0f, LOD_COUNTRY, LOD_DETAIL, 90, 5000000);
    addLine(BOUNDARY_ADMIN, LineType::NORMAL, 0.1, QColor(200, 100, 100), 0.85, 0, false, false, QVector<qreal>(), QColor(), 0, 5.5f, LOD_PROVINCE, LOD_DETAIL, 100, 1000000);

    std::sort(m_lineStyles.begin(), m_lineStyles.end(), [](const LineStyle& a, const LineStyle& b) {
        if (a.majorZIndex != b.majorZIndex) return a.majorZIndex < b.majorZIndex;
        return a.drawOrder < b.drawOrder;
    });

    for (int i = 0; i < m_lineStyles.size(); ++i) {
        m_lineStyleIndex.insert(m_lineStyles[i].type, i);
    }
}

const LineStyle* OsmStyle::lineStyleFor(int type) const
{
    auto it = m_lineStyleIndex.constFind(type);
    if (it != m_lineStyleIndex.constEnd()) {
        return &m_lineStyles[it.value()];
    }
    return nullptr;
}

void OsmStyle::resetToDefault()
{
    initStyles();
}

void OsmStyle::setFillColor(int type, const QColor &color)
{
    for (auto &fs : m_fillStyles) {
        if (fs.type == type) {
            fs.color = color;
        }
    }
}

void OsmStyle::setLineColor(int type, const QColor &color, LineType lineType)
{
    for (auto &ls : m_lineStyles) {
        if (ls.type == type && ls.lineType == lineType) {
            ls.color = color;
        }
    }
}

void OsmStyle::setLineWidth(int type, qreal widthPx, LineType lineType)
{
    for (auto &ls : m_lineStyles) {
        if (ls.type == type && ls.lineType == lineType) {
            ls.widthPx = widthPx;
        }
    }
}

int OsmStyle::highwayTagType(const QString &value)
{
    if (value == "motorway")      return HIGHWAY_MOTORWAY;
    if (value == "trunk")         return HIGHWAY_TRUNK;
    if (value == "primary")       return HIGHWAY_PRIMARY;
    if (value == "secondary")     return HIGHWAY_SECONDARY;
    if (value == "tertiary")      return HIGHWAY_TERTIARY;
    if (value == "residential")   return HIGHWAY_RESIDENTIAL;
    if (value == "unclassified")  return HIGHWAY_UNCLASSIFIED;
    if (value == "service")       return HIGHWAY_SERVICE;
    if (value == "track")         return HIGHWAY_TRACK;
    if (value == "path")          return HIGHWAY_PATH;
    if (value == "footway")       return HIGHWAY_FOOTWAY;
    if (value == "cycleway")      return HIGHWAY_CYCLEWAY;
    if (value == "steps")         return HIGHWAY_STEPS;
    if (value == "pedestrian")    return HIGHWAY_PEDESTRIAN;
    if (value == "living_street") return HIGHWAY_LIVING_STREET;
    if (value == "construction")  return HIGHWAY_CONSTRUCTION;
    if (value == "bridleway")     return HIGHWAY_BRIDLEWAY;
    if (value == "bus_guideway")  return HIGHWAY_BUS_GUIDEWAY;
    if (value == "traffic_signals") return HIGHWAY_TRAFFIC_SIGNALS;
    return UNKNOWN;
}

int OsmStyle::railwayTagType(const QString &value)
{
    if (value == "rail")         return RAILWAY;
    if (value == "light_rail")   return RAILWAY_LIGHT_RAIL;
    if (value == "tram")         return RAILWAY_TRAM;
    if (value == "subway")       return RAILWAY_SUBWAY;
    if (value == "monorail")     return RAILWAY_MONORAIL;
    if (value == "narrow_gauge") return RAILWAY_NARROW_GAUGE;
    if (value == "abandoned")    return RAILWAY_ABANDONED;
    if (value == "disused")      return RAILWAY_DISUSED;
    if (value == "preserved")    return RAILWAY;
    return UNKNOWN;  // Unknown railway type - no POI created
}

int OsmStyle::waterwayTagType(const QString &value)
{
    static const QStringList waterAreaValues = {"riverbank", "dock", "basin", "reservoir", "pond", "lake"};
    if (waterAreaValues.contains(value)) {
        return NATURAL_WATER;
    }
    if (value == "river")   return WATERWAY_RIVER;
    if (value == "canal")   return WATERWAY_CANAL;
    if (value == "stream")  return WATERWAY_STREAM;
    if (value == "drain")   return WATERWAY_DRAIN;
    return UNKNOWN;  // Unknown waterway type - no POI created
}

int OsmStyle::buildingTagType(const QString &value)
{
    if (value == "no" || value == "none" || value.isEmpty()) return UNKNOWN;
    return BUILDING;
}

int OsmStyle::landuseTagType(const QString &value)
{
    if (value == "residential")      return LANDUSE_RESIDENTIAL;
    if (value == "forest")           return LANDUSE_FOREST;
    if (value == "grass")            return LANDUSE_GRASS;
    if (value == "industrial")       return LANDUSE_INDUSTRIAL;
    if (value == "commercial")       return LANDUSE_COMMERCIAL;
    if (value == "farmland")         return LANDUSE_FARMLAND;
    if (value == "meadow")           return LANDUSE_MEADOW;
    if (value == "recreation_ground")return LANDUSE_RECREATION_GROUND;
    if (value == "retail")           return LANDUSE_RETAIL;
    if (value == "construction")     return LANDUSE_CONSTRUCTION;
    if (value == "landfill")         return LANDUSE_LANDFILL;
    if (value == "military")         return LANDUSE_MILITARY;
    if (value == "quarry")           return LANDUSE_QUARRY;
    if (value == "cemetery")         return LANDUSE_CEMETERY;
    if (value == "allotments")       return LANDUSE_ALLOTMENTS;
    if (value == "orchard")          return LANDUSE_ORCHARD;
    if (value == "vineyard")         return LANDUSE_VINEYARD;
    if (value == "reservoir")        return LANDUSE_RESERVOIR;
    if (value == "basin")            return LANDUSE_BASIN;
    if (value == "farm")             return LANDUSE_FARMLAND;
    if (value == "farmyard")         return LANDUSE_RESIDENTIAL;
    return UNKNOWN;
}

int OsmStyle::naturalTagType(const QString &value)
{
    if (value == "water")      return NATURAL_WATER;
    if (value == "wood")       return NATURAL_WOOD;
    if (value == "tree")       return NATURAL_WOOD;
    if (value == "grassland")  return NATURAL_GRASSLAND;
    if (value == "beach")      return NATURAL_BEACH;
    if (value == "glacier")    return NATURAL_GLACIER;
    if (value == "marsh")      return NATURAL_MARSH;
    if (value == "mud")        return NATURAL_MUD;
    if (value == "sand")       return NATURAL_SAND;
    if (value == "scrub")      return NATURAL_SCRUB;
    if (value == "heath")      return NATURAL_HEATH;
    if (value == "wetland")    return NATURAL_WETLAND;
    if (value == "coastline")  return NATURAL_COASTLINE;
    if (value == "rock")       return NATURAL_ROCK;
    if (value == "peak")       return NATURAL_ROCK;
    if (value == "cliff")      return NATURAL_ROCK;
    if (value == "cave_entrance") return NATURAL_ROCK;
    if (value == "spring")     return NATURAL_WATER;
    if (value == "hot_spring") return NATURAL_WATER;
    if (value == "geyser")     return NATURAL_WATER;
    if (value == "bay")        return NATURAL_WATER;
    if (value == "strait")     return NATURAL_WATER;
    return UNKNOWN;
}

int OsmStyle::leisureTagType(const QString &value)
{
    if (value == "park")             return LEISURE_PARK;
    if (value == "golf_course")      return LEISURE_GOLF_COURSE;
    if (value == "sports_centre")    return LEISURE_SPORTS_CENTRE;
    if (value == "stadium")          return LEISURE_STADIUM;
    if (value == "playground")       return LEISURE_PLAYGROUND;
    if (value == "pitch")            return LEISURE_PITCH;
    if (value == "track")            return LEISURE_TRACK;
    if (value == "marina")           return LEISURE_MARINA;
    if (value == "nature_reserve")   return LEISURE_NATURE_RESERVE;
    if (value == "water_park")       return LEISURE_WATER_PARK;
    if (value == "garden")           return LEISURE_GARDEN;
    if (value == "common")           return LEISURE_COMMON;
    return UNKNOWN;
}

int OsmStyle::boundaryTagType(const QString &value)
{
    if (value == "administrative") return BOUNDARY_ADMIN;
    if (value == "national_park")  return BOUNDARY_NATIONAL_PARK;
    if (value == "civil")          return BOUNDARY_CIVIL;
    if (value == "political")      return BOUNDARY_POLITICAL;
    return UNKNOWN;  // Unknown boundary type - no POI created
}

int OsmStyle::barrierTagType(const QString &value)
{
    if (value == "fence")          return BARRIER_FENCE;
    if (value == "wall")           return BARRIER_WALL;
    if (value == "hedge")          return BARRIER_HEDGE;
    if (value == "ditch")          return BARRIER_DITCH;
    if (value == "retaining_wall") return BARRIER_RETAINING_WALL;
    if (value == "city_wall")      return BARRIER_CITY_WALL;
    return UNKNOWN;
}

int OsmStyle::aerowayTagType(const QString &value)
{
    if (value == "runway")     return AEROWAY_RUNWAY;
    if (value == "taxiway")    return AEROWAY_TAXIWAY;
    if (value == "apron")      return AEROWAY_APRON;
    if (value == "terminal")   return AEROWAY_TERMINAL;
    if (value == "aerodrome")  return AEROWAY_AERODROME;
    if (value == "airport")    return AEROWAY_AERODROME;
    return UNKNOWN;
}

int OsmStyle::powerTagType(const QString &value)
{
    if (value == "line")         return POWER_LINE;
    if (value == "minor_line")  return POWER_LINE;
    if (value == "cable")       return POWER_LINE;
    if (value == "tower")        return POWER_TOWER;
    if (value == "pole")         return POWER_TOWER;
    if (value == "sub_station")  return POWER_SUBSTATION;
    if (value == "substation")   return POWER_SUBSTATION;
    if (value == "generator")    return POWER_SUBSTATION;
    if (value == "transformer")  return POWER_SUBSTATION;
    if (value == "switch")       return POWER_SUBSTATION;
    return UNKNOWN;
}

int OsmStyle::manMadeTagType(const QString &value)
{
    if (value == "tower")        return MAN_MADE_TOWER;
    if (value == "mast")         return MAN_MADE_TOWER;
    if (value == "lighthouse")   return MAN_MADE_TOWER;
    if (value == "water_tower")  return MAN_MADE_TOWER;
    if (value == "communications_tower") return MAN_MADE_TOWER;
    if (value == "water_well")   return MAN_MADE_TOWER;
    if (value == "windmill")     return MAN_MADE_TOWER;
    if (value == "pipeline")     return MAN_MADE_TOWER;
    if (value == "pump")         return MAN_MADE_TOWER;
    if (value == "storage_tank") return MAN_MADE_TOWER;
    if (value == "wastewater_plant") return MAN_MADE_TOWER;
    if (value == "works")        return MAN_MADE_TOWER;
    if (value == "surveillance") return MAN_MADE_TOWER;
    if (value == "survey_point") return MAN_MADE_TOWER;
    if (value == "beacon")       return MAN_MADE_TOWER;
    return UNKNOWN;
}

int OsmStyle::historicTagType(const QString &value)
{
    if (value == "castle")                return HISTORIC_CASTLE;
    if (value == "ruins")                 return HISTORIC_RUINS;
    if (value == "memorial")              return HISTORIC_MEMORIAL;
    if (value == "monument")              return HISTORIC_MONUMENT;
    if (value == "archaeological_site")   return HISTORIC_ARCHAEOLOGICAL_SITE;
    return UNKNOWN;
}

int OsmStyle::tourismTagType(const QString &value)
{
    if (value == "hotel")          return TOURISM_HOTEL;
    if (value == "motel")          return TOURISM_MOTEL;
    if (value == "hostel")         return TOURISM_HOSTEL;
    if (value == "guest_house")    return TOURISM_GUESTHOUSE;
    if (value == "attraction")     return TOURISM_ATTRACTION;
    if (value == "museum")         return TOURISM_MUSEUM;
    if (value == "viewpoint")      return TOURISM_VIEWPOINT;
    if (value == "zoo")            return TOURISM_ZOO;
    if (value == "camp_site")      return TOURISM_CAMP_SITE;
    if (value == "caravan_site")   return TOURISM_CARAVAN_SITE;
    if (value == "picnic_site")    return TOURISM_PICNIC_SITE;
    if (value == "theme_park")     return TOURISM_THEME_PARK;
    return UNKNOWN;
}

int OsmStyle::amenityTagType(const QString &value)
{
    if (value == "hospital")         return AMENITY_HOSPITAL;
    if (value == "school")           return AMENITY_SCHOOL;
    if (value == "university")       return AMENITY_UNIVERSITY;
    if (value == "college")          return AMENITY_UNIVERSITY;
    if (value == "kindergarten")     return AMENITY_SCHOOL;
    if (value == "police")           return AMENITY_POLICE;
    if (value == "fire_station")     return AMENITY_FIRE_STATION;
    if (value == "parking")          return AMENITY_PARKING;
    if (value == "fuel")             return AMENITY_FUEL;
    if (value == "restaurant")       return AMENITY_RESTAURANT;
    if (value == "cafe")             return AMENITY_CAFE;
    if (value == "fast_food")        return AMENITY_RESTAURANT;
    if (value == "pub")              return AMENITY_PUB;
    if (value == "bar")              return AMENITY_BAR;
    if (value == "bank")             return AMENITY_BANK;
    if (value == "atm")              return AMENITY_ATM;
    if (value == "pharmacy")         return AMENITY_PHARMACY;
    if (value == "post_office")      return AMENITY_POST_OFFICE;
    if (value == "library")          return AMENITY_LIBRARY;
    if (value == "townhall")         return AMENITY_TOWN_HALL;
    if (value == "public_building")  return AMENITY_PUBLIC_BUILDING;
    if (value == "place_of_worship") return AMENITY_PLACE_OF_WORSHIP;
    if (value == "cinema")           return AMENITY_PLACE_OF_WORSHIP;
    if (value == "theatre")          return AMENITY_PLACE_OF_WORSHIP;
    if (value == "community_centre") return AMENITY_PUBLIC_BUILDING;
    if (value == "clinic")           return AMENITY_HOSPITAL;
    if (value == "doctors")          return AMENITY_HOSPITAL;
    if (value == "dentist")          return AMENITY_HOSPITAL;
    if (value == "veterinary")       return AMENITY_HOSPITAL;
    if (value == "bus_station")      return AMENITY_PARKING;
    if (value == "taxi")             return AMENITY_PARKING;
    if (value == "shelter")          return AMENITY_PLACE_OF_WORSHIP;
    if (value == "bicycle_rental")   return AMENITY_PARKING;
    if (value == "drinking_water")   return AMENITY_PARKING;
    if (value == "toilets")          return AMENITY_PARKING;
    if (value == "telephone")        return AMENITY_PARKING;
    if (value == "nursing_home")     return AMENITY_HOSPITAL;
    if (value == "social_facility")  return AMENITY_PUBLIC_BUILDING;
    return UNKNOWN;
}

int OsmStyle::shopTagType(const QString &value)
{
    if (value == "supermarket")       return SHOP_SUPERMARKET;
    if (value == "mall")              return SHOP_MALL;
    if (value == "convenience")       return SHOP_CONVENIENCE;
    if (value == "convenience_store") return SHOP_CONVENIENCE;
    if (value == "clothes")           return SHOP_CLOTHES;
    if (value == "bakery")            return SHOP_BAKERY;
    if (value == "baker")             return SHOP_BAKERY;
    if (value == "butcher")           return SHOP_BUTCHER;
    if (value == "grocery")           return SHOP_GROCERY;
    if (value == "hardware")          return SHOP_HARDWARE;
    if (value == "furniture")         return SHOP_FURNITURE;
    if (value == "bicycle")           return SHOP_BICYCLE;
    if (value == "car")               return SHOP_CAR;
    if (value == "car_repair")        return SHOP_CAR_REPAIR;
    if (value == "car_parts")         return SHOP_CAR_REPAIR;
    if (value == "electronics")       return SHOP_HARDWARE;
    if (value == "mobile_phone")      return SHOP_HARDWARE;
    if (value == "books")             return SHOP_CLOTHES;
    if (value == "shoes")             return SHOP_CLOTHES;
    if (value == "jewelry")           return SHOP_CLOTHES;
    if (value == "beauty")            return SHOP_CLOTHES;
    if (value == "hairdresser")       return SHOP_CLOTHES;
    if (value == "optician")          return SHOP_HARDWARE;
    if (value == "travel_agency")     return SHOP_CLOTHES;
    if (value == "tobacco")           return SHOP_CLOTHES;
    if (value == "sports")            return SHOP_BICYCLE;
    if (value == "alcohol")           return SHOP_CLOTHES;
    if (value == "department_store") return SHOP_MALL;
    if (value == "general")           return SHOP_GROCERY;
    if (value == "variety_store")     return SHOP_GROCERY;
    if (value == "chemist")           return SHOP_HARDWARE;
    if (value == "cosmetics")         return SHOP_CLOTHES;
    if (value == "gift")              return SHOP_CLOTHES;
    if (value == "kiosk")             return SHOP_CONVENIENCE;
    if (value == "marketplace")       return SHOP_MALL;
    return UNKNOWN;
}

int OsmStyle::sportTagType(const QString &value)
{
    if (value == "soccer")       return SPORT_SOCCER;
    if (value == "football")     return SPORT_SOCCER;
    if (value == "tennis")       return SPORT_TENNIS;
    if (value == "basketball")   return SPORT_BASKETBALL;
    if (value == "swimming")     return SPORT_SWIMMING;
    if (value == "baseball")     return SPORT_BASEBALL;
    return UNKNOWN;
}

int OsmStyle::militaryTagType(const QString &value)
{
    if (value == "airfield")    return MILITARY_AIRFIELD;
    if (value == "barracks")    return MILITARY_BARRACKS;
    if (value == "danger_area") return MILITARY_DANGER_AREA;
    if (value == "range")       return MILITARY_RANGE;
    if (value == "naval_base")  return MILITARY_NAVAL_BASE;
    return UNKNOWN;
}

int OsmStyle::placeTagType(const QString &value)
{
    if (value == "city")      return PLACE_CITY;
    if (value == "town")      return PLACE_TOWN;
    if (value == "village")   return PLACE_VILLAGE;
    if (value == "hamlet")    return PLACE_HAMLET;
    if (value == "suburb")    return PLACE_SUBURB;
    if (value == "locality")  return PLACE_LOCALITY;
    return UNKNOWN;
}

int OsmStyle::pisteTagType(const QString &value)
{
    if (value == "downhill") return PISTE_DOWNHILL_INTERMEDIATE;
    if (value == "nordic")   return PISTE_NORDIC;
    return UNKNOWN;
}

int OsmStyle::routeTagType(const QString &value)
{
    if (value == "ferry") return FERRY_ROUTE;
    if (value == "ski")   return PISTE_NORDIC;
    return UNKNOWN;
}

int OsmStyle::aerialwayTagType(const QString &value)
{
    if (value == "cable_car")  return LIFT_CABLE_CAR;
    if (value == "chair_lift") return LIFT_CHAIR;
    if (value == "drag_lift")  return LIFT_DRAG;
    return UNKNOWN;
}

bool OsmStyle::isArea(int tagType)
{
    switch (tagType) {
    case BUILDING:
    case LANDUSE_RESIDENTIAL:
    case LANDUSE_COMMERCIAL:
    case LANDUSE_INDUSTRIAL:
    case LANDUSE_FOREST:
    case LANDUSE_GRASS:
    case LANDUSE_MEADOW:
    case LANDUSE_RECREATION_GROUND:
    case LANDUSE_ALLOTMENTS:
    case LANDUSE_CEMETERY:
    case LANDUSE_ORCHARD:
    case LANDUSE_VINEYARD:
    case LANDUSE_FARMLAND:
    case NATURAL_WATER:
    case NATURAL_WOOD:
    case NATURAL_GRASSLAND:
    case NATURAL_SAND:
    case NATURAL_BEACH:
    case NATURAL_SCRUB:
    case NATURAL_HEATH:
    case NATURAL_WETLAND:
    case LEISURE_PARK:
    case LEISURE_GOLF_COURSE:
    case LEISURE_STADIUM:
    case LEISURE_WATER_PARK:
    case LEISURE_GARDEN:
    case HISTORIC_CASTLE:
    case HISTORIC_RUINS:
        return true;
    default:
        return false;
    }
}

bool OsmStyle::isWaterAreaTagType(int tagType)
{
    return tagType == NATURAL_WATER;
}

int OsmStyle::defaultLodMin(int tagType)
{
    switch (tagType) {
    // === Roads ===
    case HIGHWAY_MOTORWAY:
    case HIGHWAY_TRUNK:
        return LOD_COUNTRY;
    case HIGHWAY_PRIMARY:
    case HIGHWAY_SECONDARY:
        return LOD_PROVINCE;
    case HIGHWAY_TERTIARY:
    case HIGHWAY_RESIDENTIAL:
    case HIGHWAY_UNCLASSIFIED:
        return LOD_CITY;
    case HIGHWAY_SERVICE:
    case HIGHWAY_TRACK:
    case HIGHWAY_PATH:
    case HIGHWAY_FOOTWAY:
    case HIGHWAY_CYCLEWAY:
    case HIGHWAY_STEPS:
    case HIGHWAY_PEDESTRIAN:
    case HIGHWAY_LIVING_STREET:
        return LOD_TOWN;

    // === Railways ===
    case RAILWAY:
    case RAILWAY_LIGHT_RAIL:
    case RAILWAY_TRAM:
    case RAILWAY_SUBWAY:
    case RAILWAY_MONORAIL:
        return LOD_CITY;

    // === Waterways ===
    case WATERWAY_RIVER:
    case WATERWAY_CANAL:
        return LOD_PROVINCE;
    case WATERWAY:
    case WATERWAY_STREAM:
    case WATERWAY_DRAIN:
        return LOD_TOWN;

    // === Buildings/Land ===
    case BUILDING:
        return LOD_CITY;
    case NATURAL_WATER:
        return LOD_COUNTRY;
    case NATURAL_WOOD:
    case NATURAL_GRASSLAND:
        return LOD_PROVINCE;
    case BOUNDARY_ADMIN:
        return LOD_PROVINCE;

    // === POI tiered display (gradually visible by importance when scale > 1000) ===

    // --- Important landmarks/facilities: visible when ppd > 100000 (LOD_DETAIL) ---
    case PLACE_CITY:
    case POI_CITY:
    case PLACE_TOWN:
    case POI_TOWN:
    case PLACE_VILLAGE:
    case POI_VILLAGE:
    case AEROWAY_AERODROME:
    case POI_AIRPORT:
    case AMENITY_HOSPITAL:
    case POI_HOSPITAL:
    case AMENITY_FIRE_STATION:
    case AMENITY_POLICE:
    case AMENITY_UNIVERSITY:
    case AMENITY_SCHOOL:
    case AMENITY_PLACE_OF_WORSHIP:
    case AMENITY_CHURCH:
    case AMENITY_PHARMACY:
    case AMENITY_BANK:
    case AMENITY_TOWN_HALL:
    case AMENITY_PUBLIC_BUILDING:
    case AMENITY_POST_OFFICE:
    case AMENITY_LIBRARY:
    case AMENITY_ATM:
    case TOURISM_MUSEUM:
    case TOURISM_ATTRACTION:
    case POI_MUSEUM:
    case POI_ATTRACTION:
    case POI_BRIDGE:
    case POI_WATER_FEATURE:
    case POI_ISLAND:
    case POI_LAND_FEATURE:
    case POI_HIGHWAY_EXIT:
    case LEISURE_NATURE_RESERVE:
    case LEISURE_STADIUM:
    case PLACE_HAMLET:
        return LOD_DETAIL;

    // --- General POIs: visible when ppd > 500000 (LOD_POI_FULL) ---
    case AMENITY_RESTAURANT:
    case AMENITY_CAFE:
    case AMENITY_PUB:
    case AMENITY_BAR:
    case AMENITY_FUEL:
    case AMENITY_PARKING:
    case POI_FUEL:
    case POI_RESTAURANT:
    case POI_BAR:
    case POI_PARKING:
    case SHOP_SUPERMARKET:
    case SHOP_MALL:
    case SHOP_CONVENIENCE:
    case POI_SHOPPING:
    case TOURISM_HOTEL:
    case TOURISM_MOTEL:
    case TOURISM_HOSTEL:
    case TOURISM_GUESTHOUSE:
    case TOURISM_VIEWPOINT:
    case TOURISM_ZOO:
    case TOURISM_CAMP_SITE:
    case TOURISM_CARAVAN_SITE:
    case TOURISM_PICNIC_SITE:
    case TOURISM_THEME_PARK:
    case POI_HOTEL:
    case POI_CAMPSITE:
    case POI_PICNIC:
    case POI_MARINA:
    case POI_TOLL_BOOTH:
    case POI_CAPE:
    case LEISURE_PARK:
    case POI_PARK:
    case SHOP_CLOTHES:
    case SHOP_BAKERY:
    case SHOP_BUTCHER:
    case SHOP_GROCERY:
    case SHOP_HARDWARE:
    case SHOP_FURNITURE:
    case SHOP_BICYCLE:
    case SHOP_CAR:
    case SHOP_CAR_REPAIR:
    case LEISURE_GOLF_COURSE:
    case LEISURE_SPORTS_CENTRE:
    case LEISURE_PLAYGROUND:
    case LEISURE_PITCH:
    case LEISURE_MARINA:
    case LEISURE_WATER_PARK:
    case LEISURE_GARDEN:
    case LEISURE_COMMON:
    case HISTORIC_CASTLE:
    case HISTORIC_RUINS:
    case HISTORIC_MEMORIAL:
    case HISTORIC_MONUMENT:
    case HISTORIC_ARCHAEOLOGICAL_SITE:
    case SPORT_SOCCER:
    case SPORT_TENNIS:
    case SPORT_BASKETBALL:
    case SPORT_SWIMMING:
    case SPORT_BASEBALL:
    case PLACE_SUBURB:
    case PLACE_LOCALITY:
    case POWER_TOWER:
    case POWER_SUBSTATION:
    case POI_DEFAULT:
    default:
        return LOD_DETAIL;
    }
}

int OsmStyle::defaultLodMax(int tagType)
{
    Q_UNUSED(tagType);
    return 99;  // No upper limit; display start zoom is controlled by lodMin
}

// ---- PoiIconCache (SVG icon pre-render cache) ----