Accompagnement académique
IPR Référent : Sylvain André
Contacts : Dominique Raveneau, dominique.raveneau@ac-orleans-tours.fr
Alexandra Gondonneau, Alexandra.Gondonneau@ac-orleans-tours.fr
{"map_options":{"center_lat":"48.334097","center_lng":"0.835571","zoom":7,"map_type_id":"HYBRID","center_by_nearest":false,"fit_bounds":false,"center_circle_fillcolor":"#8CAEF2","center_circle_strokecolor":"#8CAEF2","show_center_circle":false,"show_center_marker":false,"center_marker_icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","draggable":true,"scroll_wheel":"true","gesture":"auto","marker_default_icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/11-generic.png","infowindow_setting":"<div class=\"fc-main\">\n<div class=\"fc-item-title\">{marker_title} <span class=\"fc-badge info\">{marker_category}<\/span><\/div>\n<div class=\"fc-item-featured_image\">{marker_image} <\/div>\n<p>{marker_message}<\/p>\n<address><b>Address : <\/b>{marker_address}<\/address>\n<\/div>\n","infowindow_geotags_setting":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">{post_title}<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                {post_excerpt}\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div>{post_featured_image}<div id=\"contenu_article\">{post_content}<\/div><\/div>","infowindow_skin":{"name":"default","type":"infowindow","sourcecode":"&lt;div class=&quot;fc-main&quot;&gt;&lt;div class=&quot;fc-item-title&quot;&gt;{marker_title} &lt;span class=&quot;fc-badge info&quot;&gt;{marker_category}&lt;\/span&gt;&lt;\/div&gt; &lt;div class=&quot;fc-item-featured_image&quot;&gt;{marker_image} &lt;\/div&gt;{marker_message}&lt;address&gt;&lt;b&gt;Address : &lt;\/b&gt;{marker_address}&lt;\/address&gt;&lt;\/div&gt;"},"infowindow_post_skin":{"name":"udine","type":"post","sourcecode":"&lt;div class=&quot;fc-item-box fc-item-no-padding&quot;&gt;\r\n    &lt;div class=&quot;fc-itemcontent-padding&quot;&gt;\r\n        &lt;div class=&quot;fc-item-padding-content_20&quot;&gt;\r\n            &lt;div class=&quot;fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center&quot;&gt;&lt;\/div&gt;\r\n            &lt;div class=&quot;fc-item-title fc-item-primary-text-color fc-text-center&quot;&gt;{post_title}&lt;\/div&gt;\r\n            &lt;div class=&quot;fc-item-content fc-item-body-text-color fc-item-top-space&quot;&gt;\r\n                {post_excerpt}\r\n&lt;p style=&quot;text-align:center;&quot;&gt;&lt;button onclick=&quot;javascript:affiche_post();&quot;&gt;EN SAVOIR PLUS&lt;\/button&gt;&lt;\/p&gt;\r\n            &lt;\/div&gt;\r\n        &lt;\/div&gt;\r\n    &lt;\/div&gt;\r\n&lt;\/div&gt;\r\n&lt;div id=&quot;contenu_post&quot; style=&quot;display:none;&quot;&gt;&lt;div id=&quot;btFermePost&quot;&gt;&lt;button onclick=&quot;javascript:fermer_post();&quot;&gt;&lt;small&gt;Fermer&lt;\/small&gt;&lt;\/button&gt;&lt;\/div&gt;{post_featured_image}&lt;div id=&quot;contenu_article&quot;&gt;{post_content}&lt;\/div&gt;&lt;\/div&gt;"},"infowindow_drop_animation":false,"close_infowindow_on_map_click":false,"default_infowindow_open":false,"infowindow_open_event":"mouseover","infowindow_filter_only":false,"infowindow_click_change_zoom":0,"infowindow_click_change_center":false,"full_screen_control":false,"search_control":true,"zoom_control":true,"map_type_control":false,"street_view_control":false,"locateme_control":false,"mobile_specific":false,"zoom_mobile":5,"draggable_mobile":true,"scroll_wheel_mobile":true,"full_screen_control_position":"TOP_RIGHT","search_control_position":"TOP_LEFT","locateme_control_position":"TOP_LEFT","zoom_control_position":"TOP_LEFT","map_type_control_position":"TOP_RIGHT","map_type_control_style":"HORIZONTAL_BAR","street_view_control_position":"TOP_LEFT","map_control":false,"screens":{"smartphones":{"map_zoom_level_mobile":"5"},"ipads":{"map_zoom_level_mobile":"5"},"large-screens":{"map_zoom_level_mobile":"5"}},"map_infowindow_customisations":false,"infowindow_width":"100%","infowindow_border_color":"rgba(0, 0, 0, 0.0980392)","infowindow_bg_color":"#fff","show_infowindow_header":false,"min_zoom":"0","max_zoom":"19","zoom_level_after_search":"10","url_filters":false,"doubleclickzoom":false,"current_post_only":false,"bound_map_after_filter":true,"display_reset_button":true,"map_reset_button_text":"R\u00e9initialiser","height":"600"},"places":[{"source":"post","title":"Berge de Arcisses","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Arcisses<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Arcisses \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nBerge de Arcisses<\/h2>\n<p>Latitude : 48.334097|Longitude : 0.835571<br \/>Commune : Arcisses<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Arcisses \u2022 2023-2024","address":"","location":{"lat":"48.334097","lng":"0.835571","redirect_custom_link":"","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-arcisses\/","zoom":7,"extra_fields":{"post_excerpt":"Arcisses \u2022 2023-2024","post_content":"<h2 class=\"site\">\nBerge de Arcisses<\/h2>\n<p>Latitude : 48.334097|Longitude : 0.835571<br \/>Commune : Arcisses<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"Berge de Arcisses","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-arcisses\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.334097","%_wpgmp_metabox_longitude%":"0.835571","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_33","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":14287,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category","extension_fields":{"cat_order":""}}]},{"source":"post","title":"Coll\u00e8ge Marcel Proust","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Marcel Proust<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\u00e8me \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Marcel Proust<\/h2>\n<p>Commune\u00a0: Illiers-Combray<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>60 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge de Arcisses. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"5\u00e8me \u2022 2023-2024","location":{"lat":"48.301858074857456","lng":"1.247728533335375","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-marcel-proust\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2023-2024","post_content":"<h2>Coll\u00e8ge Marcel Proust<\/h2>\n<p>Commune\u00a0: Illiers-Combray<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>60 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge de Arcisses. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"Coll\u00e8ge Marcel Proust","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-marcel-proust\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.301858074857456","%_wpgmp_metabox_longitude%":"1.247728533335375","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_33#","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":14288,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Plage du lac d&rsquo;auron","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Plage du lac d&rsquo;auron<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Bourges \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nPlage du lac d'auron<\/h2>\n<p>Latitude : 47.055589243855366|Longitude : 2.3976105900866074<br \/>Commune : Bourges<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Or-34BM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Bourges \u2022 2023-2024","location":{"lat":"47.055589243855366","lng":"2.3976105900866074","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-lac-dauron\/","zoom":7,"extra_fields":{"post_excerpt":"Bourges \u2022 2023-2024","post_content":"<h2 class=\"site\">\nPlage du lac d'auron<\/h2>\n<p>Latitude : 47.055589243855366|Longitude : 2.3976105900866074<br \/>Commune : Bourges<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Or-34BM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage du lac d&rsquo;auron","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-lac-dauron\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.055589243855366","%_wpgmp_metabox_longitude%":"2.3976105900866074","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_34","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":14289,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Saint Exup\u00e9ry","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Saint Exup\u00e9ry<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Classe de 4e \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Saint Exup\u00e9ry<\/h2>\n<p>Commune\u00a0: Bourges<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>28 \u00e9l\u00e8ves de Classe de 4e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage du lac d'auron.<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Or-34BM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Classe de 4e \u2022 2023-2024","location":{"lat":"47.07838543403887","lng":"2.3815446026474145","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-exupery-4\/","zoom":7,"extra_fields":{"post_excerpt":"Classe de 4e \u2022 2023-2024","post_content":"<h2>Coll\u00e8ge Saint Exup\u00e9ry<\/h2>\n<p>Commune\u00a0: Bourges<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>28 \u00e9l\u00e8ves de Classe de 4e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage du lac d'auron.<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Or-34BM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Saint Exup\u00e9ry","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-exupery-4\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.07838543403887","%_wpgmp_metabox_longitude%":"2.3815446026474145","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_34#","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":14290,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Berge d&rsquo;Aubigny sur N\u00e8re","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge d&rsquo;Aubigny sur N\u00e8re<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Aubigny sur N\u00e8re \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nBerge d'Aubigny sur N\u00e8re<\/h2>\n<p>Latitude : 47.488008|Longitude : 2.440939<br \/>Commune : Aubigny sur N\u00e8re<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Or-35BM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Aubigny sur N\u00e8re \u2022 2023-2024","location":{"lat":"47.488008","lng":"2.440939","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-daubigny-sur-nere\/","zoom":7,"extra_fields":{"post_excerpt":"Aubigny sur N\u00e8re \u2022 2023-2024","post_content":"<h2 class=\"site\">\nBerge d'Aubigny sur N\u00e8re<\/h2>\n<p>Latitude : 47.488008|Longitude : 2.440939<br \/>Commune : Aubigny sur N\u00e8re<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Or-35BM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Berge d&rsquo;Aubigny sur N\u00e8re","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-daubigny-sur-nere\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.488008","%_wpgmp_metabox_longitude%":"2.440939","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_35","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":14291,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge G\u00e9rard Philipe","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge G\u00e9rard Philipe<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2 classes de 5e \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge G\u00e9rard Philipe<\/h2>\n<p>Commune\u00a0: AUBIGNY SUR NERE<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>56 \u00e9l\u00e8ves de 2 classes de 5e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge d'Aubigny sur N\u00e8re. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Or-35BM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2 classes de 5e \u2022 2023-2024","location":{"lat":"47.484627903379355","lng":"2.4345028621713696","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-gerard-philipe-2\/","zoom":7,"extra_fields":{"post_excerpt":"2 classes de 5e \u2022 2023-2024","post_content":"<h2>Coll\u00e8ge G\u00e9rard Philipe<\/h2>\n<p>Commune\u00a0: AUBIGNY SUR NERE<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>56 \u00e9l\u00e8ves de 2 classes de 5e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge d'Aubigny sur N\u00e8re. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Or-35BM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge G\u00e9rard Philipe","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-gerard-philipe-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.484627903379355","%_wpgmp_metabox_longitude%":"2.4345028621713696","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_35#","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":14292,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Jean Roux","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Jean Roux<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2021-2022-2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Jean Roux\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_21-22_Or_26_Photo_collecte-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Jean Roux<\/h2>\n<p>Commune\u00a0: Fondettes<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>10 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont Mirabeaux\".<\/p><ul>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>20 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de Saint-Cosme\".<\/p><ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-26FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-26FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Fondettes\" de la commune de Fondettes. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2021-2022-2023-2024","location":{"lat":"47.7213616569668","lng":"1.9428984283905917","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-roux\/","zoom":7,"extra_fields":{"post_excerpt":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2021-2022-2023-2024","post_content":"<h2>Coll\u00e8ge Jean Roux<\/h2>\n<p>Commune\u00a0: Fondettes<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>10 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont Mirabeaux\".<\/p><ul>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>20 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de Saint-Cosme\".<\/p><ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-26FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-26FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Fondettes\" de la commune de Fondettes. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Jean Roux","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-roux\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Jean Roux\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_21-22_Or_26_Photo_collecte-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.7213616569668","%_wpgmp_metabox_longitude%":"1.9428984283905917","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_20#","%_wp_page_template%":"default","%_thumbnail_id%":"11368","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022, 2022-2023, 2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":6687,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022","2022-2023","2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Berge de Ch\u00e2tillon sur Loire","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Ch\u00e2tillon sur Loire<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Ch\u00e2tillon sur Loire \u2022 2022-2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Ch\u00e2tillon sur Loire\" width=\"300\" height=\"138\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-24_1-PhotoSitebis-300x138.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Ch\u00e2tillon sur Loire<\/h2>\n<p>Latitude : 47.598801N | Longitude : 2.760718E<br \/>Commune : Ch\u00e2tillon sur Loire<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-24FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-24Fs.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-24FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-24FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Ch\u00e2tillon sur Loire \u2022 2022-2023-2024","location":{"lat":"47.598801","lng":"2.760718","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-chatillon-sur-loire\/","zoom":7,"extra_fields":{"post_excerpt":"Ch\u00e2tillon sur Loire \u2022 2022-2023-2024","post_content":"<h2 class=\"site\">Berge de Ch\u00e2tillon sur Loire<\/h2>\n<p>Latitude : 47.598801N | Longitude : 2.760718E<br \/>Commune : Ch\u00e2tillon sur Loire<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-24FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-24Fs.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-24FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-24FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Berge de Ch\u00e2tillon sur Loire","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-chatillon-sur-loire\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Ch\u00e2tillon sur Loire\" width=\"300\" height=\"138\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-24_1-PhotoSitebis-300x138.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.598801","%_wpgmp_metabox_longitude%":"2.760718","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_22-23_Or_24","%_wp_page_template%":"default","%_thumbnail_id%":"11366","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2022-2023, 2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":8683,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2022-2023","2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Pierre D\u00e9zarnaulds","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Pierre D\u00e9zarnaulds<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\u00e8me \u2022 2022-2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Pierre D\u00e9zarnaulds\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-24-photoeleves1-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Pierre D\u00e9zarnaulds<\/h2>\n<p>Commune\u00a0: Ch\u00e2tillon sur Loire<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>57 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Ch\u00e2tillon sur Loire\".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-24FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-24Fs.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>84 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Ch\u00e2tillon sur Loire\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-24FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-24FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2022-2023-2024","location":{"lat":"47.59095194428039","lng":"2.744436326761216","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-pierre-dezarnaulds\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2022-2023-2024","post_content":"<h2>Coll\u00e8ge Pierre D\u00e9zarnaulds<\/h2>\n<p>Commune\u00a0: Ch\u00e2tillon sur Loire<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>57 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Ch\u00e2tillon sur Loire\".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-24FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-24Fs.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>84 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Ch\u00e2tillon sur Loire\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-24FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-24FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Pierre D\u00e9zarnaulds","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-pierre-dezarnaulds\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Pierre D\u00e9zarnaulds\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-24-photoeleves1-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.59095194428039","%_wpgmp_metabox_longitude%":"2.744436326761216","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_22-23_Or_24#","%_wp_page_template%":"default","%_thumbnail_id%":"11365","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2022-2023, 2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":8684,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2022-2023","2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Lyc\u00e9e Balzac","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Balzac<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Terminale \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Balzac<\/h2>\n<p>Commune\u00a0: TOURS<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>35 \u00e9l\u00e8ves de Terminale<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Ile  de la M\u00e9tairie. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Terminale \u2022 2023-2024","location":{"lat":"47.387693319504336","lng":"0.6870952544565809","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-balzac-2\/","zoom":7,"extra_fields":{"post_excerpt":"Terminale \u2022 2023-2024","post_content":"<h2>Lyc\u00e9e Balzac<\/h2>\n<p>Commune\u00a0: TOURS<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>35 \u00e9l\u00e8ves de Terminale<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Ile  de la M\u00e9tairie. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Balzac","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-balzac-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.387693319504336","%_wpgmp_metabox_longitude%":"0.6870952544565809","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_3#","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":14278,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Pont Mirabeau","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Pont Mirabeau<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Tours \u2022 2021-2022-2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Pont Mirabeau<\/h2>\n<p>Latitude : 47.398174\u00b0N | Longitude : 0.69821964\u00b0E<br \/>Commune : Tours<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne avant fin juin 2024.<\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_9FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_9FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_9FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Tours \u2022 2021-2022-2023-2024","location":{"lat":"47.39817443490501","lng":"0.6982196459906248","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-mirabeau\/","zoom":7,"extra_fields":{"post_excerpt":"Tours \u2022 2021-2022-2023-2024","post_content":"<h2 class=\"site\">Pont Mirabeau<\/h2>\n<p>Latitude : 47.398174\u00b0N | Longitude : 0.69821964\u00b0E<br \/>Commune : Tours<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne avant fin juin 2024.<\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_9FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_9FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_9FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Pont Mirabeau","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-mirabeau\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.39817443490501","%_wpgmp_metabox_longitude%":"0.6982196459906248","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_9","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022, 2022-2023, 2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":5346,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022","2022-2023","2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Ile de la Noiraye (Est)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Ile de la Noiraye (Est)<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Nazelles-N\u00e9gron \u2022 2021-2022-2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ile de la Noiraye (Est)\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-14-1_Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Ile de la Noiraye (Est)<\/h2>\n<p>Latitude : 47.4141956\u00b0N | Longitude : 0.97395\u00b0E<br \/>Commune : Nazelles-N\u00e9gron<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-14FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-14FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-14FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_14FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_14FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_14FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Nazelles-N\u00e9gron \u2022 2021-2022-2023-2024","location":{"lat":"47.41419560322265","lng":"0.9739553802532323","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ile-de-la-noiraye-est\/","zoom":7,"extra_fields":{"post_excerpt":"Nazelles-N\u00e9gron \u2022 2021-2022-2023-2024","post_content":"<h2 class=\"site\">Ile de la Noiraye (Est)<\/h2>\n<p>Latitude : 47.4141956\u00b0N | Longitude : 0.97395\u00b0E<br \/>Commune : Nazelles-N\u00e9gron<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-14FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-14FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-14FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_14FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_14FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_14FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Ile de la Noiraye (Est)","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ile-de-la-noiraye-est\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ile de la Noiraye (Est)\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-14-1_Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_old_slug%":"ile-de-la-noiraye","%_wpgmp_metabox_latitude%":"47.41419560322265","%_wpgmp_metabox_longitude%":"0.9739553802532323","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_14","%_wp_page_template%":"default","%_thumbnail_id%":"11359","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022, 2022-2023, 2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":5356,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022","2022-2023","2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Malraux","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Malraux<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\u00e8me \u2022 2021-2022-2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Malraux\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-14-3_Photo_pollutionSite-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Malraux<\/h2>\n<p>Commune\u00a0: Amboise<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>130 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la Noiraye (Est)\" de la commune d'Amboise.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-14FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>120 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la Noiraye (Est)\" de la commune d'Amboise.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-14FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-14FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>100 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la Noiraye (Est)\" de la commune d'Amboise.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_14FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_14FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_14FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2021-2022-2023-2024","location":{"lat":"47.39714214988455","lng":"0.9850247938622496","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-malraux\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2021-2022-2023-2024","post_content":"<h2>Coll\u00e8ge Malraux<\/h2>\n<p>Commune\u00a0: Amboise<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>130 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la Noiraye (Est)\" de la commune d'Amboise.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-14FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>120 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la Noiraye (Est)\" de la commune d'Amboise.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-14FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-14FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>100 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la Noiraye (Est)\" de la commune d'Amboise.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_14FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_14FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_14FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Malraux","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-malraux\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Malraux\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-14-3_Photo_pollutionSite-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_old_slug%":"lycee-sainte-marguerite","%_wpgmp_metabox_latitude%":"47.39714214988455","%_wpgmp_metabox_longitude%":"0.9850247938622496","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_14#","%_wp_page_template%":"default","%_thumbnail_id%":"11358","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022, 2022-2023, 2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":5357,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022","2022-2023","2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Berge de Luynes","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Luynes<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Luynes \u2022 2021-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Luynes\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Or_15-Photo_PollutionSite-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Luynes<\/h2>\n<p>Latitude : 47.376194\u00b0N | Longitude : 0.57116\u00b0E<br \/>Commune : Luynes<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Or-15BM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-15FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_15FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Luynes \u2022 2021-2024","location":{"lat":"47.376194","lng":"0.57116","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-luynes\/","zoom":7,"extra_fields":{"post_excerpt":"Luynes \u2022 2021-2024","post_content":"<h2 class=\"site\">Berge de Luynes<\/h2>\n<p>Latitude : 47.376194\u00b0N | Longitude : 0.57116\u00b0E<br \/>Commune : Luynes<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Or-15BM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-15FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_15FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Berge de Luynes","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-luynes\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Luynes\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Or_15-Photo_PollutionSite-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.376194","%_wpgmp_metabox_longitude%":"0.57116","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_15","%_wp_page_template%":"default","%_thumbnail_id%":"11361","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022, 2022-2023, 2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":5358,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022","2022-2023","2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge P. de Commynes","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge P. de Commynes<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\u00e8me et 5\u00e8me \u2022 2021-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge P. de Commynes\" width=\"300\" height=\"164\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Or_15-Photo_VracMacro-300x164.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge P. de Commynes<\/h2>\n<p>Commune\u00a0: Tours<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>58 \u00e9l\u00e8ves de 6\u00e8me et 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Luynes\" de la commune de Luynes.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Or-15BM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>55 \u00e9l\u00e8ves de 6\u00e8me et 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Luynes\" de la commune de Luynes.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-15FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>90 \u00e9l\u00e8ves de 6\u00e8me et 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Luynes\" de la commune de Luynes. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_15FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me et 5\u00e8me \u2022 2021-2024","location":{"lat":"47.366431634535765","lng":"0.7033647085007357","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-p-de-commynes\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me et 5\u00e8me \u2022 2021-2024","post_content":"<h2>Coll\u00e8ge P. de Commynes<\/h2>\n<p>Commune\u00a0: Tours<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>58 \u00e9l\u00e8ves de 6\u00e8me et 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Luynes\" de la commune de Luynes.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Or-15BM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>55 \u00e9l\u00e8ves de 6\u00e8me et 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Luynes\" de la commune de Luynes.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-15FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>90 \u00e9l\u00e8ves de 6\u00e8me et 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Luynes\" de la commune de Luynes. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_15FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge P. de Commynes","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-p-de-commynes\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge P. de Commynes\" width=\"300\" height=\"164\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Or_15-Photo_VracMacro-300x164.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.366431634535765","%_wpgmp_metabox_longitude%":"0.7033647085007357","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_15#","%_wp_page_template%":"default","%_thumbnail_id%":"11360","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022, 2022-2023, 2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":5359,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022","2022-2023","2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Ile de la M\u00e9tairie","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Ile de la M\u00e9tairie<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Talmont Saint-Hilaire \u2022 2019-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ile de la M\u00e9tairie\" width=\"300\" height=\"139\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/Or-3-Photo-laisse-300x139.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Ile de la M\u00e9tairie<\/h2>\n<p>Latitude : 47.407933\u00b0N | Longitude : 0.774336\u00b0E<br \/>Commune : Ville-aux-Dames<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e 2019-2020<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_3_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_3_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_3_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Talmont Saint-Hilaire \u2022 2019-2024","location":{"lat":"47.407933","lng":"0.774336","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ile-de-la-metairie\/","zoom":7,"extra_fields":{"post_excerpt":"Talmont Saint-Hilaire \u2022 2019-2024","post_content":"<h2 class=\"site\">Ile de la M\u00e9tairie<\/h2>\n<p>Latitude : 47.407933\u00b0N | Longitude : 0.774336\u00b0E<br \/>Commune : Ville-aux-Dames<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Or-3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e 2019-2020<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_3_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_3_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_3_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Ile de la M\u00e9tairie","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ile-de-la-metairie\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ile de la M\u00e9tairie\" width=\"300\" height=\"139\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/Or-3-Photo-laisse-300x139.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.407933","%_wpgmp_metabox_longitude%":"0.774336","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_19-20_Or_3","%_wp_page_template%":"default","%_thumbnail_id%":"4191","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2019-2020, 2020-2021, 2021-2022, 2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4204,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2019-2020","2020-2021","2021-2022","2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Pierre Corneille","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Pierre Corneille<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Eco-d\u00e9l\u00e9gu\u00e9.e.s \u2022 2019-2020-2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Pierre Corneille\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_3_photo_classe.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Pierre Corneille<\/h2>\n<p>Commune : Tours<br \/>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>20 \u00e9l\u00e8ves \u00e9co-d\u00e9l\u00e9gu\u00e9.e.s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la M\u00e9tairie\" de la commune la Ville-aux-Dames. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<h3>\n<h4>24 \u00e9l\u00e8ves de 5\u00e8me<h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la M\u00e9tairie\" de la commune la Ville-aux-Dames.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2019-2020<h3>\n<h4>21 \u00e9l\u00e8ves de 5\u00e8me<h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la M\u00e9tairie\" de la commune la Ville-aux-Dames.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_3_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_3_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_3_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Eco-d\u00e9l\u00e9gu\u00e9.e.s \u2022 2019-2020-2021-2022","location":{"lat":"47.376519412556725","lng":"0.7309864407044234","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-pierre-corneille\/","zoom":7,"extra_fields":{"post_excerpt":"Eco-d\u00e9l\u00e9gu\u00e9.e.s \u2022 2019-2020-2021-2022","post_content":"<h2>Coll\u00e8ge Pierre Corneille<\/h2>\n<p>Commune : Tours<br \/>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>20 \u00e9l\u00e8ves \u00e9co-d\u00e9l\u00e9gu\u00e9.e.s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la M\u00e9tairie\" de la commune la Ville-aux-Dames. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<h3>\n<h4>24 \u00e9l\u00e8ves de 5\u00e8me<h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la M\u00e9tairie\" de la commune la Ville-aux-Dames.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_3FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2019-2020<h3>\n<h4>21 \u00e9l\u00e8ves de 5\u00e8me<h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la M\u00e9tairie\" de la commune la Ville-aux-Dames.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_3_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_3_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_3_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Pierre Corneille","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-pierre-corneille\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Pierre Corneille\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_3_photo_classe.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.376519412556725","%_wpgmp_metabox_longitude%":"0.7309864407044234","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_19-20_Or_3#","%_wp_page_template%":"default","%_thumbnail_id%":"1695","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2019-2020, 2020-2021, 2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4205,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2019-2020","2020-2021","2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Berge de Bourges","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Bourges<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                BOURGES \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nBerge de Bourges<\/h2>\n<p>Latitude : 47.086156|Longitude : 2.357744<br \/>Commune : BOURGES<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"BOURGES \u2022 2023-2024","location":{"lat":"47.086156","lng":"2.357744","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-bourges\/","zoom":7,"extra_fields":{"post_excerpt":"BOURGES \u2022 2023-2024","post_content":"<h2 class=\"site\">\nBerge de Bourges<\/h2>\n<p>Latitude : 47.086156|Longitude : 2.357744<br \/>Commune : BOURGES<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"Berge de Bourges","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-bourges\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.086156","%_wpgmp_metabox_longitude%":"2.357744","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_28","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":12865,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"lyc\u00e9e professionnel Jean Mermoz","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">lyc\u00e9e professionnel Jean Mermoz<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3\u00e8me \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>lyc\u00e9e professionnel Jean Mermoz<\/h2>\n<p>Commune\u00a0: Bourges<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>24 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge de Bourges. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"3\u00e8me \u2022 2023-2024","location":{"lat":"47.10063324957073","lng":"2.422246996766095","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-professionnel-jean-mermoz\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me \u2022 2023-2024","post_content":"<h2>lyc\u00e9e professionnel Jean Mermoz<\/h2>\n<p>Commune\u00a0: Bourges<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>24 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge de Bourges. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"lyc\u00e9e professionnel Jean Mermoz","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-professionnel-jean-mermoz\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.10063324957073","%_wpgmp_metabox_longitude%":"2.422246996766095","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_28#","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":12866,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Pont de Chinon","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Pont de Chinon<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Cuffy \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nPont de Chinon<\/h2>\n<p>Latitude : 47.164854|Longitude : 0.237098<br \/>Commune : Cuffy<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Cuffy \u2022 2023-2024","location":{"lat":"47.164854","lng":"0.237098","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-de-chinon\/","zoom":7,"extra_fields":{"post_excerpt":"Cuffy \u2022 2023-2024","post_content":"<h2 class=\"site\">\nPont de Chinon<\/h2>\n<p>Latitude : 47.164854|Longitude : 0.237098<br \/>Commune : Cuffy<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"Pont de Chinon","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-de-chinon\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.164854","%_wpgmp_metabox_longitude%":"0.237098","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_29","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":12867,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Lyc\u00e9e Rabelais","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Rabelais<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Rabelais<\/h2>\n<p>Commune\u00a0: CHINON<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Pont de Chinon. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"2nde \u2022 2023-2024","location":{"lat":"47.16272185555299","lng":"0.23426418327894008","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-rabelais\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2023-2024","post_content":"<h2>Lyc\u00e9e Rabelais<\/h2>\n<p>Commune\u00a0: CHINON<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Pont de Chinon. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"Lyc\u00e9e Rabelais","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-rabelais\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.16272185555299","%_wpgmp_metabox_longitude%":"0.23426418327894008","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_29#","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":12868,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Berge de Charg\u00e9","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Charg\u00e9<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Charg\u00e9 \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nBerge de Charg\u00e9<\/h2>\n<p>Latitude : 47.43603|Longitude : 1.02622<br \/>Commune : Charg\u00e9<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Charg\u00e9 \u2022 2023-2024","location":{"lat":"47.43603","lng":"1.02622","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-charge\/","zoom":7,"extra_fields":{"post_excerpt":"Charg\u00e9 \u2022 2023-2024","post_content":"<h2 class=\"site\">\nBerge de Charg\u00e9<\/h2>\n<p>Latitude : 47.43603|Longitude : 1.02622<br \/>Commune : Charg\u00e9<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"Berge de Charg\u00e9","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-charge\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.43603","%_wpgmp_metabox_longitude%":"1.02622","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_30","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":12869,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Lyc\u00e9e Th\u00e9r\u00e8e Planiol","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Th\u00e9r\u00e8e Planiol<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                1\u00e8re Bac Pro menuisier agenceur + d\u00e9colletage + Eco d\u00e9l\u00e9gu\u00e9s \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Th\u00e9r\u00e8e Planiol<\/h2>\n<p>Commune\u00a0: Loches<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>15 \u00e9l\u00e8ves de 1\u00e8re Bac Pro menuisier agenceur + d\u00e9colletage + Eco d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge de Charg\u00e9. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"1\u00e8re Bac Pro menuisier agenceur + d\u00e9colletage + Eco d\u00e9l\u00e9gu\u00e9s \u2022 2023-2024","location":{"lat":"47.12723300633319","lng":"0.9812754970035199","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-theree-planiol\/","zoom":7,"extra_fields":{"post_excerpt":"1\u00e8re Bac Pro menuisier agenceur + d\u00e9colletage + Eco d\u00e9l\u00e9gu\u00e9s \u2022 2023-2024","post_content":"<h2>Lyc\u00e9e Th\u00e9r\u00e8e Planiol<\/h2>\n<p>Commune\u00a0: Loches<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>15 \u00e9l\u00e8ves de 1\u00e8re Bac Pro menuisier agenceur + d\u00e9colletage + Eco d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge de Charg\u00e9. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"Lyc\u00e9e Th\u00e9r\u00e8e Planiol","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-theree-planiol\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.12723300633319","%_wpgmp_metabox_longitude%":"0.9812754970035199","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_30#","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":12870,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Berge d&rsquo;Orl\u00e9ans","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge d&rsquo;Orl\u00e9ans<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Orl\u00e9ans \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nBerge d'Orl\u00e9ans<\/h2>\n<p>Latitude : 47.895463|Longitude : 1.908636<br \/>Commune : Orl\u00e9ans<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Orl\u00e9ans \u2022 2023-2024","location":{"lat":"47.895463","lng":"1.908636","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-dorleans\/","zoom":7,"extra_fields":{"post_excerpt":"Orl\u00e9ans \u2022 2023-2024","post_content":"<h2 class=\"site\">\nBerge d'Orl\u00e9ans<\/h2>\n<p>Latitude : 47.895463|Longitude : 1.908636<br \/>Commune : Orl\u00e9ans<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"Berge d&rsquo;Orl\u00e9ans","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-dorleans\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.895463","%_wpgmp_metabox_longitude%":"1.908636","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_31","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":12871,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Sainte Croix Saint Euverte","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Sainte Croix Saint Euverte<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5e \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Sainte Croix Saint Euverte<\/h2>\n<p>Commune\u00a0: ORL\u00c9ANS<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>37 \u00e9l\u00e8ves de 5e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge d'Orl\u00e9ans. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"5e \u2022 2023-2024","location":{"lat":"47.91132440654857","lng":"1.900307356343631","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-sainte-croix-saint-euverte\/","zoom":7,"extra_fields":{"post_excerpt":"5e \u2022 2023-2024","post_content":"<h2>Coll\u00e8ge Sainte Croix Saint Euverte<\/h2>\n<p>Commune\u00a0: ORL\u00c9ANS<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>37 \u00e9l\u00e8ves de 5e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge d'Orl\u00e9ans. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"Coll\u00e8ge Sainte Croix Saint Euverte","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-sainte-croix-saint-euverte\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.91132440654857","%_wpgmp_metabox_longitude%":"1.900307356343631","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_31#","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":12872,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Peuplier noir Liard","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Peuplier noir Liard<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Orl\u00e9ans \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nPeuplier noir Liard<\/h2>\n<p>Latitude : 47.3951|Longitude : 0.66973<br \/>Commune : Orl\u00e9ans<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Orl\u00e9ans \u2022 2023-2024","location":{"lat":"47.3951","lng":"0.66973","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/peuplier-noir-liard\/","zoom":7,"extra_fields":{"post_excerpt":"Orl\u00e9ans \u2022 2023-2024","post_content":"<h2 class=\"site\">\nPeuplier noir Liard<\/h2>\n<p>Latitude : 47.3951|Longitude : 0.66973<br \/>Commune : Orl\u00e9ans<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"Peuplier noir Liard","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/peuplier-noir-liard\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.3951","%_wpgmp_metabox_longitude%":"0.66973","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_32","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":12873,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Lycee Albert Bayet","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lycee Albert Bayet<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3\u00e8me \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lycee Albert Bayet<\/h2>\n<p>Commune\u00a0: Tours<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>24 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Peuplier noir Liard. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"3\u00e8me \u2022 2023-2024","location":{"lat":"47.394044733099015","lng":"0.6714014967843349","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-albert-bayet\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me \u2022 2023-2024","post_content":"<h2>Lycee Albert Bayet<\/h2>\n<p>Commune\u00a0: Tours<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>24 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Peuplier noir Liard. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"Lycee Albert Bayet","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-albert-bayet\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.394044733099015","%_wpgmp_metabox_longitude%":"0.6714014967843349","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_32#","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":12874,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Berge de Cuffy","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Cuffy<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Cuffy \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nBerge de Cuffy<\/h2>\n<p>Latitude : 46.959418728750805|Longitude : 3.07679523004746<br \/>Commune : Cuffy<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Cuffy \u2022 2023-2024","location":{"lat":"46.959418728750805","lng":"3.07679523004746","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-cuffy\/","zoom":7,"extra_fields":{"post_excerpt":"Cuffy \u2022 2023-2024","post_content":"<h2 class=\"site\">\nBerge de Cuffy<\/h2>\n<p>Latitude : 46.959418728750805|Longitude : 3.07679523004746<br \/>Commune : Cuffy<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"Berge de Cuffy","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-cuffy\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"46.959418728750805","%_wpgmp_metabox_longitude%":"3.07679523004746","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_27","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":12863,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Max Jacob","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Max Jacob<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3\u00e8me \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Max Jacob<\/h2>\n<p>Commune\u00a0: St Jean de la Ruelle<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>40 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Ch\u00e9cy (Nord Ouest)\" de la commune de Ch\u00e9cy. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_17_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_17FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_17_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"3\u00e8me \u2022 2021-2022","location":{"lat":"47.91801571765325","lng":"1.8782653380455532","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-max-jacob\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Max Jacob<\/h2>\n<p>Commune\u00a0: St Jean de la Ruelle<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>40 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Ch\u00e9cy (Nord Ouest)\" de la commune de Ch\u00e9cy. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_17_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_17FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_17_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Max Jacob","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-max-jacob\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.91801571765325","%_wpgmp_metabox_longitude%":"1.8782653380455532","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_17#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":5363,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"lyc\u00e9e Alain Fournier","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">lyc\u00e9e Alain Fournier<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>lyc\u00e9e Alain Fournier<\/h2>\n<p>Commune\u00a0: Bourges<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>35 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge de Cuffy. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"2nde \u2022 2023-2024","location":{"lat":"47.101020764440015","lng":"2.412431539093452","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-alain-fournier\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2023-2024","post_content":"<h2>lyc\u00e9e Alain Fournier<\/h2>\n<p>Commune\u00a0: Bourges<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>35 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge de Cuffy. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"lyc\u00e9e Alain Fournier","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-alain-fournier\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.101020764440015","%_wpgmp_metabox_longitude%":"2.412431539093452","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_27#","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":12864,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Berge des deux lions","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge des deux lions<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Tours \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge des deux lions<\/h2>\n<p>Latitude : 47.36236\u00b0N | Longitude : 0.680503\u00b0E<br \/>Commune : Tours<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_18FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Tours \u2022 2021-2022","location":{"lat":"47.362361","lng":"0.680503","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-des-deux-lions\/","zoom":7,"extra_fields":{"post_excerpt":"Tours \u2022 2021-2022","post_content":"<h2 class=\"site\">Berge des deux lions<\/h2>\n<p>Latitude : 47.36236\u00b0N | Longitude : 0.680503\u00b0E<br \/>Commune : Tours<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_18FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Berge des deux lions","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-des-deux-lions\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.362361","%_wpgmp_metabox_longitude%":"0.680503","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_18","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":5364,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Jean Philippe Rameau","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Jean Philippe Rameau<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                4\u00e8me \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Jean Philippe Rameau<\/h2>\n<p>Commune\u00a0: Tours<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>28 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge des deux lions\" de la commune de Tours. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_18FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"4\u00e8me \u2022 2021-2022","location":{"lat":"47.36074739555249","lng":"0.7033456135299783","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-philippe-rameau\/","zoom":7,"extra_fields":{"post_excerpt":"4\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Jean Philippe Rameau<\/h2>\n<p>Commune\u00a0: Tours<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>28 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge des deux lions\" de la commune de Tours. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_18FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Jean Philippe Rameau","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-philippe-rameau\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.36074739555249","%_wpgmp_metabox_longitude%":"0.7033456135299783","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_18#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":5365,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Berge de Saint Aignan Le Jaillard","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Saint Aignan Le Jaillard<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Fert\u00e9-Saint-Aubin \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Saint Aignan Le Jaillard<\/h2>\n<p>Latitude : 47.767578\u00b0N | Longitude : 2.416734\u00b0E<br \/>Commune : Fert\u00e9-Saint-Aubin\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_19_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Fert\u00e9-Saint-Aubin \u2022 2021-2022","location":{"lat":"47.767578","lng":"2.416734","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-saint-aignan-le-jaillard\/","zoom":7,"extra_fields":{"post_excerpt":"Fert\u00e9-Saint-Aubin \u2022 2021-2022","post_content":"<h2 class=\"site\">Berge de Saint Aignan Le Jaillard<\/h2>\n<p>Latitude : 47.767578\u00b0N | Longitude : 2.416734\u00b0E<br \/>Commune : Fert\u00e9-Saint-Aubin\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_19_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Berge de Saint Aignan Le Jaillard","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-saint-aignan-le-jaillard\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.767578","%_wpgmp_metabox_longitude%":"2.416734","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_19","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":6684,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Le pr\u00e9 des rois","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Le pr\u00e9 des rois<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3\u00e8me \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Le pr\u00e9 des rois<\/h2>\n<p>Commune\u00a0:La Fert\u00e9-Saint-Aubin<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Saint Aignan Le Jaillard\" de la commune de Fert\u00e9-Saint-Aubin. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_19_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"3\u00e8me \u2022 2021-2022","location":{"lat":"47.72131835085844","lng":"1.9430164455759533","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-le-pre-des-rois\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Le pr\u00e9 des rois<\/h2>\n<p>Commune\u00a0:La Fert\u00e9-Saint-Aubin<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Saint Aignan Le Jaillard\" de la commune de Fert\u00e9-Saint-Aubin. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_19_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Le pr\u00e9 des rois","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-le-pre-des-rois\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.72131835085844","%_wpgmp_metabox_longitude%":"1.9430164455759533","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_19#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":6685,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Berge de Fondettes","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Fondettes<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Fondettes \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Fondettes<\/h2>\n<p>Latitude : 47.392453\u00b0N | Longitude : 0.646256\u00b0E<br \/>Commune : Fondettes<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Fondettes \u2022 2021-2022","location":{"lat":"47.392453","lng":"0.646256","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-fondettes\/","zoom":7,"extra_fields":{"post_excerpt":"Fondettes \u2022 2021-2022","post_content":"<h2 class=\"site\">Berge de Fondettes<\/h2>\n<p>Latitude : 47.392453\u00b0N | Longitude : 0.646256\u00b0E<br \/>Commune : Fondettes<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_20FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Berge de Fondettes","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-fondettes\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.392453","%_wpgmp_metabox_longitude%":"0.646256","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_20","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":6686,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Jargeau plage","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Jargeau plage<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Jargeau plage \u2022 2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Jargeau plage\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-21_photo_site1-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Jargeau plage<\/h2>\n<p>Latitude : 47.869259N | Longitude :  2.119891E<br \/>Commune : Jargeau plage<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-21FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-21FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Jargeau plage \u2022 2022-2023","location":{"lat":"47.869259","lng":"2.119891","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/jargeau-plage\/","zoom":7,"extra_fields":{"post_excerpt":"Jargeau plage \u2022 2022-2023","post_content":"<h2 class=\"site\">Jargeau plage<\/h2>\n<p>Latitude : 47.869259N | Longitude :  2.119891E<br \/>Commune : Jargeau plage<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-21FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-21FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Jargeau plage","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/jargeau-plage\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Jargeau plage\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-21_photo_site1-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.869259","%_wpgmp_metabox_longitude%":"2.119891","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_22-23_Or_21","%_wp_page_template%":"default","%_thumbnail_id%":"11362","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":8677,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Le Clos Ferbois","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Le Clos Ferbois<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Le Clos Ferbois\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-21_photo_site2-300x225.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Le Clos Ferbois<\/h2>\n<p>Commune\u00a0: Jargeau<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>23 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Jargeau plage\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-21FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-21FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023","location":{"lat":"47.86307264579658","lng":"2.120631111425899","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-le-clos-ferbois\/","zoom":7,"extra_fields":{"post_excerpt":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Le Clos Ferbois<\/h2>\n<p>Commune\u00a0: Jargeau<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>23 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Jargeau plage\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-21FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-21FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Le Clos Ferbois","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-le-clos-ferbois\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Le Clos Ferbois\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-21_photo_site2-300x225.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.86307264579658","%_wpgmp_metabox_longitude%":"2.120631111425899","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_22-23_Or_21#","%_wp_page_template%":"default","%_thumbnail_id%":"11363","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":8678,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Port de Varennes-sur-Loire","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Port de Varennes-sur-Loire<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Varennes-sur-Loire \u2022 2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Port de Varennes-sur-Loire\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-22-1_Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Port de Varennes-sur-Loire<\/h2>\n<p>Latitude : 47.220949N | Longitude :  0.058492E<br \/>Commune : Varennes-sur-Loire<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-22FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-22FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Varennes-sur-Loire \u2022 2022-2023","location":{"lat":"47.220949","lng":"0.058492","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/port-de-varennes-sur-loire\/","zoom":7,"extra_fields":{"post_excerpt":"Varennes-sur-Loire \u2022 2022-2023","post_content":"<h2 class=\"site\">Port de Varennes-sur-Loire<\/h2>\n<p>Latitude : 47.220949N | Longitude :  0.058492E<br \/>Commune : Varennes-sur-Loire<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-22FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-22FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Port de Varennes-sur-Loire","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/port-de-varennes-sur-loire\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Port de Varennes-sur-Loire\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-22-1_Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.220949","%_wpgmp_metabox_longitude%":"0.058492","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_22-23_Or_22","%_wp_page_template%":"default","%_thumbnail_id%":"11364","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":8679,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Henri Becquerel","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Henri Becquerel<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\u00e8me \u2022 2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Henri Becquerel\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-22-1_Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Henri Becquerel<\/h2>\n<p>Commune\u00a0: Avoine<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>130 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Port de Varennes-sur-Loire\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-22FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-22FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2022-2023","location":{"lat":"47.20992405610638","lng":"0.18409315187707162","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-henri-becquerel\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Henri Becquerel<\/h2>\n<p>Commune\u00a0: Avoine<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>130 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Port de Varennes-sur-Loire\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-22FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-22FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Henri Becquerel","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-henri-becquerel\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Henri Becquerel\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-22-1_Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.20992405610638","%_wpgmp_metabox_longitude%":"0.18409315187707162","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_22-23_Or_22#","%_wp_page_template%":"default","%_thumbnail_id%":"11364","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":8680,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Berge de Poilly-Lez-Gien","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Poilly-Lez-Gien<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Poilly-Lez-Gien \u2022 2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Poilly-Lez-Gien<\/h2>\n<p>Latitude : 49.418973N | Longitude :  0.932043E<br \/>Commune : Poilly-Lez-Gien<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-23FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Poilly-Lez-Gien \u2022 2022-2023","location":{"lat":"47.68220209944809","lng":"2.6251701493508994","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-poilly-lez-gien\/","zoom":7,"extra_fields":{"post_excerpt":"Poilly-Lez-Gien \u2022 2022-2023","post_content":"<h2 class=\"site\">Berge de Poilly-Lez-Gien<\/h2>\n<p>Latitude : 49.418973N | Longitude :  0.932043E<br \/>Commune : Poilly-Lez-Gien<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-23FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Berge de Poilly-Lez-Gien","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-poilly-lez-gien\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.68220209944809","%_wpgmp_metabox_longitude%":"2.6251701493508994","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_22-23_Or_23","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":8681,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Des Clorisseaux","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Des Clorisseaux<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Des Clorisseaux<\/h2>\n<p>Commune\u00a0: Poilly-Lez-Gien<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>20 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Poilly-Lez-Gien\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-23FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023","location":{"lat":"47.66781383206217","lng":"2.606429411419048","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-des-clorisseaux\/","zoom":7,"extra_fields":{"post_excerpt":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Des Clorisseaux<\/h2>\n<p>Commune\u00a0: Poilly-Lez-Gien<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>20 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Poilly-Lez-Gien\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-23FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-23FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Des Clorisseaux","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-des-clorisseaux\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.66781383206217","%_wpgmp_metabox_longitude%":"2.606429411419048","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_22-23_Or_23#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":8682,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Plage de Montrichard","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Plage de Montrichard<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Montrichard \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">\nPlage de Montrichard<\/h2>\n<p>Latitude : 47.340870|Longitude : 1.183118<br \/>Commune : Montrichard<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Montrichard \u2022 2023-2024","location":{"lat":"47.340870","lng":"1.183118","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-montrichard\/","zoom":7,"extra_fields":{"post_excerpt":"Montrichard \u2022 2023-2024","post_content":"<h2 class=\"site\">\nPlage de Montrichard<\/h2>\n<p>Latitude : 47.340870|Longitude : 1.183118<br \/>Commune : Montrichard<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"Plage de Montrichard","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-montrichard\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.340870","%_wpgmp_metabox_longitude%":"1.183118","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_25","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":12861,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Lyc\u00e9e Fulbert","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Fulbert<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                1\u00e8re \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Fulbert<\/h2>\n<p>Commune\u00a0: Chartres<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>70 \u00e9l\u00e8ves de 1\u00e8re<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Montrichard. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"1\u00e8re \u2022 2023-2024","location":{"lat":"48.446152976159446","lng":"1.5086714373234515","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-fulbert\/","zoom":7,"extra_fields":{"post_excerpt":"1\u00e8re \u2022 2023-2024","post_content":"<h2>Lyc\u00e9e Fulbert<\/h2>\n<p>Commune\u00a0: Chartres<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>70 \u00e9l\u00e8ves de 1\u00e8re<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Montrichard. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"Lyc\u00e9e Fulbert","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-fulbert\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.446152976159446","%_wpgmp_metabox_longitude%":"1.5086714373234515","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_25#","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":12862,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Pont de Saint-Cosme","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Pont de Saint-Cosme<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint-Cosme \u2022 2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pont de Saint-Cosme\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_21-22_Or_26_Photo-_site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Pont de Saint-Cosme<\/h2>\n<p>Latitude : 47.39025N | Longitude : 0.64495E<br \/>Commune : Saint-Cosme<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-26FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-26FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Saint-Cosme \u2022 2022-2023","location":{"lat":"47.39025","lng":"0.64495","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-de-saint-cosme\/","zoom":7,"extra_fields":{"post_excerpt":"Saint-Cosme \u2022 2022-2023","post_content":"<h2 class=\"site\">Pont de Saint-Cosme<\/h2>\n<p>Latitude : 47.39025N | Longitude : 0.64495E<br \/>Commune : Saint-Cosme<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-26FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-26FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Pont de Saint-Cosme","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-de-saint-cosme\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pont de Saint-Cosme\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_21-22_Or_26_Photo-_site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.39025","%_wpgmp_metabox_longitude%":"0.64495","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_22-23_Or_26","%_wp_page_template%":"default","%_thumbnail_id%":"11367","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":8687,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Berge de Ch\u00e9cy (Nord Ouest)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Ch\u00e9cy (Nord Ouest)<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Ch\u00e9cy \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Ch\u00e9cy (Nord Ouest)<\/h2>\n<p>Latitude : 47.894931\u00b0N | Longitude : 1.9922668\u00b0E<br \/>Commune : Ch\u00e9cy<\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_17_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_17FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_17_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Ch\u00e9cy \u2022 2021-2022","location":{"lat":"47.89493104505844","lng":"1.9922668108201014","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-checy-nord-ouest\/","zoom":7,"extra_fields":{"post_excerpt":"Ch\u00e9cy \u2022 2021-2022","post_content":"<h2 class=\"site\">Berge de Ch\u00e9cy (Nord Ouest)<\/h2>\n<p>Latitude : 47.894931\u00b0N | Longitude : 1.9922668\u00b0E<br \/>Commune : Ch\u00e9cy<\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_17_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_17FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_17_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Berge de Ch\u00e9cy (Nord Ouest)","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-checy-nord-ouest\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.89493104505844","%_wpgmp_metabox_longitude%":"1.9922668108201014","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_17","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":5362,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Ile Simon","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Ile Simon<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Tours \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Ile Simon<\/h2>\n<p>Latitude : 47.398737\u00b0N | Longitude : 0.680362\u00b0E<br \/>Commune : Tours<\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_8FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_8FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_8FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Tours \u2022 2021-2022","location":{"lat":"47.398737","lng":"0.680362","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ile-simon\/","zoom":7,"extra_fields":{"post_excerpt":"Tours \u2022 2021-2022","post_content":"<h2 class=\"site\">Ile Simon<\/h2>\n<p>Latitude : 47.398737\u00b0N | Longitude : 0.680362\u00b0E<br \/>Commune : Tours<\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_8FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_8FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_8FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Ile Simon","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ile-simon\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.398737","%_wpgmp_metabox_longitude%":"0.680362","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_8","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":5344,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Lyc\u00e9e professionnel d&rsquo;Arsonval","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e professionnel d&rsquo;Arsonval<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                1\u00e8re \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e professionnel d'Arsonval<\/h2>\n<p>Commune\u00a0: Jou\u00e9 Les Tours<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 1\u00e8re<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile Simon\" de la commune de Tours.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_8FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_8FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_8FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"1\u00e8re \u2022 2021-2022","location":{"lat":"47.34651007254051","lng":"0.6680040803779416","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-professionnel-darsonval\/","zoom":7,"extra_fields":{"post_excerpt":"1\u00e8re \u2022 2021-2022","post_content":"<h2>Lyc\u00e9e professionnel d'Arsonval<\/h2>\n<p>Commune\u00a0: Jou\u00e9 Les Tours<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 1\u00e8re<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile Simon\" de la commune de Tours.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_8FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_8FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_8FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e professionnel d&rsquo;Arsonval","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-professionnel-darsonval\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.34651007254051","%_wpgmp_metabox_longitude%":"0.6680040803779416","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_8#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":5345,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Jacques Decour","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Jacques Decour<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\u00e8me \u2022 2021-2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Jacques Decour<\/h2>\n<p>Commune\u00a0: Saint Pierre des Corps<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>20 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont Mirabeau\" de la commune de Tours. Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont Mirabeau\" de la commune de Tours. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_9FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_9FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_9FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2021-2022-2023","location":{"lat":"47.39429768031359","lng":"0.7230053614379532","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jacques-decour\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2021-2022-2023","post_content":"<h2>Coll\u00e8ge Jacques Decour<\/h2>\n<p>Commune\u00a0: Saint Pierre des Corps<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>20 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont Mirabeau\" de la commune de Tours. Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont Mirabeau\" de la commune de Tours. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_9FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_9FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_9FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Jacques Decour","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jacques-decour\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.39429768031359","%_wpgmp_metabox_longitude%":"0.7230053614379532","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_9#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":5347,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022","2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Berge de La Frilli\u00e8re","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de La Frilli\u00e8re<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Amboise \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de La Frilli\u00e8re<\/h2>\n<p>Latitude : 47.393959\u00b0N | Longitude : 0.822172\u00b0E<br \/>Commune : Vouvray<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21_22_Or_11_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21_22_Or_11_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21_22_Or_11_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Amboise \u2022 2021-2022","location":{"lat":"47.393959","lng":"0.822172","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-la-frilliere\/","zoom":7,"extra_fields":{"post_excerpt":"Amboise \u2022 2021-2022","post_content":"<h2 class=\"site\">Berge de La Frilli\u00e8re<\/h2>\n<p>Latitude : 47.393959\u00b0N | Longitude : 0.822172\u00b0E<br \/>Commune : Vouvray<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21_22_Or_11_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21_22_Or_11_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21_22_Or_11_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Berge de La Frilli\u00e8re","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-la-frilliere\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.393959","%_wpgmp_metabox_longitude%":"0.822172","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_11","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":5350,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Lyc\u00e9e Vaucanson","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Vaucanson<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Vaucanson<\/h2>\n<p>Commune\u00a0: Tours<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>35 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de La Frilli\u00e8re\" de la commune de Vouvray. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21_22_Or_11_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21_22_Or_11_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21_22_Or_11_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2021-2022","location":{"lat":"47.42339585417353","lng":"0.7066140552444622","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-vaucanson\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2021-2022","post_content":"<h2>Lyc\u00e9e Vaucanson<\/h2>\n<p>Commune\u00a0: Tours<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>35 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de La Frilli\u00e8re\" de la commune de Vouvray. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21_22_Or_11_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21_22_Or_11_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21_22_Or_11_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Vaucanson","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-vaucanson\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.42339585417353","%_wpgmp_metabox_longitude%":"0.7066140552444622","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_11#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":5351,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Berge de Veuzain-sur-Loire","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Veuzain-sur-Loire<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Veuzain-sur-Loire \u2022 2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Veuzain-sur-Loire\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-10-1_Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Veuzain-sur-Loire<\/h2>\n<p>Latitude : 47.484109N | Longitude :  1.182978E<br \/>Commune : Veuzain-sur-Loire<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Veuzain-sur-Loire \u2022 2022-2023","location":{"lat":"47.484109","lng":"1.182978","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-veuzain-sur-loire\/","zoom":7,"extra_fields":{"post_excerpt":"Veuzain-sur-Loire \u2022 2022-2023","post_content":"<h2 class=\"site\">Berge de Veuzain-sur-Loire<\/h2>\n<p>Latitude : 47.484109N | Longitude :  1.182978E<br \/>Commune : Veuzain-sur-Loire<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Berge de Veuzain-sur-Loire","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-veuzain-sur-loire\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge de Veuzain-sur-Loire\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-10-1_Photo_Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.484109","%_wpgmp_metabox_longitude%":"1.182978","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_22-23_Or_10","%_wp_page_template%":"default","%_thumbnail_id%":"11356","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":8664,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Marcel Carn\u00e9","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Marcel Carn\u00e9<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\u00e8me \u2022 2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Marcel Carn\u00e9\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-10-Groupe-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Marcel Carn\u00e9<\/h2>\n<p>Commune\u00a0: Vineuil<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Veuzain-sur-Loire\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2022-2023","location":{"lat":"47.58483041092673","lng":"1.3815737555972256","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-marcel-carne\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Marcel Carn\u00e9<\/h2>\n<p>Commune\u00a0: Vineuil<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>30 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Veuzain-sur-Loire\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-10FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Marcel Carn\u00e9","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-marcel-carne\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Marcel Carn\u00e9\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-10-Groupe-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.58483041092673","%_wpgmp_metabox_longitude%":"1.3815737555972256","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_22-23_Or_10#","%_wp_page_template%":"default","%_thumbnail_id%":"11357","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":8665,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Berge de Poisieux","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Poisieux<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint Georges de Poisieux \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Poisieux<\/h2>\n<p>Latitude : 46.707222\u00b0N | Longitude : 2.494167\u00b0E<br \/>Commune : Saint Georges de Poisieux<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_12FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_12FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_12FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Saint Georges de Poisieux \u2022 2021-2022","location":{"lat":"46.707222","lng":"2.494167","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-poisieux\/","zoom":7,"extra_fields":{"post_excerpt":"Saint Georges de Poisieux \u2022 2021-2022","post_content":"<h2 class=\"site\">Berge de Poisieux<\/h2>\n<p>Latitude : 46.707222\u00b0N | Longitude : 2.494167\u00b0E<br \/>Commune : Saint Georges de Poisieux<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_12FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_12FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_12FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Berge de Poisieux","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-poisieux\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.707222","%_wpgmp_metabox_longitude%":"2.494167","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_12","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":5352,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Lyc\u00e9e Vaucanson","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Vaucanson<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Coll\u00e8ge \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Vaucanson<\/h2>\n<p>Commune\u00a0: Tours<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>32 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Poisieux\" de la commune de Saint Georges de Poisieux.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_12FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_12FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_12FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Coll\u00e8ge \u2022 2021-2022","location":{"lat":"46.73459841225213","lng":"2.5129279425069395","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-vaucanson-2\/","zoom":7,"extra_fields":{"post_excerpt":"Coll\u00e8ge \u2022 2021-2022","post_content":"<h2>Lyc\u00e9e Vaucanson<\/h2>\n<p>Commune\u00a0: Tours<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>32 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Poisieux\" de la commune de Saint Georges de Poisieux.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_12FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_12FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_12FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Vaucanson","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-vaucanson-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"46.73459841225213","%_wpgmp_metabox_longitude%":"2.5129279425069395","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_12#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":5353,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Berge de Ch\u00e9cy (Sud Est)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge de Ch\u00e9cy (Sud Est)<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Ch\u00e9cy \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge de Ch\u00e9cy (Sud Est)<\/h2>\n<p>Latitude : 47.89228\u00b0N | Longitude : 1.996095\u00b0E<br \/>Commune : Ch\u00e9cy<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_13_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Ch\u00e9cy \u2022 2021-2022","location":{"lat":"47.89228019093295","lng":"1.9960959940330933","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-checy-sud-est\/","zoom":7,"extra_fields":{"post_excerpt":"Ch\u00e9cy \u2022 2021-2022","post_content":"<h2 class=\"site\">Berge de Ch\u00e9cy (Sud Est)<\/h2>\n<p>Latitude : 47.89228\u00b0N | Longitude : 1.996095\u00b0E<br \/>Commune : Ch\u00e9cy<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_13_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Berge de Ch\u00e9cy (Sud Est)","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-checy-sud-est\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.89228019093295","%_wpgmp_metabox_longitude%":"1.9960959940330933","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_13","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":5354,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Pierre Mendes France","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Pierre Mendes France<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\u00e8me \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Pierre Mendes France<\/h2>\n<p>Commune\u00a0: Checy<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Ch\u00e9cy (Sud Est)\" de la commune de Ch\u00e9cy. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_13_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2021-2022","location":{"lat":"47.90214339315444","lng":"2.02575899448919","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-pierre-mendes-france\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Pierre Mendes France<\/h2>\n<p>Commune\u00a0: Checy<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Ch\u00e9cy (Sud Est)\" de la commune de Ch\u00e9cy. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_13_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Pierre Mendes France","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-pierre-mendes-france\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_old_slug%":"college-pierre-mendes-france-2","%_wpgmp_metabox_latitude%":"47.90214339315444","%_wpgmp_metabox_longitude%":"2.02575899448919","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_13#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":5355,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Pont de la Chapelle St Mesmin","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Pont de la Chapelle St Mesmin<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                La chapelle St Mesmin \u2022 2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2 class=\"site\">Pont de la Chapelle St Mesmin <\/h2>\n<p>Latitude : 47.89284\u00b0N | Longitude : 1.85559782\u00b0E<br \/>Commune : La chapelle St Mesmin <\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-16FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_16_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"La chapelle St Mesmin \u2022 2021-2022","location":{"lat":"47.89284046276847","lng":"1.855597824025283","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-de-la-chapelle-st-mesmin\/","zoom":7,"extra_fields":{"post_excerpt":"La chapelle St Mesmin \u2022 2021-2022","post_content":"<h2 class=\"site\">Pont de la Chapelle St Mesmin <\/h2>\n<p>Latitude : 47.89284\u00b0N | Longitude : 1.85559782\u00b0E<br \/>Commune : La chapelle St Mesmin <\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-16FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_16_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Pont de la Chapelle St Mesmin","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-de-la-chapelle-st-mesmin\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.89284046276847","%_wpgmp_metabox_longitude%":"1.855597824025283","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_16","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022, 2022-2023, 2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":5360,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022","2022-2023","2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Andr\u00e9 Malraux","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Andr\u00e9 Malraux<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Coll\u00e8ge \u2022 2021-2022-2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Andr\u00e9 Malraux<\/h2>\n<p>Commune\u00a0: St Jean de la Ruelle<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>25 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de la Chapelle St Mesmin \" de la commune de La chapelle St Mesmin.<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>25 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de la Chapelle St Mesmin \" de la commune de La chapelle St Mesmin.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-16FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>16 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de la Chapelle St Mesmin \" de la commune de La chapelle St Mesmin . \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_16_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Coll\u00e8ge \u2022 2021-2022-2023-2024","location":{"lat":"47.9039066541198","lng":"1.8670254190520237","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-andre-malraux\/","zoom":7,"extra_fields":{"post_excerpt":"Coll\u00e8ge \u2022 2021-2022-2023-2024","post_content":"<h2>Coll\u00e8ge Andr\u00e9 Malraux<\/h2>\n<p>Commune\u00a0: St Jean de la Ruelle<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>25 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de la Chapelle St Mesmin \" de la commune de La chapelle St Mesmin.<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>25 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de la Chapelle St Mesmin \" de la commune de La chapelle St Mesmin.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Or-16FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>16 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de la Chapelle St Mesmin \" de la commune de La chapelle St Mesmin . \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_16_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Andr\u00e9 Malraux","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-andre-malraux\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.9039066541198","%_wpgmp_metabox_longitude%":"1.8670254190520237","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_16#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022, 2022-2023, 2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":5361,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022","2022-2023","2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Ile de la Noiraye (Ouest)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Ile de la Noiraye (Ouest)<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Nazelles-N\u00e9gron \u2022 2019-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ile de la Noiraye (Ouest)\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_7_photo_site.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Ile de la Noiraye (Ouest)<\/h2>\n<p>Latitude : 47.413711\u00b0N | Longitude : 0.973485\u00b0E<br \/>Commune : Nazelles-N\u00e9gron<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Or-7_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Or-17_0FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_7FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2019-2020<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_7_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_7_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_7_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Nazelles-N\u00e9gron \u2022 2019-2024","location":{"lat":"47.413711","lng":"0.973485","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ile-de-la-noiraye-ouest\/","zoom":7,"extra_fields":{"post_excerpt":"Nazelles-N\u00e9gron \u2022 2019-2024","post_content":"<h2 class=\"site\">Ile de la Noiraye (Ouest)<\/h2>\n<p>Latitude : 47.413711\u00b0N | Longitude : 0.973485\u00b0E<br \/>Commune : Nazelles-N\u00e9gron<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Or-7_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Or-17_0FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_7FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2019-2020<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_7_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_7_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_7_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Ile de la Noiraye (Ouest)","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/ile-de-la-noiraye-ouest\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ile de la Noiraye (Ouest)\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_7_photo_site.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wp_old_slug%":"levee-de-la-loire","%_wpgmp_metabox_latitude%":"47.413711","%_wpgmp_metabox_longitude%":"0.973485","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_19-20_Or_7","%_wp_page_template%":"default","%_thumbnail_id%":"1679","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2019-2020, 2021-2022, 2022-2023, 2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4196,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2019-2020","2021-2022","2022-2023","2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Hippodrome (bis)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Hippodrome (bis)<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Orl\u00e9ans \u2022 2019-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hippodrome (bis)\" width=\"300\" height=\"203\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_OR6_1_PHOTO_SITE-300x203.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Hippodrome (bis)<\/h2>\n<p>Latitude : 47.89549\u00b0N | Longitude : 1.8858\u00b0E<br \/>Commune : Orl\u00e9ans<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e 2019-2020<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_1_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_1_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_1_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Orl\u00e9ans \u2022 2019-2024","location":{"lat":"47.89549","lng":"1.8858","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/hippodrome-bis\/","zoom":7,"extra_fields":{"post_excerpt":"Orl\u00e9ans \u2022 2019-2024","post_content":"<h2 class=\"site\">Hippodrome (bis)<\/h2>\n<p>Latitude : 47.89549\u00b0N | Longitude : 1.8858\u00b0E<br \/>Commune : Orl\u00e9ans<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e 2019-2020<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_1_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_1_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_1_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Hippodrome (bis)","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/hippodrome-bis\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hippodrome (bis)\" width=\"300\" height=\"203\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_OR6_1_PHOTO_SITE-300x203.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.89549","%_wpgmp_metabox_longitude%":"1.8858","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_19-20_Or_1","%_wp_page_template%":"default","%_thumbnail_id%":"11355","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2019-2020, 2020-2021, 2021-2022, 2022-2023, 2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4201,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2019-2020","2020-2021","2021-2022","2022-2023","2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Joachim Du Bellay","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Joachim Du Bellay<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\u00e8me\/5\u00e8me \u2022 2019-2020\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Joachim Du Bellay\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_7_photo_classe.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Joachim Du Bellay<\/h2>\n<p>Commune\u00a0: Montrichard Val de Cher<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>8 \u00e9l\u00e8ves de 6\u00e8me\/5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la Noiraye (Ouest)\" de la commune de Nazelles-N\u00e9gron.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_7_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_7_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_7_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me\/5\u00e8me \u2022 2019-2020","location":{"lat":"47.40395434851855","lng":"1.1833061727941245","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-joachim-du-bellay\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me\/5\u00e8me \u2022 2019-2020","post_content":"<h2>Coll\u00e8ge Joachim Du Bellay<\/h2>\n<p>Commune\u00a0: Montrichard Val de Cher<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>8 \u00e9l\u00e8ves de 6\u00e8me\/5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la Noiraye (Ouest)\" de la commune de Nazelles-N\u00e9gron.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_7_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_7_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_7_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Joachim Du Bellay","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-joachim-du-bellay\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Joachim Du Bellay\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_7_photo_classe.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.40395434851855","%_wpgmp_metabox_longitude%":"1.1833061727941245","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_19-20_Or_7#","%_wp_page_template%":"default","%_thumbnail_id%":"1678","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2019-2020"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4197,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2019-2020"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Condorcet","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Condorcet<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2020-2021-2022-2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Condorcet<\/h2>\n<p>Commune : Fleury-les-Aubrais<br \/>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>25 \u00e9co-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Hippodrome\" de la commune de Orl\u00e9ans.\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>20 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Hippodrome (bis)\" de la commune de Orl\u00e9ans.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>20 \u00e9l\u00e8ves de Cycle 4<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Hippodrome (bis)\" de la commune de Orl\u00e9ans.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2020-2021-2022-2023-2024","location":{"lat":"47.9304611187448","lng":"1.926175840624338","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-condorcet\/","zoom":7,"extra_fields":{"post_excerpt":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2020-2021-2022-2023-2024","post_content":"<h2>Coll\u00e8ge Condorcet<\/h2>\n<p>Commune : Fleury-les-Aubrais<br \/>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>25 \u00e9co-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Hippodrome\" de la commune de Orl\u00e9ans.\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>20 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Hippodrome (bis)\" de la commune de Orl\u00e9ans.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Or_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>20 \u00e9l\u00e8ves de Cycle 4<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Hippodrome (bis)\" de la commune de Orl\u00e9ans.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Condorcet","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-condorcet\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.9304611187448","%_wpgmp_metabox_longitude%":"1.926175840624338","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_20-21_Or_1#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022, 2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4202,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022","2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Lyc\u00e9e Sainte Marguerite","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Sainte Marguerite<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Terminale \u2022 2021-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Sainte Marguerite<\/h2>\n<p>Commune\u00a0: Chambray-l\u00e8s-Tours<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>15 \u00e9l\u00e8ves de terminale<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la Noiraye (Ouest)\" de la commune de Nazelles-N\u00e9gron.<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>38 \u00e9l\u00e8ves de terminale<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la Noiraye (Ouest)\" de la commune de Nazelles-N\u00e9gron.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Or-7_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Or-17_0FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>37 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la Noiraye (Ouest)\" de la commune de Nazelles-N\u00e9gron.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_7FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Terminale \u2022 2021-2024","location":{"lat":"47.34602811254594","lng":"0.722214559566835","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-sainte-marguerite\/","zoom":7,"extra_fields":{"post_excerpt":"Terminale \u2022 2021-2024","post_content":"<h2>Lyc\u00e9e Sainte Marguerite<\/h2>\n<p>Commune\u00a0: Chambray-l\u00e8s-Tours<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>15 \u00e9l\u00e8ves de terminale<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la Noiraye (Ouest)\" de la commune de Nazelles-N\u00e9gron.<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>38 \u00e9l\u00e8ves de terminale<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la Noiraye (Ouest)\" de la commune de Nazelles-N\u00e9gron.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Or-7_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Or-17_0FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>37 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Ile de la Noiraye (Ouest)\" de la commune de Nazelles-N\u00e9gron.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_7FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Sainte Marguerite","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-sainte-marguerite\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_old_slug%":"lycee-sainte-marguerite-2","%_wpgmp_metabox_latitude%":"47.34602811254594","%_wpgmp_metabox_longitude%":"0.722214559566835","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_21-22_Or_7#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022, 2022-2023, 2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":7281,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2021-2022","2022-2023","2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Jean Pelletier","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Jean Pelletier<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3\u00e8me \u2022 2019-2020\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Jean Pelletier\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_1_photo_classe.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Jean Pelletier<\/h2>\n<p>Commune\u00a0: Orl\u00e9ans<br \/>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>10 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Hippodrome (bis)\" de la commune de Orl\u00e9ans.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_1_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_1_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_1_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"3\u00e8me \u2022 2019-2020","location":{"lat":"47.92332408274843","lng":"1.8895406848970167","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-pelletier\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me \u2022 2019-2020","post_content":"<h2>Coll\u00e8ge Jean Pelletier<\/h2>\n<p>Commune\u00a0: Orl\u00e9ans<br \/>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>10 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Hippodrome (bis)\" de la commune de Orl\u00e9ans.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_1_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_1_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_1_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Jean Pelletier","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-pelletier\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Jean Pelletier\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_1_photo_classe.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.92332408274843","%_wpgmp_metabox_longitude%":"1.8895406848970167","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_19-20_Or_1#","%_wp_page_template%":"default","%_thumbnail_id%":"1690","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2019-2020"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4203,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2019-2020"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Louis Pergaud","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Louis Pergaud<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\u00e8me \u2022 2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Louis Pergaud\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Or-1_photo_site-300x225.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Louis Pergaud<\/h2>\n<p>Commune\u00a0: Courville-sur-Eure<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>150 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Hippodrome (bis)\" de la commune de Orl\u00e9ans.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2022-2023","location":{"lat":"48.45036608533196","lng":"1.2379240384293138","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-louis-pergaud-2\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Louis Pergaud<\/h2>\n<p>Commune\u00a0: Courville-sur-Eure<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>150 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Hippodrome (bis)\" de la commune de Orl\u00e9ans.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Or-1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Louis Pergaud","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-louis-pergaud-2\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Louis Pergaud\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Or-1_photo_site-300x225.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.45036608533196","%_wpgmp_metabox_longitude%":"1.2379240384293138","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_22-23_Or_1#","%_wp_page_template%":"default","%_thumbnail_id%":"11354","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":8650,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Lyc\u00e9e Jean Lur\u00e7at","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Jean Lur\u00e7at<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3eme \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Jean Lur\u00e7at<\/h2>\n<p>Commune\u00a0: Fleury les Aubrais<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>24 \u00e9l\u00e8ves de 3eme<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Hippodrome (bis). Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"3eme \u2022 2023-2024","location":{"lat":"47.929770746619134","lng":"1.9245486698358232","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-jean-lurcat-3\/","zoom":7,"extra_fields":{"post_excerpt":"3eme \u2022 2023-2024","post_content":"<h2>Lyc\u00e9e Jean Lur\u00e7at<\/h2>\n<p>Commune\u00a0: Fleury les Aubrais<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>24 \u00e9l\u00e8ves de 3eme<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Hippodrome (bis). Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"Lyc\u00e9e Jean Lur\u00e7at","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-jean-lurcat-3\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.929770746619134","%_wpgmp_metabox_longitude%":"1.9245486698358232","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_1#","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":12846,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Lev\u00e9e des Tuileries","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lev\u00e9e des Tuileries<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Blois \u2022 2020-2021-2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lev\u00e9e des Tuileries\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_2-Photo_Laisse02-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Lev\u00e9e des Tuileries<\/h2>\n<p>Latitude : 47.593551\u00b0N | Longitude : 1.352063\u00b0E<br \/>Commune : Blois\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Blois \u2022 2020-2021-2023-2024","location":{"lat":"47.593551","lng":"1.352063","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/levee-des-tuileries\/","zoom":7,"extra_fields":{"post_excerpt":"Blois \u2022 2020-2021-2023-2024","post_content":"<h2 class=\"site\">Lev\u00e9e des Tuileries<\/h2>\n<p>Latitude : 47.593551\u00b0N | Longitude : 1.352063\u00b0E<br \/>Commune : Blois\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lev\u00e9e des Tuileries","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/levee-des-tuileries\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lev\u00e9e des Tuileries\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_2-Photo_Laisse02-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.593551","%_wpgmp_metabox_longitude%":"1.352063","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_20-21_Or_2","%_wp_page_template%":"default","%_thumbnail_id%":"4189","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4206,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Blois B\u00e9gon","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Blois B\u00e9gon<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\u00e8me \u2022 2020-2021\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Blois B\u00e9gon\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_2-photo-classe-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Blois B\u00e9gon<\/h2>\n<p>Commune : Blois<br \/>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>24 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Lev\u00e9e des Tuileries\" de la commune de Blois.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2020-2021","location":{"lat":"47.59384999810454","lng":"1.308478127122612","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-blois-begon\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2020-2021","post_content":"<h2>Coll\u00e8ge Blois B\u00e9gon<\/h2>\n<p>Commune : Blois<br \/>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>24 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Lev\u00e9e des Tuileries\" de la commune de Blois.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_2FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_2FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Blois B\u00e9gon","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-blois-begon\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Blois B\u00e9gon\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_2-photo-classe-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.59384999810454","%_wpgmp_metabox_longitude%":"1.308478127122612","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_20-21_Or_2#","%_wp_page_template%":"default","%_thumbnail_id%":"4190","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4207,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Rabelais","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Rabelais<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\u00e8me \u2022 2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Rabelais<\/h2>\n<p>Commune\u00a0: Blois<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>80 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Lev\u00e9e des Tuileries. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"6\u00e8me \u2022 2023-2024","location":{"lat":"47.594863428741604","lng":"1.3165603967968431","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-rabelais\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2023-2024","post_content":"<h2>Coll\u00e8ge Rabelais<\/h2>\n<p>Commune\u00a0: Blois<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>80 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Lev\u00e9e des Tuileries. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"Coll\u00e8ge Rabelais","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-rabelais\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.594863428741604","%_wpgmp_metabox_longitude%":"1.3165603967968431","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_23-24_Or_2#","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":12848,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Hippodrome","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Hippodrome<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Orl\u00e9ans \u2022 2019-2020-2021-2023-2024\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hippodrome\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_4Photo_siteOuest-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Hippodrome<\/h2>\n<p>Latitude : 47.8954446\u00b0N | Longitude : 1.887963\u00b0E<br \/>Commune : Orl\u00e9ans<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_4FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_4FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_4FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e 2019-2020<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_4_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_4_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_4_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Orl\u00e9ans \u2022 2019-2020-2021-2023-2024","location":{"lat":"47.8954446","lng":"1.887963","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/hippodrome\/","zoom":7,"extra_fields":{"post_excerpt":"Orl\u00e9ans \u2022 2019-2020-2021-2023-2024","post_content":"<h2 class=\"site\">Hippodrome<\/h2>\n<p>Latitude : 47.8954446\u00b0N | Longitude : 1.887963\u00b0E<br \/>Commune : Orl\u00e9ans<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_4FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_4FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_4FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e 2019-2020<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_4_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_4_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_4_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Hippodrome","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/hippodrome\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hippodrome\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_4Photo_siteOuest-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.8954446","%_wpgmp_metabox_longitude%":"1.887963","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_19-20_Or_4","%_wp_page_template%":"default","%_thumbnail_id%":"4192","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2019-2020, 2020-2021, 2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4198,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2019-2020","2020-2021","2023-2024"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Lyc\u00e9e Jean Zay","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Jean Zay<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\u00e8me \u2022 2020-2021\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Jean Zay<\/h2>\n<p>Commune : Orl\u00e9ans<br \/>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>32 \u00e9l\u00e8ves de Treminale<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Hippodrome\" de la commune de Orl\u00e9ans.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_4FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_4FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_4FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2020-2021","location":{"lat":"47.90677224260773","lng":"1.9127638271307983","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-jean-zay\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2020-2021","post_content":"<h2>Lyc\u00e9e Jean Zay<\/h2>\n<p>Commune : Orl\u00e9ans<br \/>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>32 \u00e9l\u00e8ves de Treminale<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Hippodrome\" de la commune de Orl\u00e9ans.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_4FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_4FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_4FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Jean Zay","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-jean-zay\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.90677224260773","%_wpgmp_metabox_longitude%":"1.9127638271307983","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_20-21_Or_4#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4199,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge J.Prevert","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge J.Prevert<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\u00e8me \u2022 2019-2020\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge J.Prevert\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_4_photo_site.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge J.Prevert<\/h2>\n<p>Commune\u00a0: Saint-Jean-le-Blanc<br \/>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>27 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Hippodrome\" de la commune de Orl\u00e9ans.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_4_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_4_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_4_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2019-2020","location":{"lat":"47.88397735748954","lng":"1.9363765425666852","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-j-prevert\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2019-2020","post_content":"<h2>Coll\u00e8ge J.Prevert<\/h2>\n<p>Commune\u00a0: Saint-Jean-le-Blanc<br \/>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>27 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Hippodrome\" de la commune de Orl\u00e9ans.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_4_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_4_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_4_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge J.Prevert","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-j-prevert\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge J.Prevert\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Or_4_photo_site.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.88397735748954","%_wpgmp_metabox_longitude%":"1.9363765425666852","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_19-20_Or_4#","%_wp_page_template%":"default","%_thumbnail_id%":"1684","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2019-2020"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4200,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2019-2020"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Berge \u00e0 Tavers","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Berge \u00e0 Tavers<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Tavers \u2022 2020-2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge \u00e0 Tavers\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_5-Photo_Site2-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Berge \u00e0 Tavers<\/h2>\n<p>Latitude : 47.733037\u00b0N | Longitude : 1.605547\u00b0E<br \/>Commune : Tavers<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Tavers \u2022 2020-2021-2022","location":{"lat":"47.733037","lng":"1.605547","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-a-tavers\/","zoom":7,"extra_fields":{"post_excerpt":"Tavers \u2022 2020-2021-2022","post_content":"<h2 class=\"site\">Berge \u00e0 Tavers<\/h2>\n<p>Latitude : 47.733037\u00b0N | Longitude : 1.605547\u00b0E<br \/>Commune : Tavers<\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Berge \u00e0 Tavers","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-a-tavers\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berge \u00e0 Tavers\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_5-Photo_Site2-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.733037","%_wpgmp_metabox_longitude%":"1.605547","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_20-21_Or_5","%_wp_page_template%":"default","%_thumbnail_id%":"4193","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4208,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Lyc\u00e9e Fran\u00e7ois Villon","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lyc\u00e9e Fran\u00e7ois Villon<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde \u2022 2020-2021-2022\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Fran\u00e7ois Villon<\/h2>\n<p>Commune : Beaugency<br \/>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>10 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge \u00e0 Tavers\" de la commune de Tavers. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>32 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge \u00e0 Tavers\" de la commune de Tavers.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2020-2021-2022","location":{"lat":"47.82345496916887","lng":"1.6294918090234944","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-francois-villon\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2020-2021-2022","post_content":"<h2>Lyc\u00e9e Fran\u00e7ois Villon<\/h2>\n<p>Commune : Beaugency<br \/>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>10 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge \u00e0 Tavers\" de la commune de Tavers. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>32 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge \u00e0 Tavers\" de la commune de Tavers.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_5FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_5FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_5FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Fran\u00e7ois Villon","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-francois-villon\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.82345496916887","%_wpgmp_metabox_longitude%":"1.6294918090234944","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_20-21_Or_5#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4209,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Pont de Sully","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Pont de Sully<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Sully-sur-Loire \u2022 2020-2021-2022-2023\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pont de Sully\" width=\"300\" height=\"170\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_6.Photo_Site-1-300x170.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Pont de Sully<\/h2>\n<p>Latitude : 47.769591\u00b0N | Longitude : 2.37499554\u00b0E<br \/>Commune : Sully-sur-Loire\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL_22_23_Or-6_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL_22_23_Or-6_0FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de l'ile aux Moines\" de la commune de Marolles sur Seine.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Sully-sur-Loire \u2022 2020-2021-2022-2023","location":{"lat":"47.769591312344694","lng":"2.374995544631977","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-de-sully\/","zoom":7,"extra_fields":{"post_excerpt":"Sully-sur-Loire \u2022 2020-2021-2022-2023","post_content":"<h2 class=\"site\">Pont de Sully<\/h2>\n<p>Latitude : 47.769591\u00b0N | Longitude : 2.37499554\u00b0E<br \/>Commune : Sully-sur-Loire\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL_22_23_Or-6_FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL_22_23_Or-6_0FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Or_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de l'ile aux Moines\" de la commune de Marolles sur Seine.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_V_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e 2020-2021<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Pont de Sully","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pont-de-sully\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pont de Sully\" width=\"300\" height=\"170\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_6.Photo_Site-1-300x170.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.769591312344694","%_wpgmp_metabox_longitude%":"2.374995544631977","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"26\";}","%refpoint%":"PAL_20-21_Or_6","%_wp_page_template%":"default","%_thumbnail_id%":"4194","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2021-2022, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4210,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","2021-2022","2022-2023"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","name":"Site","id":"2","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]},{"source":"post","title":"Coll\u00e8ge Maximilien","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coll\u00e8ge Maximilien<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\u00e8me \u2022 2020-2021\r\n<p style=\"text-align:center;\"><button onclick=\"javascript:affiche_post();\">EN SAVOIR PLUS<\/button><\/p>\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>\r\n<div id=\"contenu_post\" style=\"display:none;\"><div id=\"btFermePost\"><button onclick=\"javascript:fermer_post();\"><small>Fermer<\/small><\/button><\/div><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Maximilien\" width=\"300\" height=\"170\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_6.Classe-300x170.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Maximilien<\/h2>\n<p>Commune : Sully-sur-Loire<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>23 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de Sully\" de la commune de Sully-sur-Loire.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2020-2021","location":{"lat":"47.76335922850396","lng":"2.3860807424698387","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-maximilien\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2020-2021","post_content":"<h2>Coll\u00e8ge Maximilien<\/h2>\n<p>Commune : Sully-sur-Loire<br>Acad\u00e9mie : Orl\u00e9ans-Tours<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>23 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pont de Sully\" de la commune de Sully-sur-Loire.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_6FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Maximilien","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-maximilien\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Maximilien\" width=\"300\" height=\"170\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Or_6.Classe-300x170.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.76335922850396","%_wpgmp_metabox_longitude%":"2.3860807424698387","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"2\";i:1;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"26\";}","%refpoint%":"PAL_20-21_Or_6#","%_wp_page_template%":"default","%_thumbnail_id%":"4195","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4211,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021"]},"infowindow_disable":false,"categories":[{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","name":"Classe","id":"1","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","name":"Orleans-Tours","id":"26","type":"category"}]}],"listing":{"listing_header":"<div id=\"explicatif\" style=\"margin: 10px 10px 10px 0;\">2019 \u00e0 2024 : r\u00e9sultats&nbsp;disponibles<\/div>\r\n<div id=\"legende\"><img class=\"wp-image-520\" style=\"width: 15px; height:15px; display:inline; vertical-align:bottom;\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/06\/maker-classe.png\" alt=\"\"> Classes&nbsp;&nbsp;<img class=\"wp-image-520\" style=\"width: 15px; height:15px; display:inline; vertical-align:bottom;\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/09\/maker-site-2.png\" alt=\"\"> Sites | Filtres&nbsp;:<\/div>","display_search_form":false,"search_field_autosuggest":false,"display_category_filter":false,"display_sorting_filter":false,"display_radius_filter":false,"radius_dimension":"miles","apply_default_radius":false,"default_radius_dimension":"miles","display_location_per_page_filter":false,"display_print_option":false,"display_grid_option":false,"filters":["place_category"],"sorting_options":{"category__asc":"A-Z Category","category__desc":"Z-A Category","title__asc":"A-Z Title","title__desc":"Z-A Title","address__asc":"A-Z Address","address__desc":"Z-A Address"},"default_sorting":{"orderby":"title","inorder":"asc"},"listing_container":".location_listing3","tabs_container":".location_listing3","hide_locations":true,"filters_position":"top_map","hide_map":false,"pagination":{"listing_per_page":10},"list_grid":"wpgmp_listing_list","listing_placeholder":"<div class=\"wpgmp_locations\">\r\n<div class=\"wpgmp_locations_head\">\r\n<div class=\"wpgmp_location_title\">\r\n<a href=\"\" class=\"place_title\" data-zoom=\"{marker_zoom}\" data-marker=\"{marker_id}\">{marker_title}<\/a>\r\n<\/div>\r\n<div class=\"wpgmp_location_meta\">\r\n<span class=\"wpgmp_location_category fc-badge info\">{marker_category}<\/span>\r\n<\/div>\r\n<\/div>\r\n<div class=\"wpgmp_locations_content\">\r\n{marker_message}\r\n<\/div>\r\n<div class=\"wpgmp_locations_foot\"><\/div>\r\n<p style=\"text-align:center;\"><a href=\"{post_link}\" target=\"_self\">EN SAVOIR PLUS<\/a><\/p>\r\n<\/div>","list_item_skin":{"name":"default","type":"item","sourcecode":"&lt;div class=&quot;wpgmp_locations&quot;&gt;\r\n&lt;div class=&quot;wpgmp_locations_head&quot;&gt;\r\n&lt;div class=&quot;wpgmp_location_title&quot;&gt;\r\n&lt;a href=&quot;&quot; class=&quot;place_title&quot; data-zoom=&quot;{marker_zoom}&quot; data-marker=&quot;{marker_id}&quot;&gt;{marker_title}&lt;\/a&gt;\r\n&lt;\/div&gt;\r\n&lt;div class=&quot;wpgmp_location_meta&quot;&gt;\r\n&lt;span class=&quot;wpgmp_location_category fc-badge info&quot;&gt;{marker_category}&lt;\/span&gt;\r\n&lt;\/div&gt;\r\n&lt;\/div&gt;\r\n&lt;div class=&quot;wpgmp_locations_content&quot;&gt;\r\n{marker_message}\r\n&lt;\/div&gt;\r\n&lt;div class=&quot;wpgmp_locations_foot&quot;&gt;&lt;\/div&gt;\r\n&lt;p style=&quot;text-align:center;&quot;&gt;&lt;a href=&quot;{post_link}&quot; target=&quot;_self&quot;&gt;EN SAVOIR PLUS&lt;\/a&gt;&lt;\/p&gt;\r\n&lt;\/div&gt;"}},"map_property":{"map_id":"3","debug_mode":false},"map_marker_spiderfier_setting":{"minimum_markers":"0"},"shapes":{"drawing_editable":false},"filters":{"custom_filters":{"filters":{"dropdown":{"%type-site-classe%":"Sites et classes","%etude%":"Type de pollution","%annee%":"Ann\u00e9e"}}},"filters_container":"[data-container=\"wpgmp-filters-container\"]"},"marker_category_icons":{"1":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png","2":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png","3":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","4":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","5":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","6":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","7":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","8":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","9":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","10":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","11":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","12":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","13":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","14":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","15":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","16":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","17":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","18":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","19":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","20":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","21":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","22":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","23":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","24":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","25":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","26":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","27":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","28":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","29":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","30":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","31":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","32":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","33":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","34":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","35":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","36":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png","37":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe-en-cours.png","38":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-en-cours.png","40":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/3-generic.png"}}