Index: trunk/workshop-routing-foss4g/docs/chapters/geoext_client.rst
===================================================================
--- trunk/workshop-routing-foss4g/chapters/geoext_client.rst	(revision 63)
+++ trunk/workshop-routing-foss4g/docs/chapters/geoext_client.rst	(revision 76)
@@ -1,43 +1,32 @@
 ==============================================================================================================
-GeoExt Browser Client
+Client en GeoExt
 ==============================================================================================================
 
-`GeoExt <http://www.geoext.org/>`_ is a *JavaScript Toolkit for Rich Web Mapping Applications*. GeoExt
-brings together the geospatial know how of `OpenLayers <http://www.openlayers.org>`_ with
-the user interface savvy of `Ext JS <http://www.sencha.com>`_ to help you build powerful desktop
-style GIS apps on the web with JavaScript.
-
-Let's start with a simple GeoExt example and extend it with routing functionality then:
+`GeoExt <http://www.geoext.org/>`_ est une librairie JavaScript pour le dÃ©veloppement d'applications internet avancÃ©es. GeoExt rassemble les capacitÃ©s d'`OpenLayers <http://www.openlayers.org>`_ avec l'interface utilsiateur savvy de `Ext JS <http://www.sencha.com>`_ pour aider au dÃ©veloppement d'applications similaires Ã  des applications bureautiques.
+
+CommenÃ§ons avec un exemple simple d'utilisation de GeoExt et ajoutons-y les fonctionalitÃ©s de routage :
 
 .. literalinclude:: ../../web/routing-0.html
 	:language: html
 
-In the header we include all the javascript and css needed for the application,
-we also define a function to be run when the page is loaded (Ext.onReady).
-
-This function creates a `GeoExt.MapPanel
-<http://www.geoext.org/lib/GeoExt/widgets/MapPanel.html>`_ with an
-OpenStreetMap layer centered to Denver. In this code, no OpenLayers.Map is
-explicitly created; the GeoExt.MapPanel do this under the hood: it takes the map options, the
-center and the zoom and create a map instance accordingly.
-
-To allow our users to get directions, we need to provide:
- * a way to select the routing algorithm (Shortest path Dijkstra, A* or Shooting*),
- * a way to select the start and final destination.
-
-.. note:: This chapter only show code snippets, the full source code of the
- page can be found in ``pgrouting-workshop/web/routing-final.html`` that should
- be on your desktop. The full listing can also be found at the end of this chapter.
-
--------------------------------------------------------------------------------------------------------------
-Routing method selection
--------------------------------------------------------------------------------------------------------------
-
-To select the routing method, we will use an `Ext.form.ComboBox
-<http://www.sencha.com/deploy/dev/docs/?class=Ext.form.ComboBox>`_: it
-behaves just like a normal html select but we can more easily control it.
-
-Just like the GeoExt.MapPanel, we need an html element to place our control,
-let's create a new div in the body (with 'method' as id):
+Dans l'entÃªte nous chargeons l'ensemble des fichiers javascript et css requis pour l'application. Nous dÃ©finissons aussi une fonction qui sera exÃ©cutÃ©e Ã  la fin du chargement de la page (Ext.onReady).
+
+Cette fonction cÃ©e une instance de`GeoExt.MapPanel
+<http://www.geoext.org/lib/GeoExt/widgets/MapPanel.html>`_ avec une couche de fond OpenStreetMap centrÃ©e sur Denver. Dans ce code, aucun objet OpenLayers.Map est explicitemet crÃ©Ã©; le GeoExt.MapPanel le fait de faÃ§on camouflÃ© : il rÃ©cupÃšre les options de la carte, le centre, le seuil de zoom et crÃ©e une instance de maniÃšre appropriÃ©e.
+
+Pour permettre Ã  nos utilisateurs de trouver leur direction, nous devons fournir :
+ * un moyen de sÃ©lectionner un algorithme de routage  (Dijkstra, A* ou Shooting*),
+ * un moyen de sÃ©lectionner la position de dÃ©part et d'arrivÃ©e.
+
+.. note:: Ce chapitre prÃ©sente uniquement des extraits de codes, le code source complet de la page peut Ãªtre rÃ©cupÃ©rÃ©e depuis ``pgrouting-workshop/web/routing-final.html`` qui devrait Ãªtre sur votre bureau. Le fichier complet se trouve Ã  la fin de ce chapitre.
+
+-------------------------------------------------------------------------------------------------------------
+Outil de sÃ©lection de la mÃ©thode de routage
+-------------------------------------------------------------------------------------------------------------
+
+Pour sÃ©lectionner une mÃ©thode de routage, nous utiliserons un `Ext.form.ComboBox
+<http://www.sencha.com/deploy/dev/docs/?class=Ext.form.ComboBox>`_: il se comporte simplement comme un select html mais est plus simple Ã  controler.
+
+Comme pour le GeoExt.MapPanel, nous avons besoin d'un Ã©lÃ©ments html pour placer notre control, crÃ©ons un div dans le body (ayant 'method' comme identifiant) :
 
  .. code-block:: html
@@ -48,5 +37,5 @@
    </body>
 
-Then we create the combo itself:
+CrÃ©ons ensuite le combo :
  .. code-block:: js
 
@@ -63,53 +52,37 @@
    });
 
-In the ``store`` option, we set all the possible values for the routing method;
-the format is an array of options where an option is in the form ``[key, name]``.
-The ``key`` will be send to the server (the php script in our case) and the
-``value`` displayed in the combo.
-
-The ``renderTo`` specify where the combo must be rendered, we use our new div here.
-
-And finally, a default value is selected:
+Dans l'option ``store``, nous avons dÃ©fini toutes les valeurs pour les mÃ©thodes de routages; les formats sont dans un tableau d'options ou une option est de la forme ``[clef,valeur]``. La ``clef`` sera envoyÃ©e au serveur (the script php dans note cas) et la ``valeur`` affichÃ©e dans la liste dÃ©roulante.
+
+L'option ``renderTo`` dÃ©fini oÃ¹ la liste dÃ©roulante doit Ãªtre affichÃ©e , nous utilisons ici notre Ã©lÃ©ment div.
+
+Et pour finir, une valeur par dÃ©faut est dÃ©finie :
  .. code-block:: js
 
     method.setValue("SPD");
 
