2a:null 2b:["$","title",null,{"children":"Génération procédurale de cartes | linard-y | Observable"}] 31:T444,md`La chaleur produite par les rayonnements solaires fait évaporer l'eau de l'océan qui charge l'atmosphère en vapeur d'eau. Poussée par les vents, la vapeur d'eau précipite lorsque la masse d'air, porteuse de cette vapeur, arrive à saturation (l'air ne peut porter qu'une quantité limitée de vapeur d'eau au-delà de quoi l'eau se condense et se déverse ; cette limite dépend bien sûr de la température et de la pression). En raison du soulèvement orographique (déplacement de l'air qui rencontre un obstacle du relief qui le force à s'élever), une masse d'air chargée en vapeur d'eau voit sa température diminuer ce qui conduit à diminuer l'indice de saturation et augmente le risque de précipitation. La vapeur ne peut pas passer les zones élevées, donc les plus grandes précipitations tombent sur les pentes des collines et des massifs montagneux exposés au vent. Les pentes sous le vent restent généralement sèches et forment une ombre pluviométrique. ![soulèvement orographique](http://www.astrosurf.com/luxorion/Physique/meteo-precipitation-oro-dwg.jpg)`32:T1b05,function calculatePrecipitation(svg, pavage) { let Nord = vents.indexOf('N')==-1 ? 0 : 1; let Est = vents.indexOf('E')==-1 ? 0 : 1; let Sud = vents.indexOf('S')==-1 ? 0 : 1; let Ouest = vents.indexOf('O')==-1 ? 0 : 1; let pavés = pavage.pavés; pavés.map(function(p){p.precipitation=0;}); let k = 2; var sides = Nord+ Est + Sud + Ouest; var precipInit = precipitationInput / sides; var selection = 10 / sides; var nuages = []; if (Nord==1) { // on considère que la barre nuageuse se compose d'autant de nuages que de pavés couverts par celle-ci (autrement dit à l'état initial, il y a sur le bord e la carte un nuage par pavé) let barre_nuageuse = pavés.filter(function(p){ return (p.data[1] < selection && p.data[0] > pavage.width*0.01 && p.data[0] < pavage.width*0.99); }); barre_nuageuse.map(function(p) { var x = p.data[0]; var y = p.data[1]; // on symbolise le nuage de départ par un point blanc svg.append("circle") .attr("cx", x) .attr("cy", y) .attr("r", 12) .attr("fill", "white"); // on définit ici la quantité d'eau porté par chaque nuage qui compose de la barre nuageuse var precipitation = precipInit; //poussé par le vent du Nord, le nuage va progresser vers le Sud en déversant une partie de son eau jusqu'à ce que son stock soit vide ou qu'il atteigne le bord Sud de la carte while (y < pavage.height && precipitation > 0) { // le nuage progresse à vitesse constante (+5 par iteration) y += 5; // on introduit une part d'aléatoire dans la course du nuage vers le Sud x += Math.random() * 10 - 5; // on trouve le pavé de la nouvelle position du nuage var pavé_couvert = pavés[pavage.voronoi.find(x, y).index]; // en fonction de l'élévation du pavé couvert par le nuage, ce dernier va déverser une partie de son eau sous forme de pluie // si le pavé couvert est une terre... if (pavé_couvert.elevation >= niveau_de_la_mer) { // si le pavé couvert a une élévation inférieur à 0.6, élévation à partir de laquelle on considère le pavé comme un pavé de type montagne, il perd une partie de son stock d'eau if (pavé_couvert.elevation < 0.6) { var pluie = Math.random() * pavé_couvert.elevation; precipitation -= pluie; pavé_couvert.precipitation += pluie; } else { // s'il s'agit d'un pavé de montagne, le nuage se vide complètement precipitation = 0; pavé_couvert.precipitation += precipitation; } nuages.push({x:x, y:y, pluie:pluie}); } } }); } // on répète maintenant l'algorithme dans les trois autres directions if (Est==1) { let barre_nuageuse = pavés.filter(function(p){ return (p.data[0] > pavage.width - selection && p.data[1] > pavage.height*0.01 && p.data[1] < pavage.height*0.99); }); barre_nuageuse.map(function(p) { var x = p.data[0]; var y = p.data[1]; svg.append("circle") .attr("cx", x) .attr("cy", y) .attr("r", 10) .attr("fill", "white"); var precipitation = precipInit; while (x > 0 && precipitation > 0) { x -= 5; y += Math.random() * 10 - 5; var pavé_couvert = pavés[pavage.voronoi.find(x, y).index]; if (pavé_couvert.elevation >= niveau_de_la_mer) { if (pavé_couvert.elevation < 0.6) { var pluie = Math.random() * pavé_couvert.elevation; precipitation -= pluie; pavé_couvert.precipitation += pluie; } else { precipitation = 0; pavé_couvert.precipitation += precipitation; } nuages.push({x:x, y:y, pluie:pluie}); } } }); } if (Sud==1) { let barre_nuageuse = pavés.filter(function(p){ return (p.data[1] > pavage.height - selection && p.data[0] > pavage.width*0.01 && p.data[0] < pavage.width*0.99); }); barre_nuageuse.map(function(p) { var x = p.data[0]; var y = p.data[1]; svg.append("circle") .attr("cx", x) .attr("cy", y) .attr("r", 10) .attr("fill", "white"); var precipitation = precipInit; while (y > 0 && precipitation > 0) { y -= 5; x += Math.random() * 10 - 5; var pavé_couvert = pavés[pavage.voronoi.find(x, y).index]; if (pavé_couvert.elevation >= niveau_de_la_mer) { if (pavé_couvert.elevation < 0.6) { var pluie = Math.random() * pavé_couvert.elevation; precipitation -= pluie; pavé_couvert.precipitation += pluie; } else { precipitation = 0; pavé_couvert.precipitation += precipitation; } nuages.push({x:x, y:y, pluie:pluie}); } } }); } if (Ouest==1) { let barre_nuageuse = pavés.filter(function(p){ return (p.data[0] < selection && p.data[1] > pavage.height*0.01 && p.data[1] < pavage.height*0.99); }); barre_nuageuse.map(function(p) { var x = p.data[0]; var y = p.data[1]; svg.append("circle") .attr("cx", x) .attr("cy", y) .attr("r", 10) .attr("fill", "white"); var precipitation = precipInit; while (x < pavage.width && precipitation > 0) { x += 5; y += Math.random() * 20 - 10; var pavé_couvert = pavés[pavage.voronoi.find(x, y).index]; if (pavé_couvert.elevation >= niveau_de_la_mer) { if (pavé_couvert.elevation < 0.6) { var pluie = Math.random() * pavé_couvert.elevation; precipitation -= pluie; pavé_couvert.precipitation += pluie; } else { precipitation = 0; pavé_couvert.precipitation += precipitation; } nuages.push({x:x, y:y, pluie:pluie}); } } }); } svg.selectAll(".nuage").remove(); svg.append('g') .selectAll('.nuage') .data(nuages) .enter() .append("circle") .attr("class", "nuage") .attr("cx", (d) => d.x ) .attr("cy", (d) => d.y) .attr("r", 10) .attr("fill", (d) => couleur(d.pluie*k)) .attr("fill-opacity", (d) => 3*k*(d.pluie/precipInit)); // on lisse les valeurs de précipitation en moyennant les valeurs de tous les voisins pavés.map(function(p) { if (p.elevation >= 0.2) { var prec = [p.precipitation]; p.voisins.forEach(function(e) { prec.push(pavés[e].precipitation); }); var mean = d3.mean(prec); p.precipitation = mean; p.flux = mean; } }); } 33:Tcf9, function flux(pavage, niv) { let riversData = []; var pavé; var id, oposite, edge, ea, xDiff, yDiff, riverNext = 0; let polygons = pavage.pavés; let land = polygons.filter(function(d){ return (d.elevation >= niv)}); land.sort(compareElevation); for (var i = 0; i < land.length; i++) { var index = [], peak = [], pour = [], id = land[i].id; pavé = pavage.voronoi.cells[id]; pavé.halfedges.forEach(function(e) { edge = pavage.voronoi.edges[e]; if (edge.left && edge.right) { ea = edge.left.index; if (ea === i) { ea = edge.right.index; } } if (ea) { index.push(ea); peak.push(polygons[ea].elevation); // Define neighbour ocean cells for deltas if (polygons[ea].elevation < niv) { xDiff = (edge[0][0] + edge[1][0]) / 2; yDiff = (edge[0][1] + edge[1][1]) / 2; pour.push({x:xDiff, y:yDiff, pavé:ea}); } } }) var min = index[peak.indexOf(d3.min(peak))]; // Define river number if (land[i].flux > 0.6) { if (land[i].riviere==-1) { // State new River land[i].riviere = riverNext; riverNext += 1; riversData.push({riviere: land[i].riviere, pavé: id, x: land[i].data[0], y: land[i].data[1], type: "source"}); } // Assing existing River to the downhill cell if (polygons[min].riviere==-1) { polygons[min].riviere = land[i].riviere; } else { var iRiver = riversData.filter(function(e) { return (e.riviere == land[i].riviere); }); var minRiver = riversData.filter(function(e) { return (e.riviere == polygons[min].riviere); }); if (iRiver.length >= minRiver.length) { polygons[min].riviere = land[i].riviere; } } } polygons[min].flux += land[i].flux; if (land[i].precipitation * 0.9 > polygons[min].precipitation) { polygons[min].precipitation = land[i].precipitation * 0.9; } if (polygons[min].elevation < niv && land[i].riviere!=-1) { // pour water to the Ocean if (land[i].flux > 15 && pour.length > 1) { // River Delta for (var c = 0; c < pour.length; c++) { if (c == 0) { riversData.push({ riviere: land[i].riviere, pavé: id, x: pour[0].x, y: pour[0].y, type: "delta", pour: pour[0].pavé }); } else { riversData.push({ riviere: riverNext, pavé: id, x: land[i].data[0], y: land[i].data[1], type: "course" }); riversData.push({ riviere: riverNext, pavé: id, x: pour[c].x, y: pour[c].y, type: "delta", pour: pour[0].pavé }); } riverNext += 1; } } else { // River Estuary var x = pour[0].x+((pour[0].x-land[i].data[0])/10); var y = pour[0].y+((pour[0].y-land[i].data[1])/10); riversData.push({ riviere: land[i].riviere, pavé: id, x: x, y: y, type: "estuary", pour: pour[0].pavé }); } } else { // add next River segment riversData.push({ riviere: land[i].riviere, pavé: min, x: polygons[min].data[0], y: polygons[min].data[1], type: "course" }); } } return {data: riversData, N:riverNext} }34:T127c,function drainage(pavage, niv) { var coursDEau = []; // tableau pour stocker les elements des rivières let pavés = pavage.pavés; let pavés_terrestres = pavés.filter(function(d){ return (d.elevation >= niv)}); pavés_terrestres.sort(compareElevation); let riviereID = 0; pavés_terrestres.map((p, i) => { var index = []; var topographie = []; var ecoulement = []; p.voisins.map(function(vi, vii) { topographie.push(pavés[vi].elevation); if (pavés[vi].elevation < niv) { var bord = pavage.trouveBordCommun(p.id, vii); var xDiff = (bord[0][0] + bord[1][0]) / 2; var yDiff = (bord[0][1] + bord[1][1]) / 2; ecoulement.push({x:xDiff, y:yDiff, pavé:vi}); } }); // pavage.voronoi.cells[p.id].halfedges.forEach(function(e) { // var bord = pavage.voronoi.edges[e]; // if (bord.left && bord.right) { // s'il existe un pavé de part et d'autre du bord... (a minima il y a, d'un côté, le pavé terrestre à partir de laquelle on a défini le bord) // var vi = bord.left.index; // if (vi == p.id) {vi = bord.right.index;} // index.push(vi); // topographie.push(pavés[vi].elevation); // // Défini les pavés d'eau voisine comme faisant partie d'un delta // if (pavés[vi].elevation < niv) { // var xDiff = (bord[0][0] + bord[1][0]) / 2; // var yDiff = (bord[0][1] + bord[1][1]) / 2; // ecoulement.push({x:xDiff, y:yDiff, pavé:vi}); // } // } // }); //var min = index[topographie.indexOf(Math.min(...topographie))]; //var collecteur = pavés[min]; // <-- c'est le pavé voisin le plus bas, donc l'eau va s'écouler vers ce pavé var collecteur = pavés[p.voisins[topographie.indexOf(d3.min(topographie))]]; // <-- c'est le pavé voisin le plus bas, donc l'eau va s'écouler vers ce pavé //if (collecteur.elevation > p.elevation) { collecteur = p;} if (p.flux > 0.6) { // on a à faire à un pavé sur lequel coule une rivière if (p.riviere == -1) { // si l'identifiant de la rivière n'est pas encore défini, c'est une nouvelle rivière, on va lui donner un identifiant et déclarer ce pavé comme la source de la rivière p.riviere = riviereID; riviereID += 1; coursDEau.push({riviere: p.riviere, pavé: p.id, x: p.data[0], y: p.data[1], type: "source", log:'P1'}); } if (collecteur.riviere == -1) { // si le pavé collecteur n'a pas encore été déclaré comme faisant partie de la rivière alors on lui attribue l'identifiant de la rivière du pavé dont s'écoule l'eau collecteur.riviere = p.riviere; } else { // on récupère les éléments de cours d'eau coulant sur le pavé courant var iriviere = coursDEau.filter(function(e) { return (e.riviere == p.riviere);}); // on récupère également les éléments de cours d'eau coulant sur le pavé collecteur var minriviere = coursDEau.filter(function(e) {return (e.riviere == collecteur.riviere);}); // si la rivière du pavé courant contient plus d'élements (est plus grande) que l'autre alors on change l'identifiant de la rivière du pavé collecteur, on a ici un affluent qui se jete dans la rivière principale //if (iriviere.length >= minriviere.length) { collecteur.riviere = p.riviere;} } } collecteur.flux += p.flux; if (p.precipitation * 0.9 > collecteur.precipitation) { collecteur.precipitation = p.precipitation * 0.9; } if (collecteur.elevation < niv && p.riviere != -1) { // écoulement jusque dans l'océan ou dans un lac if (p.flux > 15 && ecoulement.length > 1) { // Delta for (var c = 0; c < ecoulement.length; c++) { if (c == 0) { coursDEau.push({riviere: p.riviere, pavé: p.id, x: ecoulement[0].x, y: ecoulement[0].y, type: "delta", ecoulement: ecoulement[0].pavé, log:'P2'}); } else { coursDEau.push({riviere: riviereID, pavé: p.id, x: p.data[0], y: p.data[1], type: "course", log:'P3'}); coursDEau.push({riviere: riviereID, pavé: p.id, x: ecoulement[c].x, y: ecoulement[c].y, type: "delta", ecoulement: ecoulement[0].pavé, log:'P4'}); } riviereID += 1; } } else { var x = ecoulement[0].x+((ecoulement[0].x-p.data[0])/10); var y = ecoulement[0].y+((ecoulement[0].y-p.data[1])/10); coursDEau.push({riviere: p.riviere, pavé: p.id, x: x, y: y, type: "estuary", ecoulement: ecoulement[0].pavé, log:'P5'}); } } else { coursDEau.push({riviere: collecteur.riviere, pavé: collecteur.id, x: collecteur.data[0], y: collecteur.data[1], type: "course", log:'P6'}); } }); return {data: coursDEau, N:riviereID} } 35:Tcb3,drawRiverLines = (svg, size, pavage, data, index) => { var dataRiver; var x = d3.scaleLinear().domain([0, size[0]]).range([0, size[0]]); var y = d3.scaleLinear().domain([0, size[1]]).range([0, size[1]]); var line = d3.line() .x(function(d) {return x(d.x);}) .y(function(d) {return y(d.y);}) .curve(d3.curveCatmullRom.alpha(1)); var flux = 0; dataRiver = data.filter(function(e) { return (e.riviere == index); }); if (dataRiver.length > 1) { var riverAmended = []; if (dataRiver.length > 2) { // add more river points on 1/3 and 2/3 of length for (var r = 0; r < dataRiver.length; r++) { riverAmended.push({x:dataRiver[r].x, y:dataRiver[r].y}); if (r+2 < dataRiver.length) { var dX = dataRiver[r].x; var dY = dataRiver[r].y; var meandr = 0.4 + Math.random() * 0.3; var stX = (dX * 2 + dataRiver[r+1].x) / 3; var stY = (dY * 2 + dataRiver[r+1].y) / 3; var enX = (dX + dataRiver[r+1].x * 2) / 3; var enY = (dY + dataRiver[r+1].y * 2) / 3; if (Math.random() > 0.5) { stX += meandr; enX -= meandr; } else { stY += meandr; enY -= meandr; } riverAmended.push({x:stX,y:stY}); riverAmended.push({x:enX,y:enY}); } } var river = svg.select("defs").append("path").attr("d", line(riverAmended)); var path = river.node().getPathData(); for (var s = 1; s < path.length; s++) { var segment = ""; if (s == 1) { var sX = path[0].values[0]; var sY = path[0].values[1]; } else { var sX = path[s-1].values[4]; var sY = path[s-1].values[5]; } segment += sX +","+sY + " C"+ path[s].values[0]+"," +path[s].values[1] + "," + path[s].values[2]+"," +path[s].values[3] + "," + path[s].values[4]+"," +path[s].values[5]; svg.append("circle").attr("cx", sX).attr("cy", sY).attr("r", 0.1).attr("fill", "red"); var from = pavage.voronoi.find(sX, sY, 0.1); if (from) { flux = pavage.pavés[from.id].flux/30; } var riverWidth = (s/100 + flux); if (riverWidth > 0.5) {riverWidth *= 0.9}; var shadowWidth = riverWidth/3; if (shadowWidth < 0.1) {shadowWidth = 0.1;} //svg.append("path").attr("d", "M"+segment).attr("stroke-width", shadowWidth); //svg.append("path").attr("d", "M"+segment).attr("stroke-width", riverWidth); } } else if (dataRiver[1].type == "delta") { riverAmended.push({x:dataRiver[0].x, y:dataRiver[0].y}); var middleX = (dataRiver[0].x + dataRiver[1].x) / 2 + (0.2 + Math.random() * 0.1); var middleY = (dataRiver[0].y + dataRiver[1].y) / 2 + (0.2 + Math.random() * 0.1); riverAmended.push({x:middleX, y:middleY}); riverAmended.push({x:dataRiver[1].x, y:dataRiver[1].y}); svg.append("path").attr("d", line(riverAmended)) .attr("stroke-width", 0.3); svg.append("path").attr("d", line(riverAmended)) .attr("stroke-width", 0.6); } } } 36:T43c,{ let pavés = carte.pavés; let pavés_terrestres = pavés.filter(function(d){ return (d.elevation >= niveau_de_la_mer)}); const svg = d3.select(DOM.element('svg')) .attr("width", carte.width) .attr("height", carte.height); let elements = identifierElements(carte, niveau_de_la_mer); let rivages = identifierRivage(carte); let rivage = creerLigneDeCotesContinue(rivages, 0, 0); dessineBasiqueRivage(svg, [carte.width, carte.height], rivage); for (var r=0; r \"M\" + d.join(\"L\") + \"Z\" )\n .attr(\"fill\", (d) => couleur(d.precipitation*2));\n \n let elements = identifierElements(carte, niveau_de_la_mer);\n let rivages = identifierRivage(carte);\n let rivage = creerLigneDeCotesContinue(rivages, 0, 0);\n dessineBasiqueRivage(svg, [carte.width, carte.height], rivage);\n \n return svg.node();\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":244,"value":"md`Penchons nous maintenant sur le calcul des tracés de rivière. Pour chaque pavé, nous devons définir le pavé voisin le moins élevé pour connaitre la pente et donc la direction du drainage des précipitations qui arrivent sur le sol. Cela nous permettra de déterminer les lignes de flux sur la carte et de drainer toutes les précipitations vers l'océan ou un lac.`","pinned":false,"hidden":false,"mode":"ojs"},{"id":247,"value":"md`Il y a cependant un problème : les pavés qui sont moins élevés que tous leurs voisins. Nous devons absolument appliquer une correction au pavage, c'est-à-dire appliquer un algorithme de remplissage des dépressions. Pour faire simple, nous éliminerons le problème. Nous allons faire une boucle itérative sur l'ensemble des pavés en commencant par les plus élevés, détecter ceux qui présente cette anomalie hydrologique et de leur ajouter un peu d'élevation.`","pinned":false,"hidden":false,"mode":"ojs"},{"id":251,"value":"supprimeDepressions = (pavage, niv) => {\n let pavés = pavage.pavés;\n let pavés_terrestres = pavés.filter(function(d){ return (d.elevation >= niv)});\n\n var depression = 1, minPavéIndex, minElevation;\n while (depression > 0) {\n depression = 0;\n for (var i = 0; i < pavés_terrestres.length; i++) {\n minElevation = 10; \n pavés_terrestres[i].voisins.forEach(function(e) {\n if (pavés[e].elevation <= minElevation) {\n minElevation = pavés[e].elevation;\n minPavéIndex = e;\n }\n });\n if (pavés_terrestres[i].elevation <= pavés[minPavéIndex].elevation) {\n depression += 1;\n // on augmente l'élévation du pavé\n pavés_terrestres[i].elevation = pavés[minPavéIndex].elevation + 0.01;\n }\n }\n }\n}\n ","pinned":false,"hidden":false,"mode":"ojs"},{"id":264,"value":"md`Après ces corrections, nous pouvons déterminer les lignes de plus grande pente. On trie d'abord les pavés de terre afin que le plus haut soit en premier. On selectionne le pavé le plus bas parmi les pavés voisins du premier pavé terreste et on y attribue toutes les précipitations voisines, puis par itération on fait de même pour tous les pavés. Ainsi les pavés suivants, plus bas, recueillent de plus en plus de précipitations. Lorsque les précipitations dépassent une valeur seuil (par exemple 3), nous considérons que sur ce pavé coule une rivière.`","pinned":false,"hidden":false,"mode":"ojs"},{"id":267,"value":"md`Pour stocker les pavés de rivière, nous utilisons un tableau, qui contiendra non seulement l'index du pavé, mais aussi l'identifiant de la rivière (juste un entier) et le type c'est-à-dire, \"source\" pour les segments de rivière nouvellement définis et \"cours\" pour les segments durables.`","pinned":false,"hidden":false,"mode":"ojs"},{"id":270,"value":"md`Lorsque les précipitations doivent être attribuéesà un pavé sur lequel on a déjà identifié la présence d'une rivière et si la nouvelle rivière est plus longue que la rivière déjà identifiée alors nous réécrivons la rivière existante. Ainsi, nous pouvons suivre séparément le cours d'eau principal et les affluents.`","pinned":false,"hidden":false,"mode":"ojs"},{"id":273,"value":"md`Lorsque la rivière arrive à son exutoir, soit l'océan soit un lac, qu'il y a deux ou plusieurs pavés possibles qui peuvent servir de drain et que le flux est assez important, nous allons générer un delta de rivière. S'il n'y a qu'un pavé possible, nous marquerons le paé de déversement dans le tableau comme simple \"estuaire\".`","pinned":false,"hidden":false,"mode":"ojs"},{"id":255,"value":"compareElevation = (a, b) => {\n if (a.elevation < b.elevation) return 1;\n if (a.elevation > b.elevation) return -1;\n return 0;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":406,"value":"$33","pinned":false,"hidden":false,"mode":"ojs"},{"id":276,"value":"$34","pinned":false,"hidden":false,"mode":"ojs"},{"id":296,"value":"test = flux(carte, niveau_de_la_mer)","pinned":true,"hidden":false,"mode":"ojs"},{"id":327,"value":"testC=test.data.filter(function(d){ return (d.riviere == 1)})","pinned":false,"hidden":false,"mode":"ojs"},{"id":419,"value":"$35","pinned":false,"hidden":false,"mode":"ojs"},{"id":331,"value":"dessineLitDeRiviere = (svg, size, data, index) => {\n var dataRiviere = data.filter(function(d){ return (d.riviere == index)})\n var scaleX = d3.scaleLinear().domain([0, size[0]]).range([0, size[0]]);\n var scaleY = d3.scaleLinear().domain([0, size[1]]).range([0, size[1]]);\n var path = d3.line()\n .x(function(d) { return scaleX(d.x);})\n .y(function(d) { return scaleY(d.y);});\n\n svg.append(\"path\")\n .attr(\"class\", \"rivage\")\n .attr(\"fill\", \"none\")\n .attr(\"stroke\", \"seagreen\")\n .attr(\"stroke-width\", 2)\n .attr(\"stroke-opacity\", 0.9)\n .attr(\"stroke-linecap\",\"round\")\n .attr(\"stroke-linejoin\",\"round\")\n .attr(\"d\", path(dataRiviere));\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":334,"value":"$36","pinned":false,"hidden":false,"mode":"ojs"},{"id":14,"value":"md`#### Importation des libraries utiles`","pinned":false,"hidden":false,"mode":"ojs"},{"id":15,"value":"d3 = require(\"d3@5\")","pinned":false,"hidden":false,"mode":"ojs"},{"id":17,"value":"import {button, slider, number, checkbox} from \"@jashkenas/inputs\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":19,"value":"import {Navigation, Separation, chargeJSON} from \"@linard-y/gpc-fonctions-annexes\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":68,"value":"import {creeVoronoi} from \"@linard-y/gpc-etape-1\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":71,"value":"import {chargePavage, Pavage} from \"@linard-y/gpc-etape-2\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":234,"value":"import {identifierElements, identifierRivage, creerLigneDeCotesContinue, dessineBasiqueRivage} from \"@linard-y/gpc-etape-3\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":171,"value":"import {legend} from \"@d3/color-legend\"","pinned":false,"hidden":false,"mode":"ojs"}],"files":"$W37","stdlib":"1","titling":"auto"}} 2f:"$2e:body"