wiki:Fr:Help/Styles/MapCSSImplementation

Context Navigation

Autres langues:

Table des Matières

Structure générale
Sélecteurs
Modèles de rendu
Caractéristiques
Expressions d'évaluation
1. Exemples
Remarques sur la compatibilité
Requêtes Media (obsolètes)

Mise en œuvre de MapCSS

La mise en œuvre de MapCSS (en) de JOSM est utilisée pour les fonctionnalités :

Modèles de rendu de cartes
Règles de Validation, voir le vérificateur d'attributs MapCSS pour la partie spéciale réservée aux règles.
Fenêtre Rechercher

Pensez à installer le MapCSS Syntax Highlighter dans VS Code pour ajouter une mise en évidence visuelle de MapCSS paint et de la syntaxe du validateur.

Structure générale

Une feuille de style MapCSS comporte des règles de la forme suivante

selector {
    prop: value;
    /* ... */
    prop: value;
    /* and/or */
    set: class;
    set: .class;
    /* noter que les règles de validation n'utilisent pas les deux points après set */
}

L'algorithme pour trouver des styles (modèles) pour un objet donné est le suivant :

 - pour chaque règle :
     Si le sélecteur s'applique, définir les propriétés du bloc { }
 - analyser la liste finale des propriétés et générer des styles à partir d'elle

MapCSS utilise le format commentaire de CSS (/* ... */). Notez que lorsque vous commentez de grandes parties d'un fichier MapCSS, certaines constructions peuvent provoquer une fin inattendue du commentaire, par exemple :

/*
*[highway][name =~ /^R(\.|:)? .*/] { /* la fin de l'expression régulière définit la fin inattendue du commentaire */
        throwWarning: tr("foo");
}
*/

Sélecteurs

Les sélecteurs désignent les expressions de filtre d'une règle MapCSS. La règle n'est appliquée à un objet de la carte que si ses sélecteurs correspondent à l'objet.

Les sélecteurs de MapCSS sont différents de ceux du CSS standard pour le Web. MapCSS ne prend en charge qu'un sous-ensemble des sélecteurs CSS standard, mais les étend avec des sélecteurs supplémentaires requis pour les données OSM.

Quelques exemples simples :

/* appliqué aux chemins avec un attribut highway=residential */
way[highway=residential] {  /* les modèles */}

/* appliqués aux nouveaux chemins fermés sur le calque 1, à condition qu'ils aient les attributs amenity=parking et access=customers, 
 * et que le niveau de zoom soit compris entre 11 et 14. 
 */
way|z11-14[amenity=parking][access=customers]:closed:new::layer_1 {...}


area[amenity=parking][access=customers], area[amenity=parking][!access] {...}
relation[type=route][route=foot] > way::relation_underlay {..}

Les différents éléments (type-, zoom- ,sélecteur condition, pseudo classes, layer identifier, grouping et child combinator) sont expliqués ci-dessous.

Sélecteur de types

Selecteur

Description

Correspond à n'importe quel objet.

node, way, relation

Correspond aux objets osm du type donné.

area

Correspond à n'importe quelle zone, que le bord de la zone soit modélisé par un seul chemin ou par un ensemble de chemins reliés entre eux par une relation.

area[natural=beach] {...} 
/* ... est équivalent à ... */
way[natural=beach], relation[type=multipolygon][natural=beach] {...}

Notez que area sélectionne également les chemins non fermés, il peut donc être utile d'ajouter la pseudo-classe :closed. Le validateur JOSM émettra un avertissement pour les chemins non fermés qui ont un style de zone.

meta

Le sélecteur meta démarre une règle spéciale qui doit se trouver au début du fichier. Elle donne quelques informations générales sur la feuille de style. Tous les logiciels qui prennent en charge MapCSS devraient être en mesure d'analyser ces sections sans erreur. N'utilisez donc pas d'extensions syntaxiques exotiques dans cette partie..

meta {
    title: "Parking lanes";   /* titre affiché dans le menu */
    icon: "logo_16x16x8.png"; /* petite icône affichée dans le menu à côté du titre */
    version: "1.2";           /* la version du style */
    description: "...";       /* une ou deux phrases de description du style */
    author: "...";            /* le(s) auteur(s) du style */
    link: "https://...";      /* URL vers la page web du style */
    min-josm-version: 6789;   /* la version minimale de JOSM sur laquelle ce style fonctionne */
}

canvas

Certaines informations de style non spécifiques aux nœuds, aux chemins ou aux relations.

canvas {
    fill-color: #ffffea; /* l'ancienne couleur de fond est dépréciée depuis la r7110 */
    default-points: false;
    default-lines: false;
}

Clé	Description	Format des valeurs	Valeur par défaut
`fill-color`	Spécifie la couleur globale de remplissage/arrière-plan (`background-color` est déprécié depuis la r7110).	Color (nom de couleur)	`black`
`default-points`	Si le style de point par défaut doit être ajouté aux nœuds auxquels aucun style ne s'applique.	Boolean (Booléen)	`true`
`default-lines`	Si le style de ligne par défaut doit être ajouté aux chemins pour lesquels aucun style ne s'applique.	Boolean (Booléen)	`true`

Sélecteur enfant

Si un nœud fait partie d'un chemin, on dit qu'il est enfant de ce chemin. De même, si un nœud, un chemin, ou une relation est membre d'une relation, on dit qu'il est enfant de cette relation.

Dans MapCSS, vous pouvez utiliser un sélecteur enfant qui ne correspond que si l'objet parent et l'objet enfant correspondent.

Exemple:

/*
 * ne correspond que pour un chemin qui est un enfant d'une relation avec les attributs
 * type=route et route=foot
 */
relation[type=route][route=foot] > way {...}

Notes:

Le sélecteur de zoom et l'identifiant de calque ne sont pertinents que pour la partie à droite du signe >.
Les fonctions prop() et is_prop_set() ne sont supportées que sur la partie droite du signe >.
Les fonctions parent_tag et parent_tags (voir ci-dessous) peuvent être utilisées pour accéder aux tags du ou des parents.
Pour des raisons de compatibilité avec la norme MapCSS 0.2, la fonction relation[type=route][route=foot] chemin {/*...*/}, sans le signe supérieur > est également supportée. Toutefois, aucun Sélecteur de lien ne peut être spécifié dans ce cas.

Sélecteur parent

En plus des sélecteurs enfant, JOSM supporte la notion de sélecteur parent. Notez que les sélecteurs parent sont une extension de MapCSS spécifique à JOSM qui n'est pas présente dans les autres implémentations de MapCSS.

Tout comme le sélecteur enfant, le sélecteur parent ne correspond que si l'objet parent et l'objet enfant correspondent. Contrairement au sélecteur enfant, le caractère < est utilisé.

Contrairement au sélecteur enfant, l'objet parent sera "sélectionné". En d'autres termes, les propriétés du Bloc de Déclaration {{{...}}} s'appliquent à l'objet situé à droite du signe "<".

Exemple:

/*
 * correspond à un highway dont au moins un nœud est marqué comme traffic_calming=*
 */
node[traffic_calming] < way[highway] {...}

Sélecteur de condition

Les sélecteurs peuvent inclure un ensemble de conditions. Si l'une de ces conditions est évaluée à false, le sélecteur ne correspond pas et la règle de style n'est pas appliquée.

Une condition d'attribut spécifie une condition sur un des attributs d'un objet OSM.