-This part only uses ExtJS component: no OpenLayers or GeoExt code here.
-
--------------------------------------------------------------------------------------------------------------
-Select the start and final destination
--------------------------------------------------------------------------------------------------------------
-
-We want to allow the users to draw and move the start and final destination
-points. This is more or less the behavior of google maps and others: the user
-selects the points via a search box (address search) or by clicking the
-map. The system query the server and display the route on the map. The user
-can later move the start or final point and the route is updated.
-
-In this workshop, we will only implement the input via the map (draw points and
-drag-and-drop) but it's possible to implement the search box feature by using a
-web service like `GeoNames <http://www.geonames.org/>`_ or any other `geocoding
-<http://en.wikipedia.org/wiki/Geocoding>`_ service.
-
-To do this we will need a tool to draw points (we will use the
+Cette partie utilise le composant ExtJS : ni code OpenLayers ni GeoExt.
+
+-------------------------------------------------------------------------------------------------------------
+SÃ©lectionner un point de dÃ©part et d'arrivÃ©e
+-------------------------------------------------------------------------------------------------------------
+
+Nous souhaitons permettre Ã  nos utilisateurs de dÃ©ssiner et dÃ©placer un point de dÃ©part et d'arrivÃ©e. C'est plus ou moins le comportement des applications comme google map et les autres : l'utilsateur choisi un point de dÃ©part Ã  l'aide d'un moteur de recherche ou en cliquant sur la carte. L'applicationinterroge ensuite le serveur afin d'afficher le chemin sur la carte. L'utilisateur peut ensuite modifier son opint de dÃ©part et d'arrivÃ©e afin que le chemin soit mis Ã  jour automatiquement.
+
+Dans ces travaux pratiques, nous implÃ©menterons seulement la saisie de point sur la carte (dessiner des points et les dÃ©placer) mais il est parfaitement possible d'implÃ©menter un moteur de recherche en utilisant un service web dÃ©diÃ© tel que `GeoNames <http://www.geonames.org/>`_ ou tout autre service de `geocodage
+<http://fr.wikipedia.org/wiki/Geocodage>`_.
+
+Pour faire ceci nous aurons besoin d'un outil permettant de dessiner des points (nous utiliserons le control
 `OpenLayers.Control.DrawFeatures
-<http://openlayers.org/dev/examples/draw-feature.html>`_ control) and a tool to
-move points (`OpenLayers.Control.DragFeatures
-<http://openlayers.org/dev/examples/drag-feature.html>`_ will be perfect for
-this job). As their name suggests these controls comes from OpenLayers.
-
-These two controls will need a place to draw and manipulate the points; we
-will also need an `OpenLayers.Layer.Vector
-<http://dev.openlayers.org/releases/OpenLayers-2.10/doc/apidocs/files/OpenLayers/Layer/Vector-js.html>`_
-layer. In OpenLayers, a vector layer in a place where features (a geometry and
-attributes) can be drawn programmatically (in contrast, the OSM layer is a
-raster layer).
-
-Because vector layers are cheap, we will use a second one to draw the route
-returned by the web service. The layers initialization is:
-
- .. code-block:: js
-
-    // create the layer where the route will be drawn
+<http://openlayers.org/dev/examples/draw-feature.html>`_) et un outil pour dÃ©placer les points (`OpenLayers.Control.DragFeatures
+<http://openlayers.org/dev/examples/drag-feature.html>`_ sera parfait pour ce travail). Comme leur noms le suppose ces controls sont disponibles dans OpenLayers.
+
+Ces deux controls auront besoin d'un emplacement pour afficher et manipuler les points; nous aurons besoin d'une couche `OpenLayers.Layer.Vector
+<http://dev.openlayers.org/releases/OpenLayers-2.10/doc/apidocs/files/OpenLayers/Layer/Vector-js.html>`_. Dans OpenLayers, une couche vecteur est un endroit oÃ¹ des Ã©lements (une geomÃ©trie et des attributs) peuvent Ãªtre afffichÃ©e (contrairement Ã  la couche OSM qui est une couche raster).
+
+Comme les couches vecteurs sont lÃ©gÃšres, nous en utiliserons une seconde pour afficher la route retourner par le service web. L'initialisation de la couche se fait de la maniÃšre suivante :
+
+ .. code-block:: js
+
+    // CrÃ©ation de la couche oÃ¹ le chemin sera affichÃ©
     var route_layer = new OpenLayers.Layer.Vector("route", {
         styleMap: new OpenLayers.StyleMap(new OpenLayers.Style({
@@ -119,91 +92,76 @@
     });
 
-``"route"`` is the layer name, any string can be used.
-``styleMap`` gives the layer a bit of visual style with a custom stroke color and
-width (in pixel).
-
-The second layer initialization is simply:
-
- .. code-block:: js
-
-    // create the layer where the start and final points will be drawn
+``"route"`` est  le nom de la couche, n'importe qu'elle chaÃ®ne de caractÃšres peut Ãªtre utilisÃ©e.
+``styleMap`` fournis Ã  la couche un mimum de style avec une couleur de contour particuliÃšre et un largeur (en pixel).
+
+La seconde couche est simplement initialiser comme suit :
+
+ .. code-block:: js
+
+    // CrÃ©ation de la couche ou seront affichÃ© les points de dÃ©part et d'arrivÃ©e
     var points_layer = new OpenLayers.Layer.Vector("points");
 
-The two layers are added to the OpenLayers.Map object with:
-
- .. code-block:: js
-
-    // add the layers to the map
+Les deux couches sont ajoutÃ©e Ã  l'objet OpenLayers.Map avec :
+
+ .. code-block:: js
+
+    // Ajouter la cocuhe Ã  la carte
     map.addLayers([points_layer, route_layer]);
 
-Let's look at the control to draw the points: because this component has
-special behavior it's more easy to create a new class based on the standard
-OpenLayers.Control.DrawFeatures control. This new control (named DrawPoints) is
-saved in a separated javascript file (``web/DrawPoints.js``):
+Regardons le control pour afficher les points : puisque ce composant Ã  un comportement particulier il est plus simple de crÃ©er une nouvelle classe basÃ©e sur le control standard
+OpenLayers.Control.DrawFeatures. Ce control (nommÃ© DrawPoints) est enregistrÃ© dans un fichier javascript Ã  part (``web/DrawPoints.js``):
 
 .. literalinclude:: ../../web/DrawPoints.js
 	:language: js
 
-In the ``initialize`` function (that's the class constructor) we set that
-this control can only draw points (handler variable is OpenLayers.Handler.Point).
-
-The special behavior is implemented in the ``drawFeature`` function: because we
-only need the start and final points the control deactivates itself when two
-points are drawn by counting how many features has the vector
-layer. Control deactivation is ``this.deactivate()``.
-
-Our control is then created with:
-
- .. code-block:: js
-
-    // create the control to draw the points (see the DrawPoints.js file)
+Dans la fonction ``initialize`` (qui est le constructeur de la classe) nous spÃ©cifions que ce control peut seulement dessiner des point (la variable handler est OpenLayers.Handler.Point).
+
+Le comportement spÃ©cifique est implÃ©mentÃ© dans la fonction ``drawFeature`` : puisque nous avons seulement  besoin des points de dÃ©part et d'arrivÃ©e, le control se desactive automatiquemnt lorsque deux points ont Ã©tÃ© saisie. La dÃ©sactivation se fait via ``this.deactivate()``.
+
+Notre control est ensuite crÃ©Ã© avec :
+
+ .. code-block:: js
+
+    // CrÃ©ation du control pour dessiner les points (voir le fichier DrawPoints.js)
     var draw_points = new DrawPoints(points_layer);
 
-``points_layer`` is the vector layer created earlier.
-
-And now for the DragFeature control:
-
- .. code-block:: js
-
-    // create the control to move the points
+``points_layer`` est la couche vecteur crÃ©Ã©e prÃ©cÃ©demment.
+
+Et maintenant pour le control DragFeature :
+
+ .. code-block:: js
+
+    // CrÃ©ation du control pour dÃ©placer les points 
     var drag_points = new OpenLayers.Control.DragFeature(points_layer, {
         autoActivate: true
     });
 
-Again, ``points_layer`` is the vector layer, ``autoActivate: true`` tells
-OpenLayers that we want this control to be automatically activated.
-
- .. code-block:: js
-
-    // add the controls to the map
+Encore une fois, la couche ``points_layer``est de type vecteur, ``autoActivate: true`` dit Ã  OpenLayers que nous voulons que ce control soit automatiquement activÃ©.
+
+ .. code-block:: js
+
+    // Ajouter le control Ã  la carte
     map.addControls([draw_points, drag_points]);
 
-Adds the controls to the map.
-
--------------------------------------------------------------------------------------------------------------
-Call and receive data from web service
--------------------------------------------------------------------------------------------------------------
-
-The basic workflow to get a route from the web server is:
-
-#. transform our points coordinates from EPSG:900913 to EPSG:4326
-#. call the web service with the correct arguments (method name and two points coordinates)
-#. parse the web service response: transform GeoJSON to OpenLayers.Feature.Vector
-#. transform all the coordinates from EPSG:4326 to EPSG:900913
-#. add this result to a vector layer
-
-The first item is something new: our map uses the EPSG:900913 projection
-(because we use an OSM layer) but the web service expects coordinates in
-EPSG:4326: we have to re-project the data before sending them. This is not a
-big deal: we will simply use the `Proj4js <http://trac.osgeo.org/proj4js/>`_
-javascript library.
-
-(The second item *call the web service* is covered in the next chapter.)
-
-The routing web service in pgrouting.php returns a `GeoJSON
-<http://geojson.org/>`_ FeatureCollection object. A FeatureCollection is simply
-an array of features: one feature for each route segment. This is very convenient because
-OpenLayers and GeoExt have all what we need to handle this format. To make our
-live even easier, we are going to use the GeoExt.data.FeatureStore:
+Ajouter le control Ã  la carte.
+
+-------------------------------------------------------------------------------------------------------------
+Envoyer et recevoire des donnÃ©es du service web
+-------------------------------------------------------------------------------------------------------------
+
+Le cheminement de base pour obtenir un chemin depuis le service web est le suivant :
+
+#. transformer nos points en coordonnÃ©es de EPSG:900913 en EPSG:4326
+#. appeler le service web avec les arguments correctes (nom de la mÃ©thode et deux points)
+#. lire le rÃ©sultat retournÃ© par le service web : transformer le GeoJSON en OpenLayers.Feature.Vector
+#. transformer toutes les coordonnÃ©es de EPSG:4326 Ã  EPSG:900913
+#. ajouter le rÃ©sultat Ã  la couche vecteur
+
+La premiÃšre Ã©tape est quelque chose de nouveau : notre carte utilise le systÃšme de projection EPSG:900913 
+(parce que nous utilisons une couche OSM) mais le service web attends des coordonnÃ©es en EPSG:4326 : nous devons re-projeter les donnÃ©es avant de les envoyer. Ce n'est pas bien difficile : nous aurons simplement besoin de la ` librairie javascript Proj4js <http://trac.osgeo.org/proj4js/>`_.
+
+(La deuxiÃšme Ã©tape *appeler le service web* est Ã©tudiÃ© au chapitre suivant.)
+
+Le service web de routage dans pgrouting.php renvoit un objet  FeatureCollection au format `GeoJSON <http://geojson.org/>`_. Un objet FeatureCollection est simplement un tableau d'Ã©lÃ©ment : un Ã©lÃ©ments pour chaque tronÃ§on de route. Ceci est trÃšs pratique carOpenLayers et GeoExt ont tout ce dont nous avons besoin pour gÃ©rer ce format. Pour nous rendre la tÃ¢che encore plus simple, nous utiliserons le GeoExt.data.FeatureStore suivant :
 
  .. code-block:: js
@@ -225,43 +183,29 @@
     });
 
-A store is simply a container to store informations: we can push data into and
-get it back.
-
-Let's explain all the options:
-
-``layer``: the argument is a vector layer: by specifying a layer, the
-FeatureStore will automatically draw the data received into this
-layer. This is exactly what we need for the last item (*add this result to a
-vector layer*) in the list above.
-
-``fields``: lists all the attributes returned along with the geometry: pgrouting.php
-returns the segment length so we set it here. Note that this information is not
-used in this workshop.
-
-``proxy``: the proxy item specify where the data should be taken: in our case
-from a HTTP server. The proxy type is GeoExt.data.ProtocolProxy: this class
-connects the ExtJS world (the store) and the OpenLayers world (the protocol
-object).
-
-``protocol``: this OpenLayers component is able to make HTTP requests to an ``url``
-(our php script) and to parse the response (``format`` option). By adding the
-``internalProjection`` and ``externalProjection`` option, the coordinates
-re-projection in made by the format.
-
-We now have all what we need to handle the data returned by the web service: the next
-chapter will explain how and when to call the service.
-
--------------------------------------------------------------------------------------------------------------
-Trigger the web service call
--------------------------------------------------------------------------------------------------------------
-
-We need to call the web service when:
- * the two points are drawn
- * one of the point is moved
- * the routing method has changed
-
-Our vector layer generates an event (called ``featureadded``) when a
-new feature is added, we can listen to this event and call to pgrouting
-function (this function will be presented shortly):
+Un Store est simplement un conteneur qui stocke des informations : nous pouvons y ajouter des Ã©lÃ©ments et les rÃ©cupÃ©rer.
+
+Expliquons les options :
+
+``layer``: le paramÃštre est une couche vecteur : en spÃ©cifiant une couche, le
+FeatureStore affichera automatiquement les donnÃ©es qu'elle contient. C'est exactement ce dont nous avons besoin pour la derniÃšre Ã©tape (*ajouter le rÃ©sultat Ã  la couche vecteur*) dans la liste ci-dessus.
+
+``fields``: liste tout les attributs renvoyÃ©s avec la gÃ©omÃ©trie : pgrouting.php renvoit la longueurdu segment donc nous le spÃ©cifions ici. Notez que cette information n'est pas utilisÃ©e dans ces travaux pratiques.
+
+``proxy``: le paramÃštre proxy specifie oÃ¹ nous devons rÃ©cupÃ©rer les donnÃ©es : dans notre cas depuis le serveur HTTP. Le type de proxy est GeoExt.data.ProtocolProxy : cette classe connecte le monde ExtJS (le Store) et le monde OpenLayers (l'objet protocol).
+
+``protocol``: ce composant OpenLayers est capable d'exÃ©cuter des requÃªtes Ã  un``url`` (notre script php) et de lire la rÃ©ponse (option ``format``). En ajoutant les options ``internalProjection`` et ``externalProjection``, les coordonnÃ©es sont reprojetÃ©es par l'objet format.
+
+Nous avons maintenant tout ce qu'il nous faut pour gÃ©rer les donnÃ©es renvoyÃ©es par le service web : le prochain chapitre expliquera comment et quand l'appeler.
+
+-------------------------------------------------------------------------------------------------------------
+DÃ©clancher l'appel au service web
+-------------------------------------------------------------------------------------------------------------
+
+Nous devons appeler le service web lorsque :
+ * les deux points sont dessinÃ©s
+ * un point Ã  Ã©tÃ© dÃ©placÃ©
+ * la mÃ©thode Ã  utiliser a changÃ© 
+
+Notre couche vecteur gÃ©nÃšre une Ã©vÃ©nement (appelÃ© ``featureadded``) lorsqu'un nouvel Ã©lÃ©ment est ajoutÃ©, nous pouvons utiliser cet Ã©vÃ©nement pour appeler la fonction pgrouting (cette fonction sera prÃ©sentÃ© dans peu de temps) :
 
  .. code-block:: js
@@ -273,12 +217,7 @@
     });
 
-.. note:: Before we continue some words about events: an event in OpenLayers
-  (the same apply for ExtJS and other frameworks), is a system to allow a
-  function to be called when *something* happened. For instance when a layer is
-  added to the map or when the mouse is over a feature. Multiple functions can
-  be connected to the same event.
-
-No event is generated when a point is moved, hopefully we can give a
-function to the DragFeature control to be called we the point is moved:
+.. note:: Avant de continuer quelque mots sur les Ã©vÃ©nements : un Ã©vÃ©nement dans OpenLayers (la mÃªme chose s'applique pour ExtJS et les autres frameworks), est un systÃšme qui permet Ã  une fonction d'Ãªtre appelÃ©e lorsque *quelquechose* se passe. Par exemple lorsqu'une couche est ajoutÃ©e Ã  la carte ou quand la souris se trouve au dessus d'un objet de la carte. Plusieurs fonctions peuvent Ãªtre liÃ©es Ã  un mÃªme Ã©vÃ©nement.
+
+Aucune Ã©vÃ©nemenet n'est gÃ©nÃ©rÃ© lorsqu'un point est dÃ©placÃ©, heureusement nous pouvons dÃ©finir une fonction Ã  notre control DragFeature Ã  appeler lorsqu'un point est dÃ©placÃ© :
 
  .. code-block:: js
@@ -288,6 +227,5 @@
     };
 
-For the *method* combo, we can add a listeners options to the constructor with
-a `select` argument (that's the event triggered when the user changes the value):
+Pour la liste dÃ©roulante *method*, nous pouvons ajouter une option `select` au contructeur  (c'est l'Ã©vÃ©nement dÃ©clencher lorsqu'un utilisateur change sa sÃ©lection) :
 
  .. code-block:: js
@@ -309,6 +247,5 @@
     });
 
-
-It's now time to present the pgrouting function:
+Il est maintenant temps de prÃ©senter la fonction pgrouting :
 
  .. code-block:: js
@@ -340,27 +277,22 @@
     }
 
