OSGeoLive/openlayers_quickstart — French @ OSGeo Weblate: The most used raster layers are the tiled layers, provided …

Translation

English

French

Needs editing

Skip

	English	French	Actions
	Source	Source
	Each layer has a source, which knows how to load the layer content. In the case of vector layers, its source reads vector data using a format class (for example GeoJSON or KML) and provides the layer with a set of features.	Chaque couche a une source, qui sait charger le contenu de la couche. Dans le cas des couches vectorielles, sa source lit les données vectorielles à l’aide d’une classe format (par exemple GeoJSON ou KML) et fournit à la couche un ensemble d'entités.
	Features	Features
	Features represent real world things and can be rendered using different geometries (like point, line or polygon) using a given style, which determines its look (line thinkness, fill color, etc).	Les Features (entités) représentent des choses du monde réel et peuvent être rendues à l’aide de différentes géométries (comme le point, la ligne ou le polygone) à l’aide d’un style, qui détermine son apparence (épaisseur de ligne, couleur de remplissage, etc.).
	Create a basic map	Créer une carte de base
	Create a file in e.g. /home/user/ called basic-map.html , and copy the following content into the file.	Créez un fichier dans par exemple /home/user/ appelé basic-map.html , et copiez le contenu suivant dans le fichier.
	Now try opening basic-map.html from a web browser using File->Open File. You should see the following:	Essayez maintenant d’ouvrir la carte de base.html à partir d’un navigateur Web à l’aide de `File->Open File`. Vous devriez voir ce qui suit :
	Note:	Notez :
	The code follows the best practice of loading JavaScipt code at the end of the html file.	Le code suit la bonne pratique de chargement du code JavaScript à la fin du fichier html.
	An OpenLayers map needs to be attached to a HTML DOM element, so we have created a ``<div>`` element identified by the map id.	Une carte OpenLayers doit être attachée à un élément du DOM HTML, nous avons donc créé un `̀`<div>`̀` élément identifié par l’identifiant map.
	Maps are represented by the ``ol.Map`` class. We specify the DOM element to render the map into using the target property.	Les cartes sont représentées par la classe ``ol.Map``. Nous spécifions l’élément DOM pour rendre la carte en utilisant la propriété target.
	OpenLayers allows map rendering using two different mechanisms: Canvas and WebGL. The default renderer is canvas.	OpenLayers permet le rendu des cartes à l’aide de deux mécanismes différents : Canvas et WebGL. Le renderer par défaut est canvas.
	A map shows data contained within layers, so we have created a tiled layer, represented by the ``ol.layer.Tile`` class, that loads content from the OpenStreetMap project, using the ``ol.source.OSM`` source class.	Une carte montre les données contenues dans les couches, nous avons donc créé une couche tuilée, représentée par la classe ``ol.layer.Tile`` qui charge du contenu du projet OpenStreetMap, en utilisant la classe source ``ol.source.OSM``.
	Finally, we set the initial position of the camera using the ``ol.View`` class, set the initial zoom level and center location.	Enfin, nous définissons la position initiale de la caméra* à l’aide de la classe ``ol.View``, définissons le niveau de zoom initial et l’emplacement central.
	Add raster layers	Ajouter des couches raster
	The most used raster layers are the tiled layers, provided by the likes of OpenStreetMap, Stamen, Bing, etc. Tiled layers are represented by the ``ol.layer.Tile`` class and must use a source that knows how to load tiles from a given provider, like ``ol.source.OSM`` or ``ol.source.Stamen``:	Les couches raster les plus utilisées sont les couches tuilées, fournies par des organisations comme OpenStreetMap, Stamen, Bing, etc. Les couches tuilées sont représentées par la classe ``ol.layer.Tile`` et doivent utiliser une source qui sait charger les tuiles d’un fournisseur donné, comme ``ol.source.OSM`` ou ``ol.source.Stamen``:
	Layers can be added to the map in two ways:	Les couches peuvent être ajoutées à la carte de deux façons :
	When constructing the ``ol.Map``, use the ``layers`` property:	Lors de la construction de ``ol.Map``, utilisez la propriété ``layers`` :
	Add them manually with the ``map.addLayer()`` method:	Ajoutez-les manuellement avec la méthode ``map.addLayer()`` :
	Add vector layers	Ajouter des couches vectorielles
	Vector layers are represented by the ``ol.layer.Vector`` class and must use a source suitable for reading the vector format, like ``ol.source.GeoJSON``, ``ol.source.KML`` or ``ol.source.TopoJSON``.	Les couches vectorielles sont représentées par la classe ``ol.layer.Vector`` et doivent utiliser une source appropriée pour lire le format vectoriel, comme ``ol.source.GeoJSON``, ``ol.source.KML`` ou ``ol.source.TopoJSON``.
	Note, in the previous code we must change the ``url_to_file`` to point to a valid GeoJSON file placed in our server. Note that Javascript security will prevent sourcing of datasets from an external URL on a different domain / port (a.k.a. same-origin policy).	Notez que dans le code précédent, nous devons modifier le ``url_to_file`` pour pointer vers un fichier GeoJSON valide placé dans notre serveur. Notez que la sécurité Javascript empêchera l’approvisionnement des ensembles de données à partir d’une URL externe sur un domaine /port différent (par exemple, la politique de même origine).
	Features can also be created manually. In this case we need to create a geometry that represents the feature:	Les entités peuvent également être créées manuellement. Dans ce cas, nous devons créer une géométrie qui représente l'entité :
	Apply style to features	Appliquer le style aux entités
	Features within vector layers can be styled. The style is determined by a combination of fill, stroke, text and image, which are all optional. In addition, a style can be applied to a layer, which determines the style of all contained features, or to an individual feature.	Les entités dans les couches vectorielles peuvent être stylisées. Le style est déterminé par une combinaison de remplissage, trait, texte et image, qui sont tous facultatifs. En outre, un style peut être appliqué à une couche, qui détermine le style de toutes les entités contenues, ou à une entité individuelle.
	A style is represented by the ``ol.style.Style`` class which has properties to set the ``fill``, ``stroke``, ``text`` and ``image`` to be applied. The next example shows the World's administrative limits dataset styled to use a green fill and stroke:	Un style est représenté par la classe``ol.style.Style`` qui a des propriétés pour définir les ``fill``, ``stroke``, ``text`` et ``image`` à appliquer. L’exemple suivant montre les limites administratives du jeu de données mondial avec un style utilisant un remplissage et contour verts :
	In the code, we have loaded a TopoJSON file and styled it through the ``style`` property. We have set a ``fill`` and ``stroke``, required for lines and polygons, and an ``image`` (in this case a circle) used for point features.	Dans le code, nous avons chargé un fichier TopoJSON et l’avons coiffé à travers la propriété ``style`. Nous avons défini un ``fill`` et ``stroke``, nécessaire pour les lignes et les polygones, et une ``image`` (dans ce cas un cercle) utilisé pour les entités ponctuelles.
	Work with events	Travailler avec les événements
	Most of the components, like map, layers or controls, trigger events to notify changes. For example we can be notified each time the mouse is moved over the map, or when a feature is added to a vector layer, etc.	La plupart des composants, comme ``map``, ``layers`` ou ``controls``, déclenchent des événements pour notifier les modifications. Par exemple, nous pouvons être avertis chaque fois que la souris est déplacée sur la carte, ou lorsqu’une entité est ajoutée à une couche vectorielle, etc.
	Events can be easily registered on an object with the ``on()`` method and unregistered with ``un()``.	Les événements peuvent être facilement enregistrés sur un objet avec la méthode ``on()`` et non enregistrés avec ``un()``.
	The following code registers an event on a map instance, and will be notified each time the pointer is moved. Within the callback function we obtain the pointer coordinates and print in the browser console in two different projections.	Le code suivant enregistre un événement sur une instance de ``map`` et sera notifié chaque fois que le pointeur est déplacé. Dans la fonction de rappel, nous obtenons les coordonnées du pointeur et les imprimons dans la console de navigateur dans deux projections différentes.