Opérateur	Description	Exemple
`=`	Correspondance exacte de la valeur.	way[highway=residential] /* est sensible à la casse, c'est-à-dire qu'il ne correspond PAS, par exemple, à highway=Residential ou à Highway=residential / node[name="My name"] / utiliser des guillemets si la clé ou la valeur comporte des espaces / node["name:pl"="Królewiec"] / utiliser des guillemets si la clé ou la valeur comprend des caractères spéciaux comme des deux-points ou des caractères unicodes */
`!=`	Valeur non équivalente	way[highway!=residential] node[name!="My name"] node["name:pl"!="Królewiec"]
`<`, `>`, `<=`, `>=`	Comparaison pour les valeurs numériques.	node[population >= 50000] /* population supérieure ou égale à 50000 / node[ele = 3000] / altitude avec exactement 3000 mètres */
`^=`	Correspondance du préfixe	node[name ^= "myprefix"] /* la valeur commence par 'myprefix' */
`$=`	Correspondance du suffixe	node[name $= "mypostfix"] /* la valeur se termine par 'mypostfix' */
`*=`	Correspondance de sous-chaîne	node[name = "my substring"] / La valeur contient la sous-chaîne 'my substring' */
`~=`	Membre de liste	[vending~=stamps] / la valeur de l'attribut pour l'attribut 'vending' est une liste de valeurs séparées par des ; / / et l'une de ces valeurs est 'stamps' */
`=~`	Concordance avec une Expression régulière	[name=~/^My_pattern./] /* la valeur de l'attribut 'name' correspond à l'expression régulière '^My_pattern.' / /* Notez que les expressions régulières doivent être entourées de /.../ / La Concordance insensible à la casse peut être activée par l'expression drapeau intégrée `(?i)` (voir Pattern.CASE_INSENSITIVE). [name =~ /^(?i)(parking)$/] /* Concordance avec parking, Parking, PARKING, PaRkInG,... / [name =~ /^(?U)(\p{Lower})+$/] /* le nom est composé uniquement de caractères unicode minuscules */
`!~` (depuis la r6455)	Concordance négative de l'expression régulière	*[surface!~/paved\|unpaved/]
`∈` (Caractère Unicode U+2208, depuis la r6609)	élément de Concordance quand un objet correspondant au(x) sélecteur(s) de droite contient au moins un élément qui correspond au(x) sélecteur(s) de gauche.	*[amenity=parking] ∈ area[amenity=parking] { throwWarning: tr("{0} inside {1}", "amenity=parking", "amenity=parking"); } Trouve les zones avec `amenity=parking` qui contiennent au moins un nœud ou une zone avec `amenity=parking`. Depuis la r15064, cette règle produit un avertissement pour chaque élément à gauche lorsqu'il y a plusieurs correspondances.
`⊆` (Caractère Unicode U+2286, depuis la r15102)	Sous-ensemble de ou égal à Synonyme de `∈`.	*[amenity=parking] ⊆ area[amenity=parking] { throwWarning: tr("{0} inside {1}", "amenity=parking", "amenity=parking"); }
`⊇` (Caractère Unicode U+2287, depuis la r15102)	Combinaison supérieure ou égale à Concordance lorsqu'un objet correspond au(x) sélecteur(s) de droite et est contenu dans un ou plusieurs éléments qui correspondent aux sélecteurs de gauche.	area[amenity=parking] ⊇ *[amenity=parking] trouve les nœuds ou les zones avec `amenity=parking` à l'intérieur des zones avec `amenity=parking`. Plus lent que `⊆` et donc pas utile dans les règles du validateur, mais peut être utile dans le dialogue de recherche.
`⊈` (Caractère Unicode U+2288, depuis la r15102)	Ni un sous-ensemble de Ni égal à Concordance lorsqu'un objet correspond au(x) sélecteur(s) de droite et ne contient aucun élément correspondant aux sélecteurs de gauche.	*[highway=street_lamp] ⊈ area:closed2[amenity=parking][lit=yes] trouve les zones amenity=parking qui ont lit=yes mais qui ne contiennent pas de lampe. Ajoutez toujours `:closed2` pour éviter les faux positifs car les zones non fermées ne contiennent jamais quelque chose.
`⊉` (Caractère Unicode U+2289, depuis la r15102)	Ni un Sur-ensemble de ni égal à Concordances lorsqu'un objet correspond au(x) sélecteur(s) de droite et n'est pas contenu dans une zone correspondant aux sélecteurs de gauche.	area[landuse=residential] ⊉ *[building] trouve les bâtiments qui ne se trouvent pas dans une zone landuse=residential. Notez que cet opérateur est susceptible de produire des faux positifs lorsque vous avez des zones `landuse=residential`qui ne correspondent pas à `:closed2`.
`⧉` (Caractère Unicode U+29c9, depuis la r6613)	croisement	area:closed:areaStyle ⧉ area:closed:areaStyle { throwOther: tr("Overlapping Areas"); } prend en compte l'attribut `layer` si elle est définie (depuis r12986)

Depuis la r6554, il est possible de préfixer "value" (c'est-à-dire l'expression après l'opérateur) avec un * afin de la "déréférencer" c'est-à-dire la considérer comme une autre clé et obtenir sa valeur). Ainsi, [key1 = *key2] ou [key1=*key2] compare la valeur de key1 avec la valeur de key2, et [key =~ */pattern/] et [key =~ */pattern/] considère la valeur de la clé pattern comme une expression régulière et la compare avec la valeur de key.

En outre, vous pouvez tester si un attribut est présent ou non :

Condition	Exemple
Présence d'attribut	way[highway?] /* corresponds à n'importe quel chemin avec un attribut 'highway' (sensible à la casse) / way["name:fr"] / utilisez des guillemets si le nom de l'attribut comprend des caractères spéciaux (espaces blancs, deux-points, caractères unicode, etc.) */
Absence d'attribut	way[!highway] /* correspond à tout chemin qui n'a pas d'attribut 'highway' (sensible à la casse). / way[!"name:fr"] / utilisez des guillemets si le nom de l'attribut comprend des caractères spéciaux (espaces blancs, deux-points, caractères unicode, etc.) */
La présence d'un attribut par une expression régulière correspond (depuis r6547)	way[/^addr:/] /* correspond à toute clé `addr:` /
Absence de balise par correspondance d'expression régulière	way[!/^addr:/] /* correspond à tout chemin qui n'a pas de balise 'addr:'. /

Vous pouvez tester si la valeur d'une balise est une valeur de vérité logique. La valeur est évaluée à true, si elle est soit "oui", "vrai", ou "1". Toutes les autres valeurs sont interprétées comme étant fausses.

Condition

Exemple

Test de la valeur vraie

way[oneway?]                  /* correspond à n'importe quel chemin avec une valeur vraie dans l'attribut 'oneway'.  */

Test pour une valeur faux (depuis r6513)

way[oneway?!]                 /* correspond à n'importe quel chemin avec une valeur faux dans l'attribut 'oneway' */

Sélecteur de territoire