-The pgrouting function calls the web service through the store argument.
-
-At first, the function checks if two points are passed in
-argument. Then, ``store.removeAll()`` is called to erase a previous result
-from the layer (remember that the store and the vector layer are binded).
-The two points coordinates are then projected using OpenLayers.Projection
-instances.
-
-Finally, ``store.load()`` is called with a ``params`` representing the
-pgrouting.php arguments (they are passed to the HTTP GET call).
-
--------------------------------------------------------------------------------------------------------------
-What's next ?
--------------------------------------------------------------------------------------------------------------
-
-Possible enhancements:
- * use a geocoding service to get start/final point
- * way point support
- * nice icons for the start and final points
- * driving directions (road map): we already have the segment length
-
--------------------------------------------------------------------------------------------------------------
-Full source code
+La fonction pgrouting appÃšle me service web Ã  travers l'argument store.
+
+Au dÃ©but, la fonction vÃ©rifie si deux points sont prÃ©sent dans les paramÃštres. Ensuite, `select` est appelÃ©e pour Ã©ffacer le rÃ©sultat prÃ©cÃ©dent de la couche (souvenez-vous que le Store et la couche vecteur sont liÃ©). Les deux points sont projetÃ©s en utilisant une instance de OpenLayers.Projection.
+
+Pour finir, ``store.load()`` est appelÃ©e avec un argument ``params`` (ils sont passÃ©s via un appÃšle HTTP utilisant la mÃ©thode GET).
+
+-------------------------------------------------------------------------------------------------------------
+Que faire maintenant ?
+-------------------------------------------------------------------------------------------------------------
+
+Possibles amÃ©liorations :
+ * Utiliser un service de gÃ©ocodage pour rÃ©cupÃ©rer le point de dÃ©part / d'arrivÃ©e
+ * Support de plusieurs points 
+ * De jolies icÃŽnes pour le point de dÃ©part et celui d'arrivÃ©e
+ * Direction du parcour (carte de voyage) : nous avons dÃ©jÃ  la distance
+
+-------------------------------------------------------------------------------------------------------------
+Code source complet
 -------------------------------------------------------------------------------------------------------------
 
Index: trunk/workshop-routing-foss4g/docs/chapters/topology.rst
===================================================================
--- trunk/workshop-routing-foss4g/chapters/topology.rst	(revision 63)
+++ trunk/workshop-routing-foss4g/docs/chapters/topology.rst	(revision 76)
@@ -1,7 +1,7 @@
 ==============================================================================================================
-Create a Network Topology
+CrÃ©ation de la topologie du rÃ©seau
 ==============================================================================================================
 
-:doc:`osm2pgrouting <osm2pgrouting>` is a convenient tool, but it's also a *black box*. There are several cases where :doc:`osm2pgrouting <osm2pgrouting>` can't be used. Obviously if the data isn't OpenStreetMap data. Some network data already comes with a network topology that can be used with pgRouting out-of-the-box. Often network data is stored in Shape file format (``.shp``) and we can use PostGIS' ``shape2postgresql`` converter to import the data into a PostgreSQL database. But what to do then?
+:doc:`osm2pgrouting <osm2pgrouting>` est un outil pratique, mais c'est aussi une *boÃ®te noire*. Il y a de nombreux cas oÃ¹ :doc:`osm2pgrouting <osm2pgrouting>` ne peut pas Ãªtre utilisÃ©. Certaines donnÃ©es de rÃ©seau sont fournies avec la topologie du rÃ©seau qui peut Ãªtre utilisÃ© par pgRouting tel-quel. Certaines donnÃ©es de rÃ©seau sont stockÃ©es au format Shape file (``.shp``) et nous pouvons les charger dans une base de donnÃ©es PostgreSQL Ã  l'aide de l'outil de conversion de PostGIS' ``shape2postgresql`. But what to do then?
 
 .. image:: images/network.png
@@ -9,11 +9,11 @@
 	:align: center
 
-In this chapter you will learn how to create a network topology from scratch. For that we will start with data that contains the minimum attributes needed for routing and show how to proceed step-by-step to build routable data for pgRouting. 
+Dans ce chapitre vous allez apprendre comment crÃ©er une topologie de rÃ©seau en partant de rien. Pour ce faire, nous allons commencer par les donnÃ©es qui contiennent les attributs minimum requis pour le routage et comment constituer Ã©tape par Ã©tape des donnÃ©es pour pgRouting.
 
 -------------------------------------------------------------------------------------------------------------
-Load network data
+Charger les donnÃ©es de rÃ©seau
 -------------------------------------------------------------------------------------------------------------
 
-At first we will load a database dump from the workshop ``data`` directory. This directory contains a compressed file with database dumps as well as a smaller network data of Denver downtown. If you haven't uncompressed the data yet, extract the file by 
+Au dÃ©but nous allors charger une sauvegarde de base de donnÃ©es Ã  partir du rÃ©pertoire ``data``des travxu pratiques. Ce rÃ©pertoire contient un fichier compressÃ© incluant une sauvegarde de base de donnÃ©es ainsi qu'un plus petit ensemble de donnÃ©es de rÃ©seau du centre ville de Denver. Si vous n'avez pas encore dÃ©compressÃ©, faite le en utilisant la comande :
 
 .. code-block:: bash
@@ -22,17 +22,17 @@
 	tar -xvzf data.tar.gz
 
-The following command will import the database dump. It will add PostGIS and pgRouting functions to a database, in the same way as decribed in the previous chapter. It will also load the Denver sample data with a minimum number of attributes, which you will usually find in any network data:
+La commande suivante permet d'importer la sauvegarde de la base de donnÃ©es. Elle ajoutera les fonctions PostGIS et pgRouting Ã  la base, de la mÃªme maniÃšre que ce nous avons dÃ©crit dans le chapitre prÃ©cÃ©dent. Cela chargera aussi le petit Ã©chantillon de donnÃ©es de Denver avec un nombre minimum d'attribut, que vous trouverez habituellement dans l'ensemble des donnÃ©es de rÃ©seau :
 
 .. code-block:: bash
 
-	# Optional: Drop database
+	# Optionel: supprimer la base de donnÃ©es
 	dropdb -U postgres pgrouting-workshop
 
-	# Load database dump file
+	# Chargement du fichier de sauvegarde
 	psql -U postgres -f ~/Desktop/pgrouting-workshop/data/sampledata_notopo.sql
 
-Let's see wich tables have been created:
+Regardons quelles tables ont Ã©tÃ© crÃ©Ã©es :
 
-.. rubric:: Run: ``psql -U postgres -d pgrouting-workshop -c "\d"``
+.. rubric:: Lancer : ``psql -U postgres -d pgrouting-workshop -c "\d"``
 	
 .. code-block:: sql
@@ -50,7 +50,7 @@
 
 	
-The table containing the road network data has the name ``ways``. It consists of the following attributes:
+La table contenant les donnÃ©es du rÃ©seau routier onle nom ``ways``. Elle possÃšde les attributs suivants :
 	
-.. rubric:: Run: ``psql -U postgres -d pgrouting-workshop -c "\d ways"``
+.. rubric:: Lancer : ``psql -U postgres -d pgrouting-workshop -c "\d ways"``
 	
 .. code-block:: sql
@@ -73,15 +73,15 @@
 	    "enforce_srid_the_geom" CHECK (srid(the_geom) = 4326)
 
-It is common that road network data provides at least the following information:
+Il est habituel dans des donnÃ©es de rÃ©seau routier de retrouver au moins les informations suivantes :
 
-* Road link ID (gid)
-* Road class (class_id)
-* Road link length (length)
-* Road name (name)
-* Road geometry (the_geom)
+* Identifiant de tronÃ§on routier (gid)
+* Classe de tronÃ§on (class_id)
+* Longuer du tronÃ§on routier (length)
+* Nom du tronÃ§on (name)
+* La gÃ©omÃ©trie du tronÃ§on (the_geom)
 
-This allows to display the road network as a PostGIS layer in GIS software, for example in QGIS. Though it is not sufficient for routing, because it doesn't contain network topology information.
+Cela permet d'afficher le rÃ©seau routier comme une couche PostGIS depuis un logiciel SIG, par exemple dans QGIS. Notez ue les informations ne suffisent pas au calcul de routes Ã©tant donnÃ© qu'il ne contient aucune information relative Ã  la topolgie du rÃ©seau.
 
-For the next steps we need to start the PostgreSQL command line tool 
+La prochaine Ã©tape consiste Ã  dÃ©marrer l'outil en ligne de commande PostgreSQL
 
 .. code-block:: bash
@@ -89,14 +89,14 @@
 	psql -U postgres pgrouting-workshop
 	
-... or use PgAdmin III.
+... ou d'utiliser PgAdmin III.
 
 
 --------------------------------------------------------------------------------------------------------------
-Calculate topology
+Calcul de la topologie
 --------------------------------------------------------------------------------------------------------------
 
-Having your data imported into a PostgreSQL database usually requires one more step for pgRouting. You have to make sure that your data provides a correct network topology, which consists of information about source and target ID of each road link.
+Pour avoir vos donnÃ©es importÃ© dans une base de donnÃ©es PostgreSQL requiÃšre gÃ©nÃ©ralement des Ã©tapes supplÃ©mentaires pour pgRouting. Vous devez vous assurer que vos donnÃ©es fournissent une topologie correcte du rÃ©seau, ce qui correspond aux informations par rapport au dÃ©but et Ã  la fin d'un tronÃ§on.
 
-If your network data doesn't have such network topology information already you need to run the ``assign_vertex_id`` function. This function assigns a ``source`` and a ``target`` ID to each link and it can "snap" nearby vertices within a certain tolerance.
+Si les donnÃ©es de votre rÃ©seau ont une dÃ©jÃ  telle information vous devez exÃ©cuter la fonctions ``assign_vertex_id``. Cette fonction permet l'assignation des valeurs pour les colonnes ``source`` et ``target`` pour chaque tronÃ§on et il peut prendre en compte le fait qu'un sommet puisse Ãªtre Ã©loignÃ© d'un autre suivant une certaine tolÃ©rance.
 
 .. code-block:: sql
@@ -104,29 +104,29 @@
 	assign_vertex_id('<table>', float tolerance, '<geometry column', '<gid>')
 	
-First we have to add source and target column, then we run the assign_vertex_id function ... and wait.:
+PremiÃšrement nous devons ajouter les colonnes source et target, pour ensuite utiliser la fonction assign_vertex_id ... et attendre :
 
 .. code-block:: sql
 
-	-- Add "source" and "target" column
+	-- Ajouter les colonnes "source" et "target"
 	ALTER TABLE ways ADD COLUMN "source" integer;
 	ALTER TABLE ways ADD COLUMN "target" integer;
 	
-	-- Run topology function
+	-- Utiliser la fonction de contruction de topologie
 	SELECT assign_vertex_id('ways', 0.00001, 'the_geom', 'gid');
 
 .. note::
 
-	Execute ``psql -U postgres -d pgrouting-workshop`` in your terminal to connect to the database and start the PostgreSQL shell. Leave the shell with ``\q`` command.   
+	ExÃ©cuter ``psql -U postgres -d pgrouting-workshop`` depuis votre terminal afin de vous connecter Ã Ã l a base de donnÃ©es et lancer des commandes PostgreSQL en ligne. Quiter la session avec la commande ``\q`` .   
 
 .. warning::
 
-	The dimension of the tolerance parameter depends on your data projection. Usually it's either "degrees" or "meters".
+	La dimension du paramÃštre tolÃ©rance dÃ©pends du systÃšme de projection de vos donnÃ©es. Habituellement c'est soit "degrÃ©s" soit "mÃštres".
 
 
 -------------------------------------------------------------------------------------------------------------
-Add indices
+Ajouter des indexes
 -------------------------------------------------------------------------------------------------------------
 
-Fortunately we didn't need to wait too long because the data is small. But your network data might be very large, so it's a good idea to add an index to ``source`` and ``target`` column.
+Heureusement nous n'avons pas Ã  attendre longtemps Ã©tant donnÃ© que notre jeu de donnÃ©es est trÃšs petit. Mais la quantitÃ© de donnÃ©es d'un rÃ©seau pourrait Ãªtre beaucoup plus importante, donc il vaut mieux ajouter des indexes pour les colonnes  ``source`` et ``target``.
 
 .. code-block:: sql
@@ -135,7 +135,7 @@
 	CREATE INDEX target_idx ON ways("target");
 
-After these steps our routing database look like this:
+Suite Ã  ces Ã©tapes, notre base de donnÃ©es routing ressemble Ã  ceci :
 
-.. rubric:: Run: ``\d``
+.. rubric:: Lancer : ``\d``
 	
 .. code-block:: sql
@@ -152,5 +152,5 @@
 	(6 rows)
 
-.. rubric:: Run: ``\d ways``
+.. rubric:: Lancer : ``\d ways``
 	
 .. code-block:: sql
@@ -177,3 +177,3 @@
 	    "enforce_srid_the_geom" CHECK (srid(the_geom) = 4326)
 		
-Now we are ready for our first routing query with :doc:`Dijkstra algorithm <shortest_path>`!
+Nous sommes fin prÃªts pour notre premiÃšre requÃªte de routage avec `l'algorithme de Dijkstra <shortest_path>` !
Index: trunk/workshop-routing-foss4g/docs/chapters/php_server.rst
===================================================================
--- trunk/workshop-routing-foss4g/chapters/php_server.rst	(revision 63)
+++ trunk/workshop-routing-foss4g/docs/chapters/php_server.rst	(revision 76)
@@ -1,21 +1,21 @@
 ==============================================================================================================
-Server side script with PHP
+Script PHP cotÃ© serveur
 ==============================================================================================================
 
-We will use a PHP script to make the routing query and send the result back to the web client.
+Nous utiliserons un script PHP pour exÃ©cuter les requÃªtes de routafe et renverons le rÃ©sultat au client web.
 
-The following steps are necessary:
+Les Ã©tapes suivantes sont nÃ©cessaires :
 
-* Retrieve the start and end point coordinates.
-* Find the closest edge to start/end point.
-* Take either the start or end vertex of this edge (for Dijkstra/ A-Star) or the complete edge (Shooting-Star) as start of the route and end respectively.
-* Make the Shortest Path database query.
-* Transform the query result to XML or better GeoJSON and send it back to the web client.
+* Retrouver les coordonnÃ©es du point de dÃ©part et de celui d'arrivÃ©e.
+* Trouver l'arrÃªte la plus proche d'un point de dÃ©part ou d'arrivÃ©e.
+* Prendre soit le noeud de dÃ©but ou de fin de l'arrÃªte  (for Dijkstra/ A-Star) ou l'arrÃªte elle-mÃªme (Shooting-Star) comme dÃ©but ou fin du parcours.
+* ExÃ©cuter les requÃªte de recherche de plus court chemin.
+* Retourner le rÃ©sultat de la requÃªte en XML ou mieux encore en GeoJSON au client web.
 
 .. note::
 	
-	To keep this example as simple as possible with focus on routing queries, this PHP script doesn't validate request parameters nore does it deal with PHP security issues. 
+	Pour conserver cet exemple aussi simple que possiblle et de mettre en Ã©vidence les requÃªte de routafe, ce script PHP ne valide pas les paramÃštres des requÃªtes et ne prend pas en compte les problÃšmes de sÃ©curitÃ©s de PHP. 
 
-Let's start with some PHP template and then place this file in a directory, which is accessible by Apache:
+CommenÃ§ons avec quelque modÃšles PHP et plaÃ§on ces fichiers dans un rÃ©pertoire accessible par le serveur Apache :
 
 .. literalinclude:: ../../web/php/pgrouting.php
@@ -25,8 +25,8 @@
 	  
 -------------------------------------------------------------------------------------------------------------
-Closest edge
+L'arrÃªte la plus proche
 -------------------------------------------------------------------------------------------------------------
 
-Usually the start and end point, which we retrieved from the client, is not the start or end vertex of an edge. It is more convenient to look for the closest edge than for the closest vertex, because Shooting Star algorithm is âedge-basedâ. For âvertex-basedâ algorithms (Dijkstra, A-Star) we can choose arbitrary start or end of the selected edge.
+Habituellement les points de dÃ©part et d'arrivÃ©e, qui sont rÃ©cupÃ©rer depuis le client, n'est pas le point de dÃ©part ou d'arrivÃ©e d'un tronÃ§on. Il est plus simple de retrouver l'arrÃªte la plus proche que le sommet le plus proche, parce que l'algorithme "Shooting-Star" est basÃ© sur les arrÃªtes. Pour les algorithmes basÃ©s sur les sommets (Dijkstra, A-Ãtoile) nous pouvons choisir le opint de dÃ©part ou d'arrivÃ©e de l'arrÃªte sÃ©lectionnÃ©e.
 
 .. literalinclude:: ../../web/php/pgrouting.php