Vous pouvez tester si un objet est situé à l'intérieur ou à l'extérieur d'un territoire spécifique. JOSM dispose d'une base de données interne pour cela. Le fichier des territoires peut être téléchargé et il faut l'ouvrir dans JOSM pour l'examiner (aperçu de la capture d'écran). Il contient les frontières de tous les pays du monde. Pour des raisons de performance, les frontières sont simplifiées. Elles peuvent être affinées pour des cas particuliers sur demande. Les territoires ont pour "attribut" leurs codes ISO_3166-1_alpha-2. Les États-Unis, le Canada, la Chine, l'Inde et l'Australie ont des frontières supplémentaires pour leurs subdivisions. Consultez les exemples suivants pour savoir comment utiliser les sélecteurs de territoires. Les sélecteurs de territoire sont moins utiles dans les modèles de coloriage et peuvent être très lourds en ressources. Cependant, ils sont beaucoup plus utiles pour les règles de validation basées sur mapcss. Pour sélectionner les territoires dont la circulation est à gauche ou à droite, il existe un moyen plus simple, voir les Pseudo Classes. Voir #10387 pour l'implémentation principale de cette fonctionnalité.

                                      /* correspond à tout nœud situé …                             */
node[inside("FR")]                    /* … à l'intérieur de la France (y compris les territoires d'outre-mer) */
node[inside("FX")]                    /* … à l'intérieur de la France métropolitaine (c'est-à-dire seulement la    
                                         partie continentale avec ses îles proches incluant la Corse)   */
node[inside("EU")]                    /* … au sein de l'Union européenne                         */
node[inside("FR,DE")]                 /* … à l'intérieur de la France __OU__ à l'intérieur de l'Allemagne            */
node[inside("US-FL")]                 /* … à l'intérieur de l'État américain de la Floride                       */

node[outside("FR")]                   /* … hors de France                                    */
node[outside("FR,DE")]                /* … hors de France __ET__ hors d'Allemagne         */
node[inside("US")][outside("US-FL")]  /* … à l'intérieur des États-Unis, à l'exception de l'État de Floride           */

Sélecteur de lien

Dans un sélecteur d'enfant, vous pouvez formuler des conditions sur le lien entre un objet parent et un objet enfant.

Si le parent est une relation, vous pouvez formuler des conditions sur le role d'un objet membre dans cette relation.

relation[type=route] >[role="link"] way {  /* correspond à tout chemin membre de la relation route avec le rôle 'link' */ 
   color: blue;
}

Opérateur	Description	Exemple
`=`	Correspondance exacte du nom du rôle. Le nom `role` est obligatoire dans ce contexte.	relation >[role=residential] way relation >[role="My name"] way /* utiliser des guillemets si la valeur du rôle comprend des espaces ou d'autres caractères spéciaux */

Les opérateurs !=, ^=, $=, *=, et ~= sont également pris en charge. Veuillez vous référer aux conditions des opérateurs de sélection.

Les noeuds dans les chemins et les membres dans les relations sont ordonnés. Vous pouvez formuler des conditions sur la position d'un nœud dans un chemin ou d'un objet membre dans une relation. Les nombres positifs comptent du premier au dernier élément, les nombres négatifs (depuis r8236) comptent du dernier au premier élément.

relation[type=route] >[index=1] way {  /* correspond au premier chemin membre de la relation route  */ 
   color: blue;
}

way >[index=-1] node {  /* correspond au dernier nœud d'un chemin  */ 
   symbol-stroke-color: green;
}

way!:closed >[index=1] node!:connection,
way!:closed >[index=-1] node!:connection {  /* correspond à tous les nœuds extrémité d'un chemin unique */ 
   symbol-stroke-color: green;
}

Sélecteur de zoom

Vous pouvez agrémenter un sélecteur de type d'un sélecteur de zoom. Le sélecteur de zoom interdit l'utilisation de plusieurs niveaux de zoom auxquels la règle MapCSS correspondante est appliquée.

Exemple 1	Exemple 2	Exemple 3	Description
`way\|z12 {...}`	`node\|z12 {...}`	`node\|z12[...] {...}`	Au niveau de zoom 12
`way\|z13-15 {...}`	`node\|z13-15 {...}`	`way\|z13-15[...] {...}`	De 13 à 15
`way\|z16- {...}`	`node\|z16- {...}`	`node\|z16-[...] {...}`	16 et plus
`way\|z-12 {...}`	`node\|z-12 {...}`	`node\|z-12[...] {...}`	12 et moins
`way {...}`	`node{...}`	`way[...] {...}`	n'importe quel niveau de zoom

La définition précise des échelles pour chaque niveau de zoom peut changer à l'avenir. En règle générale, vous pouvez vous attendre à être approximativement au niveau de zoom n lorsque l'imagerie affiche des tuiles de carte glissante de niveau n.

Les pseudo-classes

Consultez la doc Java pour obtenir la liste actualisée des pseudo-classes prises en charge par l'implémentation MapCSS de JOSM.

Classe	Description
`:closed`	vrai pour les chemins dont le premier nœud est le même que le dernier et pour toute relation multipolygon (complètement téléchargée)
`:closed2`	même chose que ci-dessus, mais celle-ci ignore si un multipolygone est téléchargé complètement (depuis r9099)
`:completely_downloaded`	vrai pour une relation dont les membres sont tous téléchargés (depuis r9099)
`:new`	tous les nouveaux objets
`:connection`	vrai pour les nœuds utilisés par plus d'un chemin
`:unconnected`	vrai pour les nœuds qui ne sont utilisés par aucun chemin (depuis r6687)
`:tagged`	Ce que JOSM considère comme étiqueté, c'est-à-dire un objet qui a une clé d'attribut autre que les suivantes : `source`, `source_ref`, `note`, `comment`, `converted_by`, `created_by`, `watch`, `fixme`, `FIXME`, `description`, `attribution` (version r4008 ; dans cette liste `*` est global)
`:area-style`	vrai si l'objet a un style de zone
`:righthandtraffic`	vrai s'il y a une circulation à droite à l'emplacement actuel (depuis r7193) ; voir circulation à gauche ou à droite (en) pour obtenir une capture d'écran des zones
`:clockwise`	Si le chemin est fermé et orienté dans le sens des aiguilles d'une montre, ou non fermé et que le 1er, le 2e et le dernier nœud sont dans l'ordre des aiguilles d'une montre.
`:anticlockwise`	Si le chemin est fermé et orienté dans le sens inverse des aiguilles d'une montre, ou non fermé et que le 1er, le 2e et le dernier nœud sont dans l'ordre inverse des aiguilles d'une montre.
`:unclosed_multipolygon`	vrai pour les relations multipolygonales non fermées entièrement chargées (depuis r8252)
`:open_end`	pour sélectionner les nœuds d'extrémité des relations multipolygone non fermées avec `relation:unclosed_multipolygon >:open_end node` (depuis r8252)
`:in-downloaded-area`	vrai si un objet est dans la zone source et faux s'il est dans la zone hachurée (depuis r8495).
`:selected`	vrai si un objet est sélectionné dans l'éditeur (depuis r9341).
`:highlighted`	vrai si l'objet est en surbrillance.
`:modified`	objets modifiés et nouveaux (depuis r7193).

Vous pouvez aussi inverser les pseudo-classes. Par exemple, !:new pour tous les anciens objets.

Identifiant de calque

Les calques peuvent être utilisés pour créer plusieurs modèles pour un même objet. Voici un exemple :

way[highway=secondary] {
    width: 3;
    color: yellow;
}

way[highway=tertiary] {
    width: 2;
    color: orange;
}

way[access][access!=yes]::non_public_access_layer {
    width: +2;
    color:red;
    dashes: 2;
    object-z-index:-1.0;
}

way[bridge]::bridge_layer {
    width: +3;
    color:#000080;
    opacity:0.5;
    object-z-index:1.0;
}

Cela dessine toutes les routes secondaires et tertiaires respectivement en jaune et en orange. Toutes les routes avec un tag d'accès autre que yes auront un modèle de ligne supplémentaire en dessous (object-z-index:-1.0;) de la ligne principale. Si cette partie de la rue est un pont, elle sera également recouverte d'un bleu semi-transparent. La valeur de la largeur relative (width: +2;) fait référence à la largeur sur le calque par défaut (2 ou 3 dans ce cas).

Le nom du calque peut être n'importe quel identifiant.

Si vous omettez le calque dans le sélecteur, c'est la même chose que d'utiliser ::default.

Un exemple de plus :

node[amenity=parking] {
    icon-image: "presets/vehicle/parking/parking.svg";  /* affiche l'icône de parking (interne de josm) dans le calque par défaut */
    text: ref;                                          /* affiche la valeur de la clé ref sous forme de texte dans le calque par défaut */
}

node[amenity=parking][fee=yes]::fee {
    icon-image: "presets/money/exchange.svg";             /* affiche l'icône (interne à josm) pour les bureaux de change dans le calque des tarifs */
    icon-offset-x: 14;                                    /* décaler l'icône */
    icon-offset-y: -12;                                   /* décaler l'icône */
    text: charge;                                         /* affiche la valeur de la clé du coût sous forme de texte dans le calque des tarifs. */
    text-offset-x: 16;                                    /* décaler le texte */
    text-offset-y: 17;                                    /* décaler le texte */
}

Le résultat ressemble à ceci

En outre, vous pouvez utiliser le calque * pour remplacer et initialiser tous les calques.
Il remplace toutes les sous-parties existantes, donc

way::A { a; } 
way::B { b; } 
way::* { c; }  /* remplace toutes les sous-parties existantes */

est équivalent à

way::A { a; } 
way::B { b; } 
way::A { c; } /* remplace a par c dans toutes les sous-parties existantes */
way::B { c; } /* remplace b par c dans toutes les sous-parties existantes */

Et il initialise de nouvelles sous-parties. En d'autres termes :

way::* { a; } 
way::A { b; }

est équivalent à

way::A {} 
way::* { a; } 
way::A { b; }

qui à son tour est identique à

way::A { a; } 
way::A { b; }

ou à

way::A { a; b; }

Grouper

Les règles ayant un bloc de déclaration commun peuvent être regroupées en une seule :

area[landuse=forest] { color: green;   width: 2; }
area[natural=wood] { color: green;   width: 2; }

est identique à

area[landuse=forest], area[natural=wood] { color: green;   width: 2; }

Classes

Vous pouvez attribuer des classes aux éléments correspondants et définir d'autres sélecteurs à l'aide de ces classes :

/* attribution des classes */
selector {
  set class;
  /* ou de manière équivalente */
  set .class;
}

/* classes correspondantes */
way.class, node[foo=bar].class {
  /* ... */
}

Exemple d'attribution/de correspondance d'une classe nommée path :

way[highway=footway] { set path; color: #FF6644; width: 2; }
way[highway=path]    { set path; color: brown; width: 2; }
way.path { text:auto; text-color: green; text-position: line; text-offset: 5; }

Vous pouvez aussi utiliser la négation des classes. Par exemple, way !.path pour tous les chemins qui ne font pas partie de la classe .path.

Classes et calque ensemble

Si vous voulez utiliser le calque et les classes ensemble, veuillez noter que vous devez identifier la classe via is_prop_set.

node[railway=signal] { set sgnl; }

/* cela ne fonctionne pas */
node.sgnl::layer_signal_icon  { z-index: 1000; ... icon: icon/signal-icon.svg; ... }
node.sgnl::layer_signal_text  { z-index: 1010; ... text: concat("Nom du signal : ", tag("ref")); ..... )

/* utiliser à la place : is_prop_set("...", "default") */
node[is_prop_set("sgnl", "default")]::layer_signal_icon  { z-index: 1000; ... icon: icon/signal-icon.svg; ... }
node[is_prop_set("sgnl", "default")]::layer_signal_text  { z-index: 1010; ... text: concat("Nom du signal : ", tag("ref")); ..... )

Traitement Conditionnel @supports

Les règles @supports sont utilisées pour sauter une section du modèle dans certaines conditions. Typiquement, vous souhaitez utiliser une fonctionnalité introduite dans une version plus récente de JOSM, mais vous souhaitez avoir un modèle de repli pour les utilisateurs de clients JOSM plus anciens. Cette fonctionnalité est apparue avec la r8087. Exemple :

@supports (min-josm-version: 9789) {
    way[highway] {
        width: 4;
        color: orange;
    }
    /* nouveaux trucs fantaisistes */
    /* ... */
}

@supports (max-josm-version: 9788) {
    way[highway] {
        width: 4;
        color: blue;
    }
    /* mode de repli, en utilisant des fonctions plus simples */
    /* ... */
}

@supports (icon-offset-x) {
    /* seulement si la propriété icon-offset-x property est supportée */
    node[amenity] {
        icon-offset-x: 5;
    }
}

La syntaxe correspond étroitement à la syntaxe css (en) officielle. Les conditions suivantes sont prises en charge :

Condition	Description
(<mapcsskey>)	Vérifie si une certaine clé mapcss est supportée, par exemple `repeat-image` ou `icon-offset-x`.
(min-josm-version: <nombre>)	N'inclue la section `@supports` que lorsque la version actuelle de JOSM est supérieure ou égale au nombre spécifié.
(max-josm-version: <nombre>)	N'inclue la section `@supports` que lorsque la version actuelle de JOSM est inférieure ou égale au nombre spécifié.
(user-agent: <chaîne de caractères>)	N'inclue la section `@supports` que lorsque le nom de l'éditeur / restituteur correspond à la chaîne donnée. Dans JOSM, la seule valeur acceptée est `josm`.

Les conditions peuvent être combinées avec and :

@supports (min-josm-version: 8087) and (max-josm-version: 8200) {
 /* uniquement pour les versions 8087 à 8200 de JOSM */
}

D'autres opérateurs logiques comme or et not peuvent également être utilisés. Les parenthèses sont nécessaires si vous voulez combiner différents opérateurs logiques :

@supports ((min-josm-version: 8087) and (max-josm-version: 8200)) or (user-agent: myEditor) {
  /* pour les versions 8087 à 8200 de JOSM et pour l'éditeur appelé "myEditor" */
}

Étant donné que les règles @supports ne sont prises en charge qu'à partir de la version r8087 de JOSM, vous devez également spécifier cette version minimale de JOSM dans le méta-sélecteur :

meta {
    min-josm-version: "8087"; /* Ce modèle utilise les règles @supports */
    /* ... */
}

Modèles de rendu

Les paramètres des modèles sont utilisés pour fournir à l'utilisateur des paramètres pour personnaliser un modèle de coloriage. L'utilisateur peut les utiliser dans la fenêtre Coloriage. Les type de paramètres suivants sont disponibles :

boolean (voir r7450)
double (double) (depuis r15731, voir #10435)
string (chaîne de caractères) (depuis r15731, voir #10435)
color (couleur) (depuis r16843, voir #10435)

Paramètres de type `boolean`

Créez un paramètre de type boolean (booléen) :

setting::highway_casing {
  type: boolean;
  label: tr("Dessiner l'habillage du chemin");
  default: true;
}

Utilisez un paramètre de type boolean:

way[highway][setting("highway_casing")] {
  casing-width: 2;
  casing-color: white;
}

Paramètres de type `double`

Créez un paramètre de type double :

setting::place_font_size {
  type: double;
  label: tr("Définir la taille de la police du nom du lieu...");
  default: 11;
}

Utilisez un paramètre de type double:

node.place, way.place, area.place {
  font-size: setting("place_font_size");
}

Paramètres de type `string`

Créez un paramètre de type string (chaîne de caractères) :

setting::textdisplay {
  type: string;
  label: tr("clé utilisée pour l'affichage");
  default: "name"; /* examples for usage: alt_name, old_name, addr:housename, ref, operator, ... */
}

Utilisez un paramètre de type string:

way {
  text: tag(setting("textdisplay"));
}

Paramètres de type `color`

Créez un paramètre de type color. La couleur par défaut default peut être n'importe quelle couleur, comme indiqué dans les explications sur les valeurs des Propriétés :

setting::colordisplay {
  type: color;
  label: tr("kclé utilisée pour l'affichage");
  default: colorDisplayCustomPref#FF00FF;
}

Utilisez un paramètre de type color:

way {
  color: setting("colordisplay");
}

Paramètres de regroupement

Des paramètres similaires peuvent être regroupés en définissant des settings groups (groupes de paramètres) (depuis la r15289) :

settings::my_group {
  label: tr("mon merveilleux groupe");
  icon: "my_beautiful_icon";
}

L'étiquette est obligatoire, l'icône est facultative.

Une fois qu'un groupe de paramètres est défini, il peut être référencé à partir de tous les paramètres qui lui appartiennent :

setting::hide_icons {
  type: boolean;
  label: tr("Masquer les icônes en cas de faible zoom");
  default: true;
  group: "my_group";
}

Les groupes de paramètres sont affichés sous forme de sous-menus dans le menu des paramètres de style. Si au moins deux paramètres appartiennent à un groupe, un élément de menu spécial "Toggle all settings" (Permuter tous les paramètres) permet d'activer/désactiver rapidement tous les paramètres de ce groupe en une seule fois. Exemple d'utilisation : Modèle Cartographie avec IA) (en).

Caractéristiques

Caractéristiques générales

Clé	Description	Format des Valeurs	Valeur par Défaut
`z-index`	Précise l'ordre dans lequel les objets sont dessinés : Les objets avec un z-index plus élevé sont dessinés au-dessus des objets avec un z-index plus faible	Nombre (peut être négatif)	0
`major-z-index`	Similaire à `z-index`, mais il a une priorité plus élevée que `z-index`. Donc si un objet a un `major-z-index` plus élevé que l'autre, il est dessiné en haut. Si le `major-z-index` est le même, `z-index` décide.	Nombre (peut être négatif)	Dépend de l'élément du modèle : area (zone) : 1, casing (enveloppe) : 2, left-/right-casing (enveloppe gauche/droite) : 2.1, line-pattern (modèle de ligne) : 2.9, line (ligne) : 3, point : 4, default-point (point par défaut) : 4.1, line-text (texte de la ligne) : 4.9, point-text (texte du point) : 5
`object-z-index`	Similaire à `z-index`, mais avec une priorité inférieure. Contrôle l'ordre de coloriage pour les objets qui se chevauchent. Par exemple, pour deux chemins qui se croisent avec du texte : Utilisez `z-index` ou `major-z-index` si vous voulez d'abord dessiner les deux lignes et ensuite les deux légendes. Utilisez `object-z-index` si l'un des chemins doit être complètement au-dessus de l'autre.	Nombre (peut être négatif)	0
`modifier`	Meilleur contrôle, si un symbole de ligne/nœud par défaut est généré par JOSM. Cela se produit lorsqu'il n'y a pas de style approprié (`modifier=false`) trouvé sur une couche.	`false` ou `true`	`false` pour le calque par défaut et `true` pour tout autre calque

Notez que pour des raisons de performance, les valeurs des trois z-indexes sont limitées à des valeurs flottantes de 24 bits avec un maximum de 5 chiffres décimaux. Actuellement, le modèle de coloriage interne utilise des valeurs avec max. 2 chiffres avant et après le séparateur décimal. Pour éviter les problèmes, utilisez des valeurs z-indexes entre -99.999 et +99.999. (Voir aussi #14485)

Modèles d'icônes et de symboles

Clé	Description	Format des Valeurs	Valeur par Défaut
`icon-image`	L'icône à la position du nœud. Voir également Images.	Image	-
`icon-opacity`	Opacité de l'image de l'icône	Opacité	1.0
`icon-width`	Largeur de l'icône. Si une seule des propriétés `icon-width` et `icon-height` est donnée, l'image sera mise à l'échelle proportionnellement. Si ni la propriété `icon-width` ni la propriété `icon-height` ne sont définies, l'icône gardera sa taille originale.	Nombre	-
`icon-height`	Hauteur de l'icône. (Voir `icon-width`)	Nombre	-
`icon-offset-x`	Décale l'icône dans le sens horizontal (valeurs positives vers la droite) (depuis r8085)	Nombre	0
`icon-offset-y`	Décale l'icône dans la direction verticale (valeurs positives vers le bas) (depuis r8085)	Nombre	0
`icon-rotation`	Fait tourner l'icône dans le sens des aiguilles d'une montre ou dans le sens inverse (valeur négative)(depuis r8260)	`[rad]`, `[rad]rad`, `[deg]°`, `[deg]deg`, `[grad]grad`, `[turn]turn` (definition angles (en)) ou une direction cardinale (par exemple `northeast` (pour nord-est) ou `sw` (pour sud-ouest)); ou `way` pour faire pivoter l'icône dans la direction du chemin parent. Voir aussi les fonctions `degree_to_radians` et `cardinal_to_radians`. Depuis la version 18678, la fonction parent_way_angle() est une alternative à way : par exemple `way > node[...]::layer_x { ... icon-rotation: parent_way_angle(); ... }`	-
`icon-position`	Définit la position de l'icône pour les zones. Identique à `text-position` (depuis r11730).	`center` (centre), `inside` (à l'intérieur), `line` (ligne)	`center`
`symbol-shape`	Affiche un symbole à la position du nœud	`square` (carré), `circle` (cercle), `triangle` (triangle), `pentagon` (pentagone), `hexagon` (hexagone), `heptagon` (heptagone), `octagon` (octogone), `nonagon` (nonagone), `decagon` (décagone)	-
`symbol-size`	Taille du symbole	Nombre, peut être relative ("+4")	10
`symbol-stroke-width`	largeur du trait du contour	Width (contour)	1.0 si `symbol-stroke-color` est défini
`symbol-stroke-color`	couleur de la ligne	(Couleur)	`#FFC800` si `symbol-stroke-width` est défini
`symbol-stroke-opacity`	opacité de la ligne	Opacité	1.0
`symbol-fill-color`	couleur de remplissage de la forme	Couleur	`blue`, à moins que `symbol-stroke-width` ou `symbol-stroke-color` ne soit défini
`symbol-fill-opacity`	opacité du remplissage	Opacité	1.0
`text-...`, `font-...`	voir les Propriétés des textes et des polices en général

Ne vous fiez pas aux valeurs par défaut des propriétés symbol-... (sauf pour opacity). Elles sont destinées aux feuilles de style "rapides & grossières" et doivent être définies par une valeur explicite.

Modèles de lignes

Clé	Description	Format des Valeurs	Valeur par Défaut
`width`	Largeur de la ligne	Width (Largeur)	-
`color`	Couleur de la ligne	Color (Couleur)	valeur de `fill-color` ou (si elle n'est pas définie) la couleur non marquée par défaut de JOSM (`#808080`)
`opacity`	Transparence de la ligne.	Opacity (Opacité)	1.0
`dashes` (tirets)	Un tableau de longueurs alternées marche/arrêt	liste de nombres, par exemple : > 15, 5 peut s'écrire comme une expression : > `list(3, 4, 5, 6)` ou le mot clé `none` pour désactiver les tirets	-
`dashes-offset`	décaler le motif du tableau de tirets d'une certaine quantité	Nombre (>= 0)	0
`dashes-background-color`	La couleur à utiliser entre les tirets (facultatif)	Color	-
`dashes-background-opacity`	Valeur d'opacité pour le fond des tirets	Opacity	valeur de `opacity`
`linecap`	Forme au bout de ligne (voir ici)	`none`, `round`, `square`	`none`
`linejoin`	Forme aux angles de la ligne	`round`, `miter`, `bevel`	`round`
`miterlimit`	S'applique à `linejoin: miter`. Définit le dépassement maximum lorsque les segments de ligne se rencontrent avec un très petit angle	Nombre (>= 1.0)	10.0
`offset`	Déplace la ligne vers la gauche ou la droite (en regardant dans la direction du chemin). Cela peut servir à dessiner plusieurs voies pour un seul chemin ou à marquer différemment les côtés gauche et droit d'un chemin.	Nombre (Une valeur positive déplace la ligne vers la gauche, une valeur négative vers la droite)	0
`text-position`	défini comme `line`, si le texte doit être dessiné le long de la ligne	`line`, `center`	-
`text-...`, `font-...`	voir les Propriétés Générales du Texte & de la Police
`repeat-image`	image répétée le long d'une ligne (depuis r5801)	Image	-
`repeat-image-width`	Largeur de l'image (facultatif, voir `icon-width`) (depuis r5811)	Nombre	-
`repeat-image-height`	Hauteur de l'image (facultatif) (depuis r5811)	Nombre	-
`repeat-image-align`	Alignement de l'image. Le bord supérieur Top, inférieur bottom ou la ligne centrale center (horizontale) de l'image sera le long de la ligne (depuis r5801)	`top`, `center`, `bottom`	`center`
`repeat-image-offset`	Décalage par rapport à la ligne (depuis r5801)	Number	0
`repeat-image-spacing`	Espacement entre les images répétées (depuis r5801)	Number	0
`repeat-image-phase`	Espacement initial en début de ligne (depuis r5812)	Number	0
`repeat-image-opacity`	Opacité de l'image répétée (depuis r16700)	Number	1.0

Toutes ces propriétés (sauf text-... et font-...) existent aussi avec le préfixe casing- Le cadre est un deuxième élément de ligne indépendant, qui est dessiné sous la ligne normale et peut être utilisé pour dessiner un cadre fin autour de la ligne dans une autre couleur.

Clé	Description	Format des Valeurs	Valeur par Défaut
`casing-width`	Largeur de la bordure de part et d'autre de la ligne principale. Dans JOSM < 5214 : largeur totale du cadre	Width (inverse de `width` si la largeur relative est spécifiée)	-
`casing-color`	Couleur du cadre	Couleur	valeur de `fill-color` ou (si elle n'est pas définie) la couleur non marquée par défaut de JOSM (`#808080`)
`casing-opacity`	Transparence du cadre.	Opacité	1.0
`casing-`...	...	...	...

Comme pour casing-, il existe aussi le préfixe left-casing- et right-casing- Il dessine des lignes supplémentaires à gauche et à droite de la ligne principale.

Modèles des zones

Clé	Description	Format des Valeurs	Valeur par Défaut
`fill-color`	Couleur avec laquelle remplir la zone. Jusqu'à 11700, la composante alpha était fixée à 50 pour créer un effet de transparence.	Couleur	-
`fill-image`	Motif de l'image	Image	-
`fill-extent`	Définissez cette propriété pour dessiner uniquement le contour de la zone. Le nombre indique la distance à parcourir depuis le bord de la zone vers le centre. (Si elle n'est pas définie, la zone sera remplie complètement) (depuis r9008)	Nombre	-
`fill-extent-threshold`	Définissez cette propriété, pour dessiner la zone entière lorsque le pourcentage de couverture donné est atteint. Il peut être supérieur à 100 %, car la zone couverte est estimée comme *perimeter extent** (étendue du périmètre).	Nombre	-
`fill-opacity`	Degré de transparence du remplissage ; s'applique à la fois à la couleur et à l'image.	Opacité	0.2 (depuis r11700, 1.0 avant cela) (peut être modifié avec les préférences `mappaint.fillalpha` et `mappaint.fill-image-alpha`)
`text-position`	Définissez-le à `center` (centre), si le texte doit être dessiné au centre de la zone. Définissez-le à `inside` (intérieur) pour placer le texte complètement à l'intérieur de la zone. (depuis la r11722)	`line`, `center`, `inside`	-
`text-...`, `font-...`	voir les propriétés générales du texte & de la police

Propriétés requises pour créer un modèle de zone : fill-color ou fill-image

Propriétés du Texte & de la Police

Clé	Description	Format de la Valeur	Valeur par Défaut
`text`	Comment trouver le texte de l'étiquette. Aucune étiquette n'est affichée, sauf si cette instruction est présente.	`auto` Dérivez le texte automatiquement. Les attributs de nom par défaut sont : "`name:`"+<LANG>, "`name`", "`int_name`", "`ref`", "`operator`", "`brand`" et "`addr:housenumber`". Configurez une liste de noms d'attributs dans la préférence "`mappaint.nameOrder`" afin de modifier cette liste. (Après avoir modifié la liste, un redémarrage de JOSM est nécessaire.) String : Chaîne de caractères Indique la clé de l'attribut dont la valeur est utilisée comme texte. Expressions Vous pouvez saisir une expression pour obtenir le texte à afficher. Exemples : `eval("ceci est un texte statique")` - restitue un texte statique `eval(concat(tag("premier"), "-", tag("second")))` - affiche les attributs concaténés "premier" et "second" `""` Pour supprimer le texte d'un ensemble précédent.	-
`text-color`	la couleur du texte	Couleur	`white` (blanc) pour les lignes et les nœuds, `#c0c0c0` pour les zones (préférences des couleurs de "`text`" et de "`areatext`" de JOSM)
`text-opacity`	transparence du texte	Opacité	1.0
`text-offset-x`	décaler le texte horizontalement, (non supporté pour le texte le long de la ligne)	Nombre	0
`text-offset-y` (peut aussi s'écrire `text-offset`)	déplace le texte verticalement, les valeurs positives déplacent le texte vers le haut.	Nombre	0
`text-halo-radius`	taille de la bordure de l'arrière-plan du texte (pour rendre le texte visible sur un fond de couleur similaire)	Nombre	-
`text-halo-color`	couleur du halo du texte	Couleur	complément de la couleur du texte
`text-halo-opacity`	transparence pour le halo du texte.	Opacité	1.0
`text-anchor-horizontal`	positionnement horizontal des étiquettes de texte	`left`, `center`, `right`	`right`
`text-anchor-vertical`	positionnement vertical des étiquettes de texte	`above`, `top`, `center`, `bottom`, `below`	`bottom`
`text-rotation`	Rotation du texte dans le sens des aiguilles d'une montre ou dans le sens inverse (valeur négative) (depuis r16253)	`[rad]`, `[rad]rad`, `[deg]°`, `[deg]deg`, `[grad]grad`, `[turn]turn` (définition) ou une direction cardinale (par exemple, `northeast` (nord-est) ou `sw` (sud-ouest)) ; ou `way` pour faire pivoter le texte dans la direction du chemin parent. Voir aussi les fonctions `degree_to_radians`, `cardinal_to_radians`. Depuis la version 18678, la fonction parent_way_angle() est une alternative à way : par exemple : `way > node[...]::layer_x { ... text-rotation: parent_way_angle(); ... }` (Notez que la direction signifie l'orientation du bord supérieur du texte. Cela signifie qu'avec la direction par défaut du nord, le texte se dirige vers l'est (avec une langue de gauche à droite). Ainsi, si vous voulez le faire passer au sud, par exemple, vous devez définir l'est.)	-
`text-position`	voir Area styles and Line styles
`font-family`	font family	String	"Droid Sans" (JOSM preference "`mappaint.font`")
`font-size`	font size	Number	8 (JOSM preference "`mappaint.fontsize`")

`font-family`	famille de police	String Chaîne de caractères	"Droid Sans" ("mappaint.font" préférence JOSM)
`font-size`	taille de la police	Nombre	8 ("mappaint.fontsize" préférence JOSM)
`font-weight`	en gras ou non	`bold`, `normal`	`normal`
`font-style`	en italique ou non	`italic`, `normal`	`normal`

Propriétés définies par l'utilisateur

Dans les Modèles de rendu de cartes vous pouvez définir n'importe quelle propriété personnalisée, par ex : crc: CRC32_checksum(tag(name))/429496.7296;
Dans les Règles de Validation ils doivent être préfixés par un -, par ex : -osmoseItemClassLevel: "1210/1/1";

Explications sur les valeurs des propriétés

Width (Largeur)

14.0 (un nombre positif quelconque)
default (utilise la largeur de ligne par défaut de JOSM, qui est de 2, mais qui peut être modifiée)
thinnest (le plus fin : dessine la ligne la plus fine possible))
+3 ((avec le signe plus devant) ajoute le nombre à la largeur sur le calque par défaut. Cela ne s'applique qu'aux modèles qui ne se trouvent pas sur le calque par défaut, par exemple les surbrillances. Une autre façon d'écrire ceci serait prop("width","default")+3. Pour casing-width, cela fait référence à la valeur width sur le même calque.

Image

Voir Images.

Color (Couleur)

la couleur est nommée comme dans cette liste (en)
style html : #RRGGBB, #RGB, #RRGGBBAA
rgb(/*r*/, /*g*/, /*b*/) - valeur rgb avec des arguments de 0.0 à 1.0
rgba(/*r*/, /*g*/, /*b*/, /*alpha*/) - valeur rgb avec alpha
hsb_color(/*hue*/, /*saturation*/, /*brightness*/) - couleur de l'espace couleur HSB
si la couleur est préfixée par un nom et un #, par exemple color: highway_track#6e541c; elle apparaîtra dans les Préférences couleurs et les utilisateurs finaux pourront ajuster la couleur eux-mêmes

Opacity (Opacité)

de 0.0 (transparent) à 1.0 (opaque)

String (Chaîne de caractères)

toute séquence de caractères, entre guillemets, par exemple "images/fill.png". Si la chaîne est un identifiant, les guillemets sont facultatifs. (Les guillemets et le signe backslash peuvent être échappés.)

Number (Nombre)

nombre entier ou à virgule flottante (sous forme simple, par exemple 0.3). En général, il peut être négatif, mais la plupart des propriétés ne prennent pas en charge les nombres négatifs.
il a une signification particulière si vous mettez un signe "+" devant (largeur relative)

Expressions d'évaluation

Voir la doc de fonctions Java pour la liste actualisée des fonctions prises en charge par l'implémentation MapCSS de JOSM.

+, -, *, /: les opérations arithmétiques
||, &&, !: les opérations booléennes
<, >, <=, >=, ==, !=: les opérateurs de comparaison
asin, atan, atan2, ceil, cos, cosh, exp, floor, log, max, min, mod (since r17759), random, round, signum, sin, sinh, sqrt, tan, tanh: la signification habituelle, details (en)
cond(b, fst, snd)
b ? fst : snd: si (b) alors fst sinon snd
list(a, b, ...): créer une liste de valeurs, par exemple pour la propriété dashes
get(lst, n): récupérer le nième élément de la liste lst (le décompte commence à 0) (depuis r5699)
split(sep, str): divise la chaîne str aux occurrences de la chaîne séparatrice sep, renvoie une liste (depuis r5699)
prop(p_name): valeur de la propriété p_name du calque courant, par exemple prop("width")
prop(p_name, layer_name): propriété du calque layer_name
is_prop_set(p_name): vrai, si la propriété p_name est définie pour le calque courant
is_prop_set(p_name, layer_name): vrai, si la propriété p_name est définie pour le calque layer_name
tag(key_name): récupérer la valeur de la clé key_name de l'objet en question
parent_tag(key_name): récupérer la valeur de la clé key_name du parent de l'objet
parent_tags(key_name): renvoie toutes les valeurs des parents pour la clé key_name sous forme de liste ordonnée par un ordre naturel (depuis r8775)
has_tag_key(key_name): vrai, si l'objet a un attribut avec la clé donnée
rgb(r, g, b): créer une valeur de couleur (arguments de 0.0 à 1.0)
hsb_color(h, s, b): créer une couleur à partir de la teinte, de la saturation et de la luminosité (arguments de 0.0 à 1.0) (depuis r6899)
red(clr), green(clr), blue(clr): obtenir la valeur des canaux de couleur dans le modèle de couleur rgb
alpha(clr): obtenir la valeur alpha de la couleur donnée (depuis r6749)
length(str): longueur d'une chaîne de caractères
count(lst): longueur d'une liste, c'est-à-dire qu'elle compte le nombre de ses éléments (depuis r7162)
length(lst): longueur d'une liste (depuis r5699) – dépréciée depuis r7162
any(obj1, obj2, ...): renvoie le premier objet qui n'est pas nul (anciennement coalescence, (depuis r7164))
concat(str1, str2, ...): assembler les chaînes de caractères en une seule
join(sep, str1, str2, ...): joindre des chaînes de caractères, avec sep comme séparateur (depuis r6737)
join_list(sep, list_name): joint les éléments de la liste list_name à une chaîne de caractères séparée par le séparateur sep (depuis r8775)
upper(str): convertit la chaîne de caractères en majuscules (depuis r11756)
lower(str): convertit la chaîne de caractères en minuscules (depuis r11756)
title(str): convertit la chaîne de caractères en casse-titre (depuis r17613] ("i am FINE" → "I Am Fine")
trim(str): supprime les espaces en tête et en queue de chaîne de caractères (depuis r11756)
trim_list(list_name): supprime les espaces en tête et en queue d'une liste de chaînes de caractères, supprime ensuite les entrées qui sont vides (depuis r15591)
JOSM_search("..."): vrai, si la recherche JOSM s'applique à l'objet.
tr(str, arg0, arg1, ...): traduire de l'anglais vers la langue courante (uniquement pour les chaînes de l'interface utilisateur de JOSM) (depuis r6506)
regexp_test(regexp, string): test si la string correspond au modèle regexp (depuis r5699)
regexp_test(regexp, string, flags): tester si string correspond au schéma regexp; flags est une chaîne qui peut contenir "i" (insensible à la casse), "m" (multiligne) et "s" ("dot all" tout point) (depuis r5699)
regexp_match(regexp, string): Tente de faire correspondre string au schéma regexp. Renvoie une liste de groupes de capture en cas de succès. Le premier élément (index 0) est la correspondance complète (c'est-à-dire string). Les éléments suivants correspondent aux parties entre crochets de l'expression régulière. (depuis r5701)
regexp_match(regexp, string, flags): Tente de faire correspondre string au schéma regexp. Renvoie une liste de groupes de capture en cas de succès. Le premier élément (index 0) est la correspondance complète (c'est-à-dire string). Les éléments suivants correspondent aux parties entre crochets de l'expression régulière. Flags est une chaîne qui peut contenir "i" (insensible à la casse), "m" (multiligne) et "s" ("dot all" tout point) (depuis r5701)
substring(str, idx): retourne la sous-chaîne de str, à partir de l'index idx (0-indexed indexation 0) (depuis r6534)
substring(str, start, end): retourne la sous-chaîne de str, à partir de l'index start (inclus) jusqu'à end (exclus) (0-indexed) (depuis r6534)
replace(string, old, new): Remplace toute occurrence de la sous-chaîne old dans la chaîne string par le texte new
osm_id(): renvoie l'identifiant OSM de l'objet actuel (depuis r5699)
osm_user_name(): renvoie le nom de l'utilisateur OSM qui a touché l'objet en question en dernier. (depuis r15246)
osm_user_id(): renvoie l'identifiant de l'utilisateur OSM qui a touché l'objet en question en dernier (depuis r15246)
osm_version(): renvoie le numéro de version OSM de l'objet courant (depuis r15246)
osm_changeset_id(): renvoie l'identifiant du groupe de modifications dans lequel l'objet actuel a été envoyé en dernier (depuis r15246)
osm_timestamp(): renvoie l'heure de la dernière modification de l'objet courant, sous forme d'horodatage (depuis r15246)
parent_osm_id(): renvoie l'identifiant OSM du parent de l'objet (correspondant au sélecteur enfant) (depuis r13094)
URL_encode(str): encodage-pourcent une chaîne de caractères. Peut être utile pour les URL de données (depuis r6805)
URL_decode(str): encodage-pourcent une chaîne de caractères. (depuis r11756)
XML_encode(str): caractères spéciaux d'échappement dans le xml. Par exemple < devient <, autres caractères speciaux : >, ", ', &, \n, \t et \r (depuis r6809)
CRC32_checksum(str): calcule la somme de contrôle CRC32 d'une chaîne de caractères (le résultat est un entier de 0 à 2³²-1) (depuis r6908)
is_right_hand_traffic(): Vérifie si la circulation se fait à gauche ou à droite à l'endroit où vous vous trouvez. (depuis r7193)
number_of_tags(): renvoie le nombre d'attributs pour l'objet OSM actuel (depuis r7237)
print(o): imprime une représentation en chaîne de o sur la ligne de commande (pour le débogage) (depuis r7237)
println(o): imprime une représentation en chaîne de o sur la ligne de commande, suivie d'une nouvelle ligne (pour le débogage) (depuis r7237)
JOSM_pref(key, default): Tirez parti des paramètres avancés de JOSM. Cette manière vous permet d'offrir certaines options à l'utilisateur et de rendre le modèle personnalisable.
(Elle fonctionne avec les chaînes de caractères, les nombres, les couleurs et les valeurs booléennes. (Cette fonction existe depuis la version r3856, mais avec quelques interdictions. JOSM_pref renvoie toujours une chaîne, mais dans les versions r7237 et antérieures, la conversion automatique de la chaîne en booléen et en couleur ne fonctionnait pas. Vous pouvez utiliser les solutions de contournement suivantes pour les valeurs booléennes et les couleurs dans les versions r7237 et antérieures : cond(JOSM_pref("myprefkey", "true")="true", "X", "O") et html2color(JOSM_pref("mycolor", "#FF345611")). Ces conversions explicites ne devraient plus être nécessaires à partir de la version r7238. La conversion automatique en nombre fonctionne dans toutes les versions. En outre, dans la version r16590, peut être utilisé pour définir les propriétés de couleur. Ainsi * { set_color: JOSM_pref("pref", #000000); } créera maintenant une propriété de couleur.)
setting(): pour utiliser un paramètre de modèle (depuis r7450)
degree_to_radians(): renvoie en radians, une direction donnée en degrés (depuis r8260)
cardinal_to_radians(): renvoie une direction cardinale en radians (depuis r8260)
waylength(): renvoie la longueur du chemin en mètres (depuis r8253)
areasize(): renvoie la surface d'un chemin fermé en mètres carrés. (depuis r8253)
at(lat,lon): retourne vrai si le centroïde de l'objet se trouve aux coordonnées lat/lon données, par exemple pour vérifier les nœuds à "null island" node[at(0.0,0.0)] (depuis r12514)
is_similar(str1, str2): renvoie vrai si les deux chaînes de caractères sont similaires, mais pas identiques, c'est-à-dire si elles ont une distance de Levenshtein de 1 ou 2. Exemple : chemin[autoroute][nom][is_similar(tag(name), "Main Street")] : way[highway][name][is_similar(tag(name), "Main Street")] vérifie les rues avec une éventuelle faute de frappe dans le nom (par exemple Main Streeg). (depuis r14371)
gpx_distance(): renvoie la distance la plus faible entre l'objet OSM et un point GPX (depuis r14802)
count_roles(): renvoie le nombre de primitives dans une relation avec les rôles spécifiés (depuis r15275]
sort(str1, str2, str3, ...): trie un tableau de chaînes de caractères (depuis r15279)
sort_list(): trie une liste de chaînes de caractères (depuis r15279)
tag_regex(regex): renvoie une liste de valeurs qui correspondent à regex (expression rationnelle) (depuis r15317)
to_boolean(str): renvoie l'argument chaîne de caractères comme un booléen (depuis r16110)
to_byte(str): renvoie l'argument chaîne de caractères sous forme d'octet (depuis r16110)
to_short(str): retourne l'argument chaîne de caractères comme un short (entier court) (depuis r16110)
to_int(str): retourne l'argument chaîne de caractères comme un int (entier) (depuis r16110)
to_long(str): retourne l'argument chaîne de caractères comme un long (entier long ) (depuis r16110)
to_float(str): renvoie l'argument de la chaîne de caractères sous la forme d'un float (nombre a virgule flottante) (depuis r16110)
to_double(str): retourne l'argument chaîne de caractères comme un double (depuis r16110)
uniq(str1, str2, str3, ...): renvoie une liste de chaînes de caractères qui n'ont que des valeurs uniques à partir d'un tableau de chaînes de caractères (depuis r15323)
uniq_list(): renvoie une liste de chaînes de caractères qui n'ont que des valeurs uniques à partir d'une liste de chaînes de caractères (depuis r15353)
parent_way_angle(): renvoie l'angle de la voie parente sous la forme d'un double en rad [depuis r18678] (voir : text-rotation ou icon-rotation)
convert_primitive_to_string(PrimitiveId): renvoie l'identifiant de la primitive sous forme de chaîne de caractères [depuis r18829]
convert_primitives_to_string(PrimitiveId, PrimitiveId, ...): renvoie une liste d'identifiants de primitives convertis en chaînes de caractères [depuis r18829]
parent_osm_primitives(optional key, optional value): renvoie une liste d'identifiants de primitives qui correspondent à la clé et à la valeur (si elles sont présentes) [depuis r18829]

Exemples

symbole en forme de cercle pour le numéro de maison dont la taille dépend du nombre de chiffres

node[addr:housenumber] { 
    symbol-shape: circle;
    symbol-size: eval((min(length(tag("addr:housenumber")), 3) * 5) + 3);
    symbol-fill-color: #B0E0E6;

    text: "addr:housenumber";
    text-anchor-horizontal: center;
    text-anchor-vertical: center;
    text-offset-x: -1;
    text-offset-y: -1; }
    
node[addr:housenumber]::hn_casing { 
    z-index: -100;
    symbol-shape: circle;
    symbol-size: +2;
    symbol-fill-color: blue;
}

inversion des couleurs

*::* {
    color: eval(rgb(1 - red(prop(color)), 1 - green(prop(color)), 1 - blue(prop(color))));
    fill-color: eval(rgb(1 - red(prop(fill-color)), 1 - green(prop(fill-color)), 1 - blue(prop(fill-color))));
}

trucs aléatoires

way {
    width: eval(random() * 20);
    color: eval(rgb(random(), random(), random()));
}

Exemple de correspondance regexp : remplacer "nameXXXsubname" par "name::subname"

*[name=~/.+XXX.+/] 
{
    _match: regexp_match("(.+?)XXX(.+)", tag("name"));
    text: concat(get(prop("_match"),1), "::", get(prop("_match"),2));
}

colorier différemment les bâtiments en fonction de la rue dans les atributs d'adresse

area[building][addr:street] {
    fill-color: hsb_color(CRC32_checksum(tag("addr:street"))/4294967296.0, 0.9, 0.7);
    fill-opacity: 0.8;
}

enveloppe à l'intérieur de la zone

area[building]:clockwise {
    right-casing-width: 10;
}
area[building]:anticlockwise {
    left-casing-width: 10;
}
/* ou */
area[building][is_clockwise()] {
    right-casing-width: 10;
}
area[building][is_anticlockwise()] {
    left-casing-width: 10;
}

sélecteur insensible à la casse. Ce qui correspond à Name=Main Street, mais aussi à naMe=MAIN STREET
```
way[/(?i)^name$/ =~ /(?i)^Main Street$/] {
}
```

Remarques sur la compatibilité

MapCSS 0.2

Grammaire

way[oneway=yes] ne fait pas de magie, vous pouvez utiliser way[oneway?] instead
pas de @import
JOSM n'exige pas que eval(...) soit entouré d'expressions, mais pour des raisons de compatibilité avec d'autres implémentations de MapCSS, vous devriez l'écrire.

Propriétés

Pour le moment, JOSM ne prend pas en charge les propriétés suivantes :

line:: image
label:: font-variant, text-decoration, text-transform, max-width
shield:: non pris en charge

Halcyon (Potlatch 2)

L'étiquette de texte est placée au centre de l'icône. Pour la compatibilité avec Halcyon, mettez
```
node { text-anchor-vertical: center; text-anchor-horizontal: center; }
```
au début de votre feuille de style.
le standard de z-index dans Halcyon est 5, mais 0 dans JOSM
image: circle; correspond à symbol-shape: circle;

Kothic

Kothic supporte l'eval, qui diffère probablement de l'eval de JOSM.
Kothic connaît les unités, alors que JOSM calcule toujours en pixel.
Les fonctions d'extrusion ne sont pas disponibles dans JOSM.

Ceyx

semble avoir [tunnel=1] au lieu de [tunnel=yes] (Halcyon) ou [tunnel?] (JOSM)

Requêtes Media (obsolètes)

Note : Les requêtes media sont dépréciées. Vous devez utiliser les règles @supports à la place (voir ci-dessus).

Les requêtes media sont utilisées pour sauter une section du modèle dans certaines conditions. En général, vous souhaitez utiliser une fonctionnalité introduite dans une version plus récente de JOSM, mais vous souhaitez disposer d'un style de repli pour les utilisateurs de clients JOSM plus anciens. Cette fonctionnalité est apparue avec la r6970. Exemple :

@media (min-josm-version: 9789) {
    way[highway] {
        width: 4;
        color: orange;
    }
    /* nouveaux trucs fantaisistes */
    /* ... */
}

@media (max-josm-version: 9788) {
    way[highway] {
        width: 4;
        color: blue;
    }
    /* mode de repli, en utilisant des fonctions plus simples */
    /* ... */
}