@@ -36,5 +36,5 @@
 	  
 -------------------------------------------------------------------------------------------------------------
-Routing query
+RequÃªte de routage
 -------------------------------------------------------------------------------------------------------------
 
@@ -45,8 +45,8 @@
 
 -------------------------------------------------------------------------------------------------------------
-GeoJSON output
+Sortie au format GeoJSON
 -------------------------------------------------------------------------------------------------------------
 
-OpenLayers allows to draw lines directly using GeoJSON format, so our script returns a GeoJSON FeatureCollection object:
+OpenLayers permet l'affichage de lignes en utilisant directement des donnÃ©es au format GeoJSON, donc notre script retourne un objet FeatureCollection au format GeoJSON :
 
 .. literalinclude:: ../../web/php/pgrouting.php
Index: trunk/workshop-routing-foss4g/docs/chapters/osm2pgrouting.rst
===================================================================
--- trunk/workshop-routing-foss4g/chapters/osm2pgrouting.rst	(revision 63)
+++ trunk/workshop-routing-foss4g/docs/chapters/osm2pgrouting.rst	(revision 76)
@@ -1,40 +1,40 @@
 ==============================================================================================================
-osm2pgrouting Import Tool
+Outils d'import osm2pgrouting
 ==============================================================================================================
 
-**osm2pgrouting** is a command line tool that makes it very easy to import OpenStreetMap data into a pgRouting database. It builds the routing network topology automatically and creates tables for feature types and road classes. osm2pgrouting was primarily written by Daniel Wendt and is currently hosted on the pgRouting project site: http://www.pgrouting.org/docs/tools/osm2pgrouting.html
+**osm2pgrouting** est un outils en ligne de commande qui rend simple l'importation de donnÃ©es OpenStreetMap dans une base de donnÃ©es pgRouting. Il contruit le rÃ©seau routier automatiquement et crÃ©e les tables pour les types de donnÃ©es et les classes de routes. osm2pgrouting a Ã©tÃ© Ã©crit initialement par Daniel Wendt et est maintenant disponible sur le site du projet pgRouting : http://www.pgrouting.org/docs/tools/osm2pgrouting.html
 
 .. note::
 
-	There are some limitations, especially regarding the network size. The current version of osm2pgrouting needs to load all data into memory, which makes it fast but also requires a lot or memory for large datasets. An alternative tool to osm2pgrouting without the network size limitation is **osm2po** (http://osm2po.de). It's available under "Freeware License".
+	Il y a quelques limitations, particuliÃšrement par rapport Ã  la taille du rÃ©seay. La version actuelle nÃ©cessite le chargement en mÃ©moire de l'ensemble des donnÃ©es, ce qui le rend rapide mais consome aussi beaucoup de mÃ©moire pour les gros enesemble d'objets. Un outils alternatif n'ayant pas de limitation sur la taille du rÃ©seauest **osm2po** (http://osm2po.de). Il est disponible sous licence "Freeware License".
 	
 
-Raw OpenStreetMap data contains much more features and information than need for routing. Also the format is not suitable for pgRouting out-of-the-box. An ``.osm`` XML file consists of three major feature types:
+Les donnÃ©es brutres d'OpenStreetMap contiennent bien plus d'Ã©lÃ©ments et d'informations qu'il est nÃ©cessaire pour du routage. Ainsi le format n'est pas utilisable tel-quel avec pgRouting. Un fichier XML ``.osm`` contient trois types de donnÃ©es majeurs :
 
-* nodes
-* ways
+* noeuds
+* chemins
 * relations
 
-The data of sampledata.osm for example looks like this:
+Les donnÃ©es de sampledata.osm par exemple ressemble Ã  ce qui suit :
 
 .. literalinclude:: code/osm_sample.osm
 	:language: xml
 
-Detailed description of all possible OpenStretMap types and classes can be found here:  http://wiki.openstreetmap.org/index.php/Map_features.
+Une description dÃ©taillÃ©e de tout les types et classes possibles d'OpenStreetMap peuvent-Ãªtre trouvÃ© ici : http://wiki.openstreetmap.org/index.php/Map_features.
 
-When using osm2pgrouting, we take only nodes and ways of types and classes specified in ``mapconfig.xml`` file that will be imported into the routing database:
+Lorsuqe vous utilisez osm2pgrouting, nous devons conserver uniquement les noeuds et les chemin ayant pour types et classes celles stipulÃ©e dans le fichier ``mapconfig.xml`` qui seront improtÃ©s dans notre base de donnÃ©es routing :
 
 .. literalinclude:: code/mapconfig_sample.xml
 	:language: xml
 
-The default ``mapconfig.xml`` is installed in ``/usr/share/osm2pgrouting/``.
+Le fichier ``mapconfig.xml``par dÃ©faut est installÃ© dans le rÃ©pertoire : ``/usr/share/osm2pgrouting/``.
 
 
 -------------------------------------------------------------------------------------------------------------
-Create routing database
+CrÃ©ation de la base de donnÃ©es routing
 -------------------------------------------------------------------------------------------------------------
 
-Before we can run osm2pgrouting we have to create a database and load PostGIS and pgRouting functions into this database. 
-If you have installed the template databases as described in the previous chapter, creating a pgRouting-ready database is done with a single command. Open a terminal window and run:
+Avant de lancer osm2pgrouting nous devons crÃ©er la base de donnÃ©es et y charger les fonctionalitÃ©s de PostGIS et pgRouting .
+Si vous avez installÃ© le modÃšle de base de donnÃ©es comme dÃ©crit dans le chapitre prÃ©cÃ©dent, crÃ©er une base de donnÃ©es prÃªte Ã  utiliser pgRouting est fait par une simple commande. Ouvrez une fenÃªtre de terminal et utiliser la commande suivante : 
 
 .. code-block:: bash
@@ -42,26 +42,26 @@
 	createdb -U postgres -T template_routing routing
 	
-... and you're done.
+... vous avez terminÃ©.
 
-Alternativly you can use **PgAdmin III** and SQL commands. Start PgAdmin III (available on the LiveDVD), connect to any database and open the SQL Editor and then run the following SQL command:
+Une alternative consiste Ã   utiliser l'outil **PgAdmin III** et des requÃªtes SQL. DÃ©marrez  PgAdmin III (disponible sur le LiveDVD), connectez vous Ã  une base de donnÃ©es eyt ouvrez l'Ã©diteur de requÃªtes afin d'y saisir les requÃªtes SQL suivantes :
 
 .. code-block:: sql
 
-	-- create routing database
+	-- CrÃ©ationde la base routing
 	CREATE DATABASE "routing" TEMPLATE "template_routing";
 
 
-Otherwise you need to manually load several files into your database. See :ref:`previous chapter <installation_load_functions>`.
+Sinon, vous devez manuellement charger diffÃ©rents fichier dans la base de donnÃ©es. Voir : :ref:`previous chapter <installation_load_functions>`.
 
 	
 -------------------------------------------------------------------------------------------------------------
-Run osm2pgrouting
+Utiliser osm2pgrouting
 -------------------------------------------------------------------------------------------------------------
 
-The next step is to run ``osm2pgrouting`` converter, which is a command line tool, so you need to open a terminal window.
+La prochaine Ã©tape c'est de lancer l'outil ``osm2pgrouting``, qui est un outil en ligne de commande, donc vous devrez l'utiliser depuis une fenÃªtre de terminal.
 
-We take the default ``mapconfig.xml`` configuration file and the ``routing`` database we created before. Furthermore we take ``~/Desktop/pgrouting-workshop/data/sampledata.osm`` as raw data. This file contains only OSM data from downtown Denver to speed up  data processing time.
+Nous prendrons par dÃ©faut le fichier de configuration ``mapconfig.xml`` et la base de donnÃ©es ``routing`` que nous avons crÃ©er prÃ©cÃ©demment. De plus nous prendrons le fichier ``~/Desktop/pgrouting-workshop/data/sampledata.osm`` comme donnÃ©es brutes. Ce fichier contient seulement les donnÃ©es OSM du centre ville de Denver afin d'accÃ©lÃ©rer le processus de chargement des donnÃ©es.
 
-The workshop data is available as compressed file, which needs to be extracted first either using file manager or with this command:
+Les donnÃ©es sont disponibles au format compressÃ©, qui doit donc Ãªtre dÃ©compressÃ© soit en utlisant un navigateur de fichier soit en utilisant la commande suivante :
 
 .. code-block:: bash
@@ -70,5 +70,5 @@
 	tar -xvzf data.tar.gz
 
-Then run the converter:
+Lancer ensuite l'outil :
 	
 .. code-block:: bash
@@ -80,56 +80,56 @@
 				  -clean
 					
-List of all possible parameters:
+Liste des paramÃštres possible :
 
 .. list-table::
    :widths: 15 15 60 10
 
-   * - **Parameter**
-     - **Value**
-     - **Description**
-     - **Required**
+   * - **ParamÃštre**
+     - **Valeur**
+     - **DÃ©scription**
+     - **Requis**
    * - -file
-     - <file>
-     - name of your osm xml file
+     - <fichier>
+     - le nom du fichier XML .osm
      - yes
    * - -dbname
-     - <dbname>
-     - name of your database
+     - <nom_de_base>
+     - le nom de votre base de donnÃ©es
      - yes
    * - -user
-     - <user>
-     - name of the user, which have write access to the database
+     - <utilisateur>
+     - le nom de l'utilisateur, qui a le droit d'accÃšs en Ã©criture sur la base de donnÃ©es
      - yes
    * - -conf
-     - <file>
-     - name of your configuration xml file
+     - <fichier>
+     - le nom du fichier XML de configuration
      - yes
    * - -host
-     - <host>
-     - host of your postgresql database (default: 127.0.0.1)
+     - <hÃŽte>
+     - l'hÃŽte de votre base de donnÃ©es postgresql (par dÃ©faut : 127.0.0.1)
      - no
    * - -port
      - <port>
-     - port of your database (default: 5432)
+     - le numÃ©ro de port de votre serveur de base de donnÃ©es(par dÃ©faut: 5432)
      - no
    * - -passwd
-     - <passwd>
-     - password for database access
+     - <mot_de_passe>
+     - le mot de passe pour se connecter Ã  la base de donnÃ©es
      - no
    * - -clean
      - 
-     - drop peviously created tables
+     - Suprrimer les tables prÃ©cÃ©demment crÃ©Ã©es
      - no
 
 .. note::
 
-	If you get permission denied error for postgres users you can set connection method to ``trust`` in ``/etc/postgresql/8.4/main/pg_hba.conf`` and restart PostgreSQL server with ``sudo service postgresql-8.4 restart``.
+	Si vous obtenez un message d'erreur relatif aux droits de l'utilisateur postgres, vous pouvez dÃ©finir la mÃ©thode comme ``trust`` dans le fichier  ``/etc/postgresql/8.4/main/pg_hba.conf`` et redÃ©marrer le serveur PostgreSQL avec la commande ``sudo service postgresql-8.4 restart``.
 
 
-Depending on the size of your network the calculation and import may take a while. After it's finished connect to your database and check the tables that should have been created:
+Suivant la taille de votre rÃ©seau le temps de cacul et d'importation de donnÃ©es peut Ãªtre long. Une fois terminÃ©, connectez Ã  votre base de donnÃ©es et vÃ©rifiez les tables qui aurait du Ãªtre crÃ©Ã©es :
 
-.. rubric:: Run: ``psql -U postgres -d routing -c "\d"``	
+.. rubric:: Lancer: ``psql -U postgres -d routing -c "\d"``	
 
-If everything went well the result should look like this:
+Si tout se passe bien, le rÃ©sultat devrait ressembler Ã  ceci :
 	
 .. code-block:: sql
Index: trunk/workshop-routing-foss4g/docs/chapters/introduction.rst
===================================================================
--- trunk/workshop-routing-foss4g/chapters/introduction.rst	(revision 63)
+++ trunk/workshop-routing-foss4g/docs/chapters/introduction.rst	(revision 76)
@@ -3,7 +3,7 @@
 ==============================================================================================================
 
-.. rubric:: Abstract
+.. rubric:: RÃ©sumÃ©
 
-`pgRouting <http://www.pgrouting.org>`_ ajoute les fonctionalitÃ© de routage Ã  `PostGIS <http://www.postgis.org>`_. Ces travaux pratiques d'introduction va vous prÃ©senter comment. Il prÃ©sente un exemple pratique de comment utiliser pgRouting avec les donnÃ©es du rÃ©seau routier d'`OpenStreetMap <http://www.openstreetmap.org>`_. Il explique les Ã©tapes permettant la prÃ©paration des donnÃ©es, effectuer des requÃªtes de routage, l'assignation des coÃ»ts et l'utilisation de `GeoExt <http://www.geoext.org>`_ pour prÃ©senter les chamins depuis une application de web-mapping.
+`pgRouting <http://www.pgrouting.org>`_ ajoute les fonctionalitÃ©s de routage Ã  `PostGIS <http://www.postgis.org>`_. Ces travaux pratiques d'introduction va vous prÃ©senter comment. Il prÃ©sente un exemple pratique de comment utiliser pgRouting avec les donnÃ©es du rÃ©seau routier d'`OpenStreetMap <http://www.openstreetmap.org>`_. Il explique les Ã©tapes permettant la prÃ©paration des donnÃ©es, effectuer des requÃªtes de routage, l'assignation des coÃ»ts et l'utilisation de `GeoExt <http://www.geoext.org>`_ pour prÃ©senter les chamins depuis une application de web-mapping.
 
 La navigration dans un rÃ©seau de routes nÃ©cessite des algorithmes de routage complex qui supportent la restriction des virages utilisables et mÃªme des attributs dÃ©pendant du temps. pgRouting est une librairie OpenSource qui peut Ãªtre Ã©tendue qui fournit une grande variÃ©tÃ© d'outils pour la recherche de plus courts chemins comme une extension de PortgreSQL et de PostGIS. Ces travaux pratiques vont expliquer la recherche de plus courts chemin avec pgRouting dans un rÃ©seau routier rÃ©el et comment la structure des donnÃ©es est importante pour obtenir des rÃ©sultats plus rapidement. Vous apprendrez aussi les difficultÃ©s et le limitations de pgRouting dans le cadre d'application SIG.
Index: trunk/workshop-routing-foss4g/docs/chapters/advanced.rst
===================================================================
--- trunk/workshop-routing-foss4g/chapters/advanced.rst	(revision 63)
+++ trunk/workshop-routing-foss4g/docs/chapters/advanced.rst	(revision 76)
@@ -1,7 +1,7 @@
 ==============================================================================================================
-Advanced Routing Queries
+RequÃªtes de routage avancÃ©es
 ==============================================================================================================
 
-As explained in the previous chapter a shortest path query usualy looks like this:
+Comme expliquÃ© dans le chapitre prÃ©cÃ©dent une requÃªte de recherche de plus court chemine ressemble gÃ©nÃ©ralement Ã  ce qui suit :
 
 .. code-block:: sql
@@ -11,31 +11,31 @@
 		to_cost, reverse_cost FROM ways', 6585, 8247, true, true);
 	
-This is usually called **shortest** path, which means that a length of an edge is its cost. But cost doesn't need to be length, cost can be almost anything, for example time, slope, surface, road type, etc.. Or it can be a combination of multiple parameters ("Weighted costs").
+On parle gÃ©nÃ©ralement de **plus court** chemin, ce qui signifie que la longueur d'un arc est son coÃ»t. Mais le coÃ»t n'est pas nÃ©cessairement une longueur, il peut reprÃ©senter n'importe quoi, par exemple le temps, la surface, le type de routes, etc ... Ou il peut Ãªtre la combinaison de plusieurs paramÃštres ("coÃ»ts pondÃ©rÃ©s").
 
 .. note::
 
-	If you want to proceed with a routing database containing pgRouting functions, sample data and all required attributes, you can load the following database dump file. 
+	Si vous souhaitez continuer avec une base de donnÃ©es contenant les fonctions pgRouting, les donnÃ©es exemples ainsi que les attributs nÃ©cessaires, vous pouvez charger le fichier de sauvegarded la maniÃšre suivante.
 
 .. code-block:: bash
 
-	# Optional: Drop database
+	# Optionel: supprimer la base de donnÃ©es
 	dropdb -U postgres pgrouting-workshop
 
-	# Load database dump file
+	# Charger le fichier de sauvegarde
 	psql -U postgres -f ~/Desktop/pgrouting-workshop/data/sampledata_routing.sql
 
 -------------------------------------------------------------------------------------------------------------
-Weighted costs
+CoÃ»ts pondÃ©rÃ©s
 -------------------------------------------------------------------------------------------------------------
 
-In real networks there are different limitations or preferences for different road types for example. In other words, we don't want to get the *shortest* but the **cheapest** path - a path with a minimal cost. There is no limitation in what we take as costs.
+Dans un vrai rÃ©seau il y a diffÃ©rents types de limitations ou de prÃ©fÃ©rences suivant les types de routes par exemple. En d'autre termes, nous ne voulons pas calculer *le plus court* chemin mais le chemin *le moins cher* - un chemin avec un coÃ»t minimum. Il n'y aucune limitation dans ce qui peut ÃªtreutilsiÃ© pour dÃ©finir le coÃ»t.
 
-When we convert data from OSM format using the osm2pgrouting tool, we get two additional tables for road ``types`` and road ``classes``:
+Lorsque nous avons convertis les donnÃ©es au format OSM en utilisant l'outil osm2pgrouting, nous avons deux autres tables permettant de dÃ©ifinir les ``types`` de routes et les ``classes``.
 
 .. note::
 
-	We switch now to the database we previously generated with osm2pgrouting. From within PostgreSQL shell this is possible with the ``\c routing`` command.
+	Nous passons maintenant Ã  la base de donnÃ©es que nuos avons gÃ©nÃ©rÃ©e avec osm2pgrouting. Depuis l'invite de commandes de PostgreSQL ceci est possible avec la commande ``\c routing``.
 
-.. rubric:: Run: ``SELECT * FROM types;``
+.. rubric:: Lancer : ``SELECT * FROM types;``
 
 .. code-block:: sql
@@ -48,5 +48,5 @@
 	   3 | tracktype
    
-.. rubric:: Run: ``SELECT * FROM classes;``
+.. rubric:: Lancer : ``SELECT * FROM classes;``
 
 .. code-block:: sql
@@ -89,5 +89,5 @@
 	 305 |       3 | grade5             |     
 
-The road class is linked with the ways table by ``class_id`` field. After importing data the ``cost`` attribute is not set yet. Its values can be changed with an ``UPDATE`` query. In this example cost values for the classes table are assigned arbitrary, so we execute:
+La classe de route est liÃ©e avec la tables des cheminspar le champ ``class_id``. Suite Ã  l'importation des donnÃ©es la valeur de la colonne ``cost`` n'est pas encore attribuÃ©e. Sa valeur peut Ãªtre modifiÃ©e Ã  l'aide d'une requÃªte ``UPDATE``. Dans cet exemple les valeurs de coÃ»t pour la table des classe sont assignÃ© de faÃ§on arbitraire, donc nous exÃ©cutons :
 
 .. code-block:: sql
@@ -101,5 +101,5 @@
 	UPDATE classes SET cost=0.3 WHERE name IN ('motorway','motorway_junction','motorway_link');
 
-For better performance, especially if the network data is large, it is better to create an index on the ``class_id`` field of the ways table and eventually on the ``id`` field of the ``types`` table.
+Pour de meilleures performances, tout spÃ©cialement si le rÃ©seau est important, il est prÃ©fÃ©rable de crÃ©er un index sur la colonnes ``class_id`` de la table des chemins et eventuellement le champ ``id`` de la table ``types``.
 
 .. code-block:: sql
@@ -108,5 +108,5 @@
 	CREATE INDEX classes_idx ON classes (id);
 
-The idea behind these two tables is to specify a factor to be multiplied with the cost of each link (usually length):
+L'idÃ©e de ces deux tables est de les utiliser afin de spÃ©cifier un facteur qui sera multipliÃ© par le coÃ»t de parcour d'un tronÃ§on (habituellement la longueur) :
 
 .. code-block:: sql
@@ -119,8 +119,8 @@
 
 -------------------------------------------------------------------------------------------------------------
-Restricted access
+Restriction d'accÃšs
 -------------------------------------------------------------------------------------------------------------
 
-Another possibility is to restrict access to roads of a certain type by either setting a very high cost for road links with a certain attribute or by not selecting certain road links at all:
+Une autre possibilitÃ© est de restreindre l'accÃšs Ã  des routes d'un certains types soit en affectant un coÃ»t trÃšs Ã©levÃ© Ã  un tronÃ§on ayant un certain attribut soit en s'assurant de ne sÃ©lectionner aucun de ces tronÃ§ons :
 
 .. code-block:: sql
@@ -128,7 +128,7 @@
 	UPDATE classes SET cost=100000 WHERE name LIKE 'motorway%';
 
-Through subqueries you can "mix" your costs as you like and this will change the results of your routing request immediately. Cost changes will affect the next shortest path search, and there is no need to rebuild your network.
+En utilisant des sous-requÃªtes vous pouvez "mixer" vos coÃ»t comme bon vous semble et cela modifiera le rÃ©sultat obtenu imÃ©diatement. Les changements de coÃ»ts affecteront la prochaine recherche de plus courts chemins, sans avoir Ã  reconstruire le votre rÃ©seau.
 
-Of course certain road classes can be excluded in the ``WHERE`` clause of the query as well, for example exclude "living_street" class:
+Bien entendu, certaines classes de tronÃ§on peuvent aussi Ãªtre exclues Ã  l'aide d'une clause ``WHERE`` dans la requÃªte, par exemple pour exclure la classe "living_street" :
 
 .. code-block:: sql
@@ -140,4 +140,4 @@
 		WHERE class_id=c.id AND class_id != 111', 6585, 8247, true, true);
 
-Of course pgRouting allows you all kind of SQL that is possible with PostgreSQL/PostGIS.
+Bien entendu, pgRouting vus permet tout types de requÃªtes SQL supportÃ©es par PostgreSQL/PostGIS.
  
Index: trunk/workshop-routing-foss4g/docs/chapters/shortest_path.rst
===================================================================
--- trunk/workshop-routing-foss4g/chapters/shortest_path.rst	(revision 63)
+++ trunk/workshop-routing-foss4g/docs/chapters/shortest_path.rst	(revision 76)
@@ -1,7 +1,7 @@
 ==============================================================================================================
-Shortest Path Search
+Plus courts chemins
 ==============================================================================================================
 
-pgRouting was first called *pgDijkstra*, because it implemented only shortest path search with *Dijkstra* algorithm. Later other functions were added and the library was renamed.
+pgRouting Ã©tÃ© initialement appelÃ© *pgDijkstra*, puisque il implÃ©mentait seulement la recherche de plus court chemin Ã  l'aide de l'agorithme de *Dijkstra*. Plus tard, d'uatres fonctions se sont ajoutÃ©es et la bibliotÃšque fut renommÃ©e.
 
 .. image:: images/route.png
@@ -9,10 +9,10 @@
 	:align: center
 	
-This chapter will explain the three different shortest path algorithms and which attributes are required. 
-
-
-.. note::
-
-	If you run :doc:`osm2pgrouting <osm2pgrouting>` tool to import *OpenStreetMap* data, the ``ways`` table contains all attributes already to run all shortest path functions. The ``ways`` table of the ``pgrouting-workshop`` database of the :doc:`previous chapter <topology>` is missing several attributes instead, which are listed as **Prerequisites** in this chapter.
+Ce chapitre explique les trois diffÃ©rents algorithmes et les attributs nÃ©cessaires.
+
+
+.. note::
+
+	Si vous lancez l'outils :doc:`osm2pgrouting <osm2pgrouting>` pour importer des donnÃ©es *OpenStreetMap*, la table des chemins (``ways``) contient dÃ©jÃ  tout les attributs nÃ©cessaires pour utiliser les fonctions de recherche de plus court chemins. Au contraire, la table ``ways`` de la base de donnÃ©es ``pgrouting-workshop`` du :doc:`chapitre prÃ©cÃ©dent <topology>` manque d'un certain nombre d'attributs, qui sont prÃ©sentÃ©s dans ce chapitre dans les **PrÃ©requis**.
 
 
@@ -21,9 +21,9 @@
 -------------------------------------------------------------------------------------------------------------
 
-Dijkstra algorithm was the first algorithm implemented in pgRouting. It doesn't require other attributes than ``source`` and ``target`` ID, ``id`` attribute and ``cost``. It can distinguish between directed and undirected graphs. You can specify if your network has ``reverse cost`` or not.
-
-.. rubric:: Prerequisites
-
-To be able to use ``reverse cost`` you need to add an additional cost column. We can set reverse cost as length.
+L'algorithme de Dijkstraa Ã©tÃ© la premiÃšre implÃ©mentation disponible dans pgRouting. Il ne nÃ©cessite pas d'autre attributs que les champs ``source`` et ``target``, les attributs ``id`` et ``cost``. Il peut Ãªtre utilisÃ© sur des graphes orientÃ©s ou non. Vous pouvez spÃ©cifier que votre rÃ©seau Ã  un coÃ»t de ``parcours inverse`` (``reverse cost``) ou non.
+
+.. rubric:: PrÃ©requis
+
+Pour Ãªtre en mesure d'utiliser un coÃ»t de parcuors invers, vous devez ajouter une colonne de coÃ»t. Nous pouvons affecter la longuer au coÃ»t de parcours inverse.
 
 .. code-block:: sql
@@ -32,5 +32,5 @@
 	UPDATE ways SET reverse_cost = length;
 
-.. rubric:: Function with parameters
+.. rubric:: Fonction avec paramÃštres
 
 .. code-block:: sql
@@ -44,13 +44,13 @@
 .. note::
 
-	* Source and target IDs are vertex IDs.
-	* Undirected graphs ("directed false") ignore "has_reverse_cost" setting
-
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Core
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Each algorithm has its *core* function , which is the base for its wrapper functions.
+	* Les identifiant pour source et target sont les identifiant des noeuds.
+	* Graphes non-orientÃ©s ("directed=false") implique que le paramÃštre "has_reverse_cost" est ignorÃ©
+
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Bases
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Chaque algorithme a une fonction de *base*.
 
 .. code-block:: sql
@@ -77,10 +77,10 @@
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Wrapper
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. rubric:: Wrapper WITHOUT bounding box
-
-Wrapper functions extend the core functions with transformations, bounding box limitations, etc.. Wrappers can change the format and ordering of the result. They often set default function parameters and make the usage of pgRouting more simple.
+Enveloppe
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. rubric:: Enveloppe SANS limite d'Ã©tendue
+
+les fonctions enveloppes sont des fonctions qui Ã©tendent les fonctions de bases en y ajoutant des transformations, ajoutant des limites de l'Ã©tendue gÃ©ograhpique de la recherhe, etc.. Les enveloppes peuvent changer le format et l'ordre des rÃ©sultats. Il affectent aussi automatiquement certains paramÃštre et rend l'utilisation de pgRouting encore plsu simple.
 
 .. code-block:: sql
@@ -103,16 +103,16 @@
 .. note::
 
-	It's possible to show the route in QGIS. It works for shortest path queries that return a geometry column.
-
-	* Create a database connection and add the "ways" table as a background layer.
-	* Add another layer of the "ways" table but select ``Build query`` before adding it.
-	* Type ``"gid"  IN ( SELECT gid FROM dijkstra_sp('ways',5700,6733))`` into the **SQL where clause** field.
-	
-	``SQL query`` can be also selected from the layer context menu. 
-
-	
-.. rubric:: Wrapper WITH bounding box
-
-You can limit your search area by adding a bounding box. This will improve performance especially for large networks.
+	Il est possible de visualiser le chemin dans QGIS. Cela fonctionne pour la requÃªte de recherche du plus court chemin qui retourne une colonne gÃ©omÃ©trique.
+
+	* CrÃ©er la connexion Ã  la base de donnÃ©es et ajoutez la table route comme couche de fond.
+	* Ajoutez une autre couche de la table "ways" mais selectionnez l'option ``Build query`` avant de l'ajouter.
+	* Saissez ``"gid"  IN ( SELECT gid FROM dijkstra_sp('ways',5700,6733))`` dans le champ **SQL where clause**.
+	
+	``SQL query`` peut aussi Ãªtre sÃ©lectionnÃ© depuis le menu contextuel de la couche. 
+
+	
+.. rubric:: Enveloppe AVEC une Ã©tendue limite
+
+Vous pouvez limiter votre recherche Ã  une zone prÃ©cise en ajoutant un cadre limite. Cela amÃ©liorera les performances tout spÃ©cialement pour les rÃ©seaux volumineux.
 
 .. code-block:: sql
@@ -134,16 +134,16 @@
 .. note:: 
 
-	The projection of OSM data is "degree", so we set a bounding box containing start and end vertex plus a ``0.1`` degree buffer for example.
-
-
--------------------------------------------------------------------------------------------------------------
-A-Star
--------------------------------------------------------------------------------------------------------------
-
-A-Star algorithm is another well-known routing algorithm. It adds geographical information to source and target of each network link. This enables the shortest path search to prefer links which are closer to the target of the search.
-
-.. rubric:: Prerequisites
-
-For A-Star you need to prepare your network table and add latitute/longitude columns (``x1``, ``y1`` and ``x2``, ``y2``) and calculate their values.
+	La projection des donnÃ©es OSM est en "degrÃ©s", donc nous dÃ©finirons un cadre limite contenant le point de dÃ©part et celui d'arrivÃ©e plus une zone tampon de ``0.1`` degrÃ©s par exemple.
+
+
+-------------------------------------------------------------------------------------------------------------
+A-Ãtoile
+-------------------------------------------------------------------------------------------------------------
+
+L'algortihme A-Ãtoile est un autre algrithme bien connu. Il ajoute l'information de la position gÃ©ographique du dÃ©but et la fin de chaque tronÃ§on. Cela permet une recherche privilÃ©giant les tronÃ§ons proches du point d'arrivÃ©e de la recherche.
+
+.. rubric:: PrÃ©requis
+
+Pour A-* vous avez besoin de prÃ©parer votre table de rÃ©seau et d'y ajouter les colonnes latitute/longitude (``x1``, ``y1`` et ``x2``, ``y2``) et de calculer leur valeurs.
 
 .. code-block:: sql
@@ -168,10 +168,10 @@
 .. Note:: 
 
-	``endpoint()`` function fails for some versions of PostgreSQL (ie. 8.2.5, 8.1.9). A workaround for that problem is using the ``PointN()`` function instead:
-
-
-.. rubric:: Function with parameters
-
-Shortest Path A-Star function is very similar to the Dijkstra function, though it prefers links that are close to the target of the search. The heuristics of this search are predefined, so you need to recompile pgRouting if you want to make changes to the heuristic function itself.
+	La fonction ``endpoint()`` ne fonctionne pas avec certaines versions de PostgresQL (par exemple les version 8.2.5 et 8.1.9). Un moyen de rÃ©soudre ce problÃšme consiste Ã  utiliser la fonction ``PointN()`` Ã  la place:
+
+
+.. rubric:: Fonction avec paramÃštres
+
+La fonction de recherche de plus court chemin A-* est trÃšs semblable Ã  la fonction Dijkstra, bien qu'elle prÃ©fÃšre les tronÃ§ons qui sont plus proche du point d'arrivÃ©e de la recherche. Les heuristiques de cette recherche sont prÃ©dÃ©finis, donc vous aurez besoin de recompiler pgRouting si vous souhaitez modifier ces heuristiques.
 
 .. code-block:: sql
@@ -184,9 +184,9 @@
 
 .. note::
-	* Source and target IDs are vertex IDs.
-	* Undirected graphs ("directed false") ignore "has_reverse_cost" setting
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Core
+	* Les identifiants source et target sont les identifiant des sommets IDs.
+	* Graphes non-orientÃ© ("directed=false") ne prennent pas en compte le paramÃštre "has_reverse_cost"
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Bases
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -215,10 +215,8 @@
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Wrapper
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. rubric:: Wrapper function WITH bounding box
-
-Wrapper functions extend the core functions with transformations, bounding box limitations, etc..
+Enveloppe
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. rubric:: Fonction envelopper AVEC cadre limite
 
 .. code-block:: sql
@@ -241,6 +239,5 @@
 .. note::
 
-	* There is currently no wrapper function for A-Star without bounding box, since bounding boxes are very useful to increase performance. If you don't need a bounding box Dijkstra will be enough anyway.
-	* The projection of OSM data is "degree", so we set a bounding box containing start and end vertex plus a 0.1 degree buffer for example.
+	* Il n'y a pas actuellement de fonction pour a-* sans cadre limite, Ã©tant donnÃ©e que le cadre limite permet d'amÃ©liorer grandement les performances. Si vous n'avez pas besoin de cadre limite, Dijkstra sera suffisant.
 
 
@@ -249,29 +246,29 @@
 -------------------------------------------------------------------------------------------------------------
 
-Shooting-Star algorithm is the latest of pgRouting shortest path algorithms. Its speciality is that it routes from link to link, not from vertex to vertex as Dijkstra and A-Star algorithms do. This makes it possible to define relations between links for example, and it solves some other vertex-based algorithm issues like "parallel links", which have same source and target but different costs.
-
-.. rubric:: Prerequisites
-
-For Shooting-Star you need to prepare your network table and add the ``rule`` and ``to_cost`` column. Like A-Star this algorithm also has a heuristic function, which prefers links closer to the target of the search.
-
-.. code-block:: sql
-
-	-- Add rule and to_cost column
+L'algorithme Shooting-Star est le dernier algorithme de recherche de plus court chemin. Sa spÃ©cialitÃ© c'est qu'il recherche un parcours d'un tronÃ§on Ã  un autre, pas d'un sommet Ã  un sommet comme les agorithmes de Dijkstra et A-Star le font. Cela rend possible la dÃ©finition de relations entre les tronÃ§ons par exemple, et cela rÃ©soud certains problÃšmes liÃ©s aux recherches d'un sommets Ã  un autre comme les "tronÃ§ons parallÃšles", qui ont les mÃªme sommet de dÃ©but et de fin mais des coÃ»t diffÃ©rents.
+
+.. rubric:: PrÃ©requis
+
+Pour Shooting-Star vous avez besoin de prÃ©parer votre table de rÃ©seau et d'ajouter les colonnes ``rule`` et ``to_cost``. Come l'algorithme A-* il a aussi un fonction heuristique, qui favorise les tronÃ§ons plus proche du point d'arrivÃ©e.which prefers links closer to the target of the search.
+
+.. code-block:: sql
+
+	-- Ajouter les colonnes rule et to_cost
 	ALTER TABLE ways ADD COLUMN to_cost double precision;	
 	ALTER TABLE ways ADD COLUMN rule text;
 
-.. rubric:: Shooting-Star algorithm introduces two new attributes
+.. rubric:: L'algorithme Shooting-Star introduit deux nouveaux attributs
 
 .. list-table::
    :widths: 10 90
 
-   * - **Attribute**
-     - **Description**
+   * - **Attribut**
+     - **DÃ©scription**
    * - rule
-     - a string with a comma separated list of edge IDs, which describes a rule for turning restriction (if you came along these edges, you can pass through the current one only with the cost stated in to_cost column)
+     - une chaine de caractÃšres contenant une liste d'identifiants de tronÃ§no sÃ©parÃ©s par une virgule, qui dÃ©crivent le sens giratoir (si vous venez de cet tronÃ§on, vous pouvez rejoindre le suivant en ajoutant un coÃ»t dÃ©fini dans la colonne to_cost)
    * - to_cost
-     - a cost of a restricted passage (can be very high in a case of turn restriction or comparable with an edge cost in a case of traffic light)
-
-.. rubric:: Function with parameters
+     - un coÃ»t pour passer d'un tronÃ§on Ã  un autre (peut Ãªtre trÃšs Ã©levÃ© s'il est interdit de trouner vers ce tronÃ§on ce qui est comparable au coÃ»t de parcours d'un tronÃ§on en cas de feu de signalisation)
+
+.. rubric:: Fonction avec paramÃštres
 
 .. code-block:: sql
@@ -285,8 +282,8 @@
 .. note::
 
-	* Source and target IDs are link IDs.
-	* Undirected graphs ("directed false") ignores "has_reverse_cost" setting
-
-To describe turn restrictions:
+	* Identifiant du dÃ©part et de l'arrivÃ©e sont des identifiants de tronÃ§ons.
+	* Graphes non-orientÃ©s ("directed=false") ne prennent pas en compte le paramÃštre "has_reverse_cost" 
+
+Pour dÃ©crire une interdiction de tourner :
 
 .. code-block:: sql
@@ -296,5 +293,5 @@
 	  12 |      3 |     10 |    2 |  4 |  3 |  4 |  5 |    1000 | 14
   
-... means that the cost of going from edge 14 to edge 12 is 1000, and
+... signifie que le coÃ»t pour aller du tronÃ§on 14 au tronÃ§on 12 est de 1000, et
 
 .. code-block:: sql
@@ -304,7 +301,7 @@
 	  12 |      3 |     10 |    2 |  4 |  3 |  4 |  5 |    1000 | 14, 4
 
-... means that the cost of going from edge 14 to edge 12 through edge 4 is 1000.
-
-If you need multiple restrictions for a given edge then you have to add multiple records for that edge each with a separate restriction.
+... signifie que le coÃ»t pour aller du tronÃ§on 14 au tronÃ§on 12 via le tronÃ§on 4 est de 1000.
+
+Si vous avez besoin de plusieurs restrictions pour une arrÃªte donnÃ©e you devez ajouter plusieurs enregistrements pour ce tronÃ§on avec un restriction particuliÃšre.
 
 .. code-block:: sql
@@ -315,12 +312,12 @@
 	  11 |      3 |     10 |    2 |  4 |  3 |  4 |  5 |    1000 | 12
 
-... means that the cost of going from either edge 4 or 12 to edge 11 is 1000. And then you always need to order your data by gid when you load it to a shortest path function..
-
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Core
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-An example of a Shooting Star query may look like this: 
+... signifie que le coÃ»t pour aller soit du tronÃ§on  4 soit du 12 au 11 est de 1000. Et donc vous devez ordoner vos donnÃ©es par gid lorsque vous chargez vos donnÃ©es dans la fonction de recherche de plus court chemin...
+
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Bases
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Un exemple d'utilisation de l'algorithme Shooting Star : 
 
 .. code-block:: sql
@@ -349,12 +346,10 @@
 .. warning::
 
-	Shooting Star algorithm calculates a path from edge to edge (not from vertex to vertex). Column vertex_id contains start vertex of an edge from column edge_id.
-
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Wrapper
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Wrapper functions extend the core functions with transformations, bounding box limitations, etc..
+	L'lgorithme Shooting Star calcul un chemin d'un tronÃ§on Ã  un autre (pas d'un sommet Ã  un autre). La colonnes vertex_id contienr le point de dÃ©part du tronÃ§on de la colonne edge_id.
+
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Envelopper
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 .. code-block:: sql
@@ -376,7 +371,3 @@
 .. note::
 
-	There is currently no wrapper function for Shooting-Star without bounding box, since bounding boxes are very useful to increase performance. 
-
-.. warning::
-
-	The projection of OSM data is "degree", so we set a bounding box containing start and end vertex plus a 0.1 degree buffer for example.
+	Il n'y a actuellement pas de fonction enveloppe pour Shooting-Star sans cadre limite, puisque le cadre limite amÃ©liore grandement les performances. 
