Académie de Rennes

{"map_options":{"center_lat":"47.6861786358864","center_lng":"-3.0096342590157694","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":"CLG PR ST GILDAS","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\">CLG PR ST GILDAS<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                coll\u00e8ge \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>CLG PR ST GILDAS<\/h2>\n<p>Commune\u00a0: BRECH<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Kerhilio. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Ren-50FM.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-Ren-50FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"coll\u00e8ge \u2022 2023-2024","address":"","location":{"lat":"47.6861786358864","lng":"-3.0096342590157694","redirect_custom_link":"","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-pr-st-gildas\/","zoom":7,"extra_fields":{"post_excerpt":"coll\u00e8ge \u2022 2023-2024","post_content":"<h2>CLG PR ST GILDAS<\/h2>\n<p>Commune\u00a0: BRECH<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Kerhilio. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Ren-50FM.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-Ren-50FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"CLG PR ST GILDAS","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-pr-st-gildas\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.6861786358864","%_wpgmp_metabox_longitude%":"-3.0096342590157694","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_50#","%_wp_page_template%":"default","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":13019,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"CLG PR NOTRE DAME DE CAMPOSTAL","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\">CLG PR NOTRE DAME DE CAMPOSTAL<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                coll\u00e8ge \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>CLG PR NOTRE DAME DE CAMPOSTAL<\/h2>\n<p>Commune\u00a0: ROSTRENEN<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Beau Rivage. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Ren-47LM.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-Ren-47LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"coll\u00e8ge \u2022 2023-2024","location":{"lat":"48.230273101034705","lng":"-3.1818436298845887","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-pr-notre-dame-de-campostal\/","zoom":7,"extra_fields":{"post_excerpt":"coll\u00e8ge \u2022 2023-2024","post_content":"<h2>CLG PR NOTRE DAME DE CAMPOSTAL<\/h2>\n<p>Commune\u00a0: ROSTRENEN<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Beau Rivage. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Ren-47LM.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-Ren-47LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"CLG PR NOTRE DAME DE CAMPOSTAL","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-pr-notre-dame-de-campostal\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.230273101034705","%_wpgmp_metabox_longitude%":"-3.1818436298845887","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_47#","%_wp_page_template%":"default","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":13013,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge d&rsquo;Acign\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 d&rsquo;Acign\u00e9<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Acign\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 d'Acign\u00e9<\/h2>\n<p>Latitude : 48.127847|Longitude : -1.542208<br \/>Commune : Acign\u00e9<\/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-Ren-48LM.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-Ren-48LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Acign\u00e9 \u2022 2023-2024","location":{"lat":"48.127847","lng":"-1.542208","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-dacigne\/","zoom":7,"extra_fields":{"post_excerpt":"Acign\u00e9 \u2022 2023-2024","post_content":"<h2 class=\"site\">\nBerge d'Acign\u00e9<\/h2>\n<p>Latitude : 48.127847|Longitude : -1.542208<br \/>Commune : Acign\u00e9<\/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-Ren-48LM.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-Ren-48LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Berge d&rsquo;Acign\u00e9","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-dacigne\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.127847","%_wpgmp_metabox_longitude%":"-1.542208","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_48","%_wp_page_template%":"default","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":13014,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"LGT SIMONE VEIL","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\">LGT SIMONE VEIL<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Coll\u00e8ge \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>LGT SIMONE VEIL<\/h2>\n<p>Commune\u00a0: LIFFRE<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge d'Acign\u00e9. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Ren-48LM.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-Ren-48LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Coll\u00e8ge \u2022 2023-2024","location":{"lat":"48.246696997387694","lng":"-1.533032610834231","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lgt-simone-veil\/","zoom":7,"extra_fields":{"post_excerpt":"Coll\u00e8ge \u2022 2023-2024","post_content":"<h2>LGT SIMONE VEIL<\/h2>\n<p>Commune\u00a0: LIFFRE<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge d'Acign\u00e9. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Ren-48LM.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-Ren-48LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"LGT SIMONE VEIL","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lgt-simone-veil\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.246696997387694","%_wpgmp_metabox_longitude%":"-1.533032610834231","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_48#","%_wp_page_template%":"default","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":13015,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Kerhilio","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 Kerhilio<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Erdeven \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 Kerhilio<\/h2>\n<p>Latitude : 47.60893445389339|Longitude : -3.1662893214187204<br \/>Commune : Erdeven<\/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-Ren-50FM.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-Ren-50FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Erdeven \u2022 2023-2024","location":{"lat":"47.60893445389339","lng":"-3.1662893214187204","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-kerhilio\/","zoom":7,"extra_fields":{"post_excerpt":"Erdeven \u2022 2023-2024","post_content":"<h2 class=\"site\">\nPlage de Kerhilio<\/h2>\n<p>Latitude : 47.60893445389339|Longitude : -3.1662893214187204<br \/>Commune : Erdeven<\/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-Ren-50FM.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-Ren-50FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Plage de Kerhilio","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-kerhilio\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.60893445389339","%_wpgmp_metabox_longitude%":"-3.1662893214187204","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_50","%_wp_page_template%":"default","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":13018,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"ITEP DU BAS LANDRY","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\">ITEP DU BAS LANDRY<\/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>ITEP DU BAS LANDRY<\/h2>\n<p>Commune\u00a0: Rennes<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>5 \u00e9l\u00e8ves<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Guichen\".<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Ren-39FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"1\u00e8re \u2022 2023-2024","location":{"lat":"48.100851030265666","lng":"-1.6471965162701905","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/itep-du-bas-landry\/","zoom":7,"extra_fields":{"post_excerpt":"1\u00e8re \u2022 2023-2024","post_content":"<h2>ITEP DU BAS LANDRY<\/h2>\n<p>Commune\u00a0: Rennes<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>5 \u00e9l\u00e8ves<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Berge de Guichen\".<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Ren-39FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"ITEP DU BAS LANDRY","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/itep-du-bas-landry\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.100851030265666","%_wpgmp_metabox_longitude%":"-1.6471965162701905","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_39#","%_wp_page_template%":"default","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":10631,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge des peupliers","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 peupliers<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Cesson-S\u00e9vign\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 des peupliers<\/h2>\n<p>Latitude : 48.1138229|Longitude : -1.608193<br \/>Commune : Cesson-S\u00e9vign\u00e9<\/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-Ren-41BM.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-Ren-41BS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Cesson-S\u00e9vign\u00e9 \u2022 2023-2024","location":{"lat":"48.1138229","lng":"-1.608193","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-des-peupliers\/","zoom":7,"extra_fields":{"post_excerpt":"Cesson-S\u00e9vign\u00e9 \u2022 2023-2024","post_content":"<h2 class=\"site\">\nBerge des peupliers<\/h2>\n<p>Latitude : 48.1138229|Longitude : -1.608193<br \/>Commune : Cesson-S\u00e9vign\u00e9<\/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-Ren-41BM.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-Ren-41BS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Berge des peupliers","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-des-peupliers\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.1138229","%_wpgmp_metabox_longitude%":"-1.608193","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_41","%_wp_page_template%":"default","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":13000,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"CLG LA BINQUENAIS","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\">CLG LA BINQUENAIS<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Coll\u00e8ge \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>CLG LA BINQUENAIS<\/h2>\n<p>Commune\u00a0: RENNES<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge des peupliers.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Ren-41BM.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-Ren-41BS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Coll\u00e8ge \u2022 2023-2024","location":{"lat":"48.09120142074924","lng":"-1.6633623185173092","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-la-binquenais\/","zoom":7,"extra_fields":{"post_excerpt":"Coll\u00e8ge \u2022 2023-2024","post_content":"<h2>CLG LA BINQUENAIS<\/h2>\n<p>Commune\u00a0: RENNES<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge des peupliers.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Ren-41BM.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-Ren-41BS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"CLG LA BINQUENAIS","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-la-binquenais\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.09120142074924","%_wpgmp_metabox_longitude%":"-1.6633623185173092","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_41#","%_wp_page_template%":"default","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":13001,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de la Belle \u00e9toile","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 la Belle \u00e9toile<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Concarneau \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 la Belle \u00e9toile<\/h2>\n<p>Latitude : 47.856960|Longitude : -3.904309<br \/>Commune : Concarneau<\/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-Ren-54FM.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-Ren-54FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Concarneau \u2022 2023-2024","location":{"lat":"47.856960","lng":"-3.904309","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-la-belle-etoile-2\/","zoom":7,"extra_fields":{"post_excerpt":"Concarneau \u2022 2023-2024","post_content":"<h2 class=\"site\">\nPlage de la Belle \u00e9toile<\/h2>\n<p>Latitude : 47.856960|Longitude : -3.904309<br \/>Commune : Concarneau<\/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-Ren-54FM.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-Ren-54FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Plage de la Belle \u00e9toile","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-la-belle-etoile-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.856960","%_wpgmp_metabox_longitude%":"-3.904309","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_54","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":14337,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Du Porzou","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 Du Porzou<\/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 Du Porzou\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-34-6-photo-categmacrobis-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Du Porzou<\/h2>\n<p>Commune\u00a0: Concarneau<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>41 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de la belle \u00e9toile\".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Ren-54FM.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-Ren-54FS.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>41 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Porzou\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL_22_23_Ren-34_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_Ren-34_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2022-2023","location":{"lat":"47.864426234030475","lng":"-3.9019891174103005","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-du-porzou\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Du Porzou<\/h2>\n<p>Commune\u00a0: Concarneau<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>41 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de la belle \u00e9toile\".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Ren-54FM.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-Ren-54FS.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>41 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Porzou\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL_22_23_Ren-34_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_Ren-34_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Du Porzou","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-du-porzou\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Du Porzou\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-34-6-photo-categmacrobis-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.864426234030475","%_wpgmp_metabox_longitude%":"-3.9019891174103005","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_34#","%_wp_page_template%":"default","%_thumbnail_id%":"11444","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":8787,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Les Grands Sables","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\">Les Grands Sables<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Groix \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\">\nLes Grands Sables<\/h2>\n<p>Latitude : 47.63769802620572|Longitude : -3.4214278368035544<br \/>Commune : Groix<\/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-Ren-44LM.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-Ren-44LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Groix \u2022 2023-2024","location":{"lat":"47.63769802620572","lng":"-3.4214278368035544","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/les-grands-sables\/","zoom":7,"extra_fields":{"post_excerpt":"Groix \u2022 2023-2024","post_content":"<h2 class=\"site\">\nLes Grands Sables<\/h2>\n<p>Latitude : 47.63769802620572|Longitude : -3.4214278368035544<br \/>Commune : Groix<\/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-Ren-44LM.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-Ren-44LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Les Grands Sables","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/les-grands-sables\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.63769802620572","%_wpgmp_metabox_longitude%":"-3.4214278368035544","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_44","%_wp_page_template%":"default","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":13006,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"LPO JEAN-BAPTISTE COLBERT","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\">LPO JEAN-BAPTISTE COLBERT<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Coll\u00e8ge \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>LPO JEAN-BAPTISTE COLBERT<\/h2>\n<p>Commune\u00a0: LORIENT<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Les Grands Sables. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Ren-44LM.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-Ren-44LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Coll\u00e8ge \u2022 2023-2024","location":{"lat":"47.7455721866349","lng":"-3.3823665301757426","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lpo-jean-baptiste-colbert\/","zoom":7,"extra_fields":{"post_excerpt":"Coll\u00e8ge \u2022 2023-2024","post_content":"<h2>LPO JEAN-BAPTISTE COLBERT<\/h2>\n<p>Commune\u00a0: LORIENT<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Les Grands Sables. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Ren-44LM.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-Ren-44LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"LPO JEAN-BAPTISTE COLBERT","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lpo-jean-baptiste-colbert\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.7455721866349","%_wpgmp_metabox_longitude%":"-3.3823665301757426","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_44#","%_wp_page_template%":"default","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":13007,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage des Capucins","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 des Capucins<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Audierne \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 des Capucins<\/h2>\n<p>Latitude : 48.0175957|Longitude : -4.5369767<br \/>Commune : Audierne<\/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-ren-45LM.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-ren-45LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Audierne \u2022 2023-2024","location":{"lat":"48.0175957","lng":"-4.5369767","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-des-capucins\/","zoom":7,"extra_fields":{"post_excerpt":"Audierne \u2022 2023-2024","post_content":"<h2 class=\"site\">\nPlage des Capucins<\/h2>\n<p>Latitude : 48.0175957|Longitude : -4.5369767<br \/>Commune : Audierne<\/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-ren-45LM.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-ren-45LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Plage des Capucins","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-des-capucins\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.0175957","%_wpgmp_metabox_longitude%":"-4.5369767","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_45","%_wp_page_template%":"default","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":13008,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"CLG BOIS DE LOCQUERAN","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\">CLG BOIS DE LOCQUERAN<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Coll\u00e8ge \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>CLG BOIS DE LOCQUERAN<\/h2>\n<p>Commune\u00a0: PLOUHINEC<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage des Capucins. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-ren-45LM.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-ren-45LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Coll\u00e8ge \u2022 2023-2024","location":{"lat":"48.025989165357046","lng":"-4.529639030158131","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-bois-de-locqueran\/","zoom":7,"extra_fields":{"post_excerpt":"Coll\u00e8ge \u2022 2023-2024","post_content":"<h2>CLG BOIS DE LOCQUERAN<\/h2>\n<p>Commune\u00a0: PLOUHINEC<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage des Capucins. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-ren-45LM.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-ren-45LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"CLG BOIS DE LOCQUERAN","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-bois-de-locqueran\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.025989165357046","%_wpgmp_metabox_longitude%":"-4.529639030158131","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_45#","%_wp_page_template%":"default","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":13009,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage des sables Rouges","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 des sables Rouges<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Le Relecq Kerhuon \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 des sables Rouges<\/h2>\n<p>Latitude : 48.391044|Longitude : -4.409162<br \/>Commune : Le Relecq Kerhuon<\/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-Ren-46FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Le Relecq Kerhuon \u2022 2023-2024","location":{"lat":"48.391044","lng":"-4.409162","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-des-sables-rouges\/","zoom":7,"extra_fields":{"post_excerpt":"Le Relecq Kerhuon \u2022 2023-2024","post_content":"<h2 class=\"site\">\nPlage des sables Rouges<\/h2>\n<p>Latitude : 48.391044|Longitude : -4.409162<br \/>Commune : Le Relecq Kerhuon<\/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-Ren-46FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage des sables Rouges","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-des-sables-rouges\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.391044","%_wpgmp_metabox_longitude%":"-4.409162","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_46","%_wp_page_template%":"default","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":13010,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"LG LA PEROUSE-KERICHEN","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\">LG LA PEROUSE-KERICHEN<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Lyc\u00e9e \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>LG LA PEROUSE-KERICHEN<\/h2>\n<p>Commune\u00a0: BREST<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Lyc\u00e9e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage des sables Rouges. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Ren-46FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Lyc\u00e9e \u2022 2023-2024","location":{"lat":"48.40620902730001","lng":"-4.4819627188189335","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lg-la-perouse-kerichen\/","zoom":7,"extra_fields":{"post_excerpt":"Lyc\u00e9e \u2022 2023-2024","post_content":"<h2>LG LA PEROUSE-KERICHEN<\/h2>\n<p>Commune\u00a0: BREST<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Lyc\u00e9e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage des sables Rouges. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Ren-46FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"LG LA PEROUSE-KERICHEN","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lg-la-perouse-kerichen\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.40620902730001","%_wpgmp_metabox_longitude%":"-4.4819627188189335","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_46#","%_wp_page_template%":"default","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":13011,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Beau Rivage","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 Beau Rivage<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Caurel \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 Beau Rivage<\/h2>\n<p>Latitude : 48.20589|Longitude : -3.04939<br \/>Commune : Caurel<\/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-Ren-47LM.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-Ren-47LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Caurel \u2022 2023-2024","location":{"lat":"48.20589","lng":"-3.04939","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-beau-rivage-3\/","zoom":7,"extra_fields":{"post_excerpt":"Caurel \u2022 2023-2024","post_content":"<h2 class=\"site\">\nPlage de Beau Rivage<\/h2>\n<p>Latitude : 48.20589|Longitude : -3.04939<br \/>Commune : Caurel<\/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-Ren-47LM.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-Ren-47LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Plage de Beau Rivage","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-beau-rivage-3\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.20589","%_wpgmp_metabox_longitude%":"-3.04939","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_47","%_wp_page_template%":"default","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":13012,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Guidel","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 Guidel<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Guidel \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 Guidel<\/h2>\n<p>Latitude : 47.76677|Longitude : -3.529943<br \/>Commune : Guidel<\/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-Ren-36LM.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-Ren-36LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Guidel \u2022 2023-2024","location":{"lat":"47.76677","lng":"-3.529943","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-guidel-2\/","zoom":7,"extra_fields":{"post_excerpt":"Guidel \u2022 2023-2024","post_content":"<h2 class=\"site\">\nPlage de Guidel<\/h2>\n<p>Latitude : 47.76677|Longitude : -3.529943<br \/>Commune : Guidel<\/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-Ren-36LM.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-Ren-36LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Plage de Guidel","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-guidel-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.76677","%_wpgmp_metabox_longitude%":"-3.529943","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_36","%_wp_page_template%":"default","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":12996,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"LGT VICTOR HUGO","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\">LGT VICTOR HUGO<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Coll\u00e8ge \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>LGT VICTOR HUGO<\/h2>\n<p>Commune\u00a0: HENNEBONT<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Guidel. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Ren-36LM.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-Ren-36LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Coll\u00e8ge \u2022 2023-2024","location":{"lat":"47.80840708931602","lng":"-3.2621325896987536","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lgt-victor-hugo\/","zoom":7,"extra_fields":{"post_excerpt":"Coll\u00e8ge \u2022 2023-2024","post_content":"<h2>LGT VICTOR HUGO<\/h2>\n<p>Commune\u00a0: HENNEBONT<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Guidel. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Ren-36LM.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-Ren-36LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"LGT VICTOR HUGO","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lgt-victor-hugo\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.80840708931602","%_wpgmp_metabox_longitude%":"-3.2621325896987536","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_36#","%_wp_page_template%":"default","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":12997,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Guichen","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 Guichen<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Guichen \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\">Berge de Guichen<\/h2>\n<p>Latitude : 48.002292N | Longitude : 1.773805W<br \/>Commune : Guichen<\/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-Ren-39FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Guichen \u2022 2023-2024","location":{"lat":"48.002292","lng":"-1.773805","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-guichen\/","zoom":7,"extra_fields":{"post_excerpt":"Guichen \u2022 2023-2024","post_content":"<h2 class=\"site\">Berge de Guichen<\/h2>\n<p>Latitude : 48.002292N | Longitude : 1.773805W<br \/>Commune : Guichen<\/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-Ren-39FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Berge de Guichen","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-guichen\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.002292","%_wpgmp_metabox_longitude%":"-1.773805","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_39","%_wp_page_template%":"default","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":10630,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"CLG PR NOTRE DAME","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\">CLG PR NOTRE DAME<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Coll\u00e8ge \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>CLG PR NOTRE DAME<\/h2>\n<p>Commune\u00a0: BREST<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage du moulin blanc. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Ren-22LM.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-Ren-22LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Coll\u00e8ge \u2022 2023-2024","location":{"lat":"48.37867295384271","lng":"-4.512837572220521","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-pr-notre-dame\/","zoom":7,"extra_fields":{"post_excerpt":"Coll\u00e8ge \u2022 2023-2024","post_content":"<h2>CLG PR NOTRE DAME<\/h2>\n<p>Commune\u00a0: BREST<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage du moulin blanc. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Ren-22LM.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-Ren-22LS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"CLG PR NOTRE DAME","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-pr-notre-dame\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.37867295384271","%_wpgmp_metabox_longitude%":"-4.512837572220521","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_22#","%_wp_page_template%":"default","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":13446,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage Bon Abri","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 Bon Abri<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Hillion \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=\"Plage Bon Abri\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-24_1_Photo_Site-300x169.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage Bon Abri<\/h2>\n<p>Latitude : 48.52672920N | Longitude : 2.65733261W<br \/>Commune : Hillion<\/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-Ren-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-Ren-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-Ren-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-Ren-24FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Hillion \u2022 2022-2023-2024","location":{"lat":"48.5267292068902","lng":"-2.6573326102277166","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-bon-abri\/","zoom":7,"extra_fields":{"post_excerpt":"Hillion \u2022 2022-2023-2024","post_content":"<h2 class=\"site\">Plage Bon Abri<\/h2>\n<p>Latitude : 48.52672920N | Longitude : 2.65733261W<br \/>Commune : Hillion<\/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-Ren-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-Ren-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-Ren-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-Ren-24FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Plage Bon Abri","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-bon-abri\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage Bon Abri\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-24_1_Photo_Site-300x169.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.5267292068902","%_wpgmp_metabox_longitude%":"-2.6573326102277166","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_24","%_wp_page_template%":"default","%_thumbnail_id%":"11440","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":8766,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Fran\u00e7ois Lorant","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 Fran\u00e7ois Lorant<\/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 id=\"contenu_article\"><h2>Coll\u00e8ge Fran\u00e7ois Lorant<\/h2>\n<p>Commune\u00a0: Monconteur<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>98 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Bon Abri\".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Ren-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-Ren-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>98 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Bon Abri\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-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-Ren-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":"48.3552554972564","lng":"-2.634696846229154","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-francois-lorant\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2022-2023-2024","post_content":"<h2>Coll\u00e8ge Fran\u00e7ois Lorant<\/h2>\n<p>Commune\u00a0: Monconteur<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>98 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Bon Abri\".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Ren-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-Ren-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>98 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Bon Abri\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-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-Ren-24FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Fran\u00e7ois Lorant","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-francois-lorant\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.3552554972564","%_wpgmp_metabox_longitude%":"-2.634696846229154","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_24#","%_wp_page_template%":"default","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":8767,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Pointe Pradic","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\">Pointe Pradic<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \u00c9tel \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=\"Pointe Pradic\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-25-2_Photo_Laisse-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Pointe Pradic<\/h2>\n<p>Latitude : 47.651840N | Longitude :  3.204479W<br \/>Commune : \u00c9tel<\/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-Ren-25FM.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-Ren-25FM.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-Ren-25FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"\u00c9tel \u2022 2022-2023-2024","location":{"lat":"47.651840","lng":"-3.204479","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pointe-pradic\/","zoom":7,"extra_fields":{"post_excerpt":"\u00c9tel \u2022 2022-2023-2024","post_content":"<h2 class=\"site\">Pointe Pradic<\/h2>\n<p>Latitude : 47.651840N | Longitude :  3.204479W<br \/>Commune : \u00c9tel<\/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-Ren-25FM.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-Ren-25FM.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-Ren-25FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Pointe Pradic","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pointe-pradic\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pointe Pradic\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-25-2_Photo_Laisse-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.651840","%_wpgmp_metabox_longitude%":"-3.204479","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_25","%_wp_page_template%":"default","%_thumbnail_id%":"11441","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":8768,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"CLG GOH LANNO","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\">CLG GOH LANNO<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Coll\u00e8ge \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>CLG GOH LANNO<\/h2>\n<p>Commune\u00a0: PLUVIGNER<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>0 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Pointe Pradic. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Ren-25FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Coll\u00e8ge \u2022 2023-2024","location":{"lat":"47.77890196552875","lng":"-3.006132228319367","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-goh-lanno\/","zoom":7,"extra_fields":{"post_excerpt":"Coll\u00e8ge \u2022 2023-2024","post_content":"<h2>CLG GOH LANNO<\/h2>\n<p>Commune\u00a0: PLUVIGNER<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>0 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Pointe Pradic. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Ren-25FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"CLG GOH LANNO","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-goh-lanno\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.77890196552875","%_wpgmp_metabox_longitude%":"-3.006132228319367","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_25#","%_wp_page_template%":"default","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":12989,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Goas Lagorn","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 Goas Lagorn<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Lannion \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=\"Plage de Goas Lagorn\" width=\"300\" height=\"168\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Ren-30-site-300x168.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de Goas Lagorn<\/h2>\n<p>Latitude : 48.7450697N | Longitude : 3.5503664W<br \/>Commune : Lannion<\/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-Ren-30LM.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-Ren-30LS.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-Ren-30FM.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-Ren-30FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Lannion \u2022 2022-2023-2024","location":{"lat":"48.7450697","lng":"-3.5503664","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-goas-lagorn\/","zoom":7,"extra_fields":{"post_excerpt":"Lannion \u2022 2022-2023-2024","post_content":"<h2 class=\"site\">Plage de Goas Lagorn<\/h2>\n<p>Latitude : 48.7450697N | Longitude : 3.5503664W<br \/>Commune : Lannion<\/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-Ren-30LM.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-Ren-30LS.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-Ren-30FM.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-Ren-30FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Plage de Goas Lagorn","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-goas-lagorn\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de Goas Lagorn\" width=\"300\" height=\"168\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Ren-30-site-300x168.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.7450697","%_wpgmp_metabox_longitude%":"-3.5503664","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_30","%_wp_page_template%":"default","%_thumbnail_id%":"11449","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":8778,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Charles Le Goffic","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 Charles Le Goffic<\/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 id=\"contenu_article\"><h2>Coll\u00e8ge Charles Le Goffic<\/h2>\n<p>Commune\u00a0: Lannion<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>90 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Goas Lagorn\".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Ren-30LM.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-Ren-30LS.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>90 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Goas Lagorn\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-30FM.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-Ren-30FS.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":"48.74418830185949","lng":"-3.4716634020342294","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-charles-le-goffic\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2022-2023-2024","post_content":"<h2>Coll\u00e8ge Charles Le Goffic<\/h2>\n<p>Commune\u00a0: Lannion<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>90 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Goas Lagorn\".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Ren-30LM.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-Ren-30LS.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>90 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Goas Lagorn\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-30FM.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-Ren-30FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Charles Le Goffic","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-charles-le-goffic\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.74418830185949","%_wpgmp_metabox_longitude%":"-3.4716634020342294","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_30#","%_wp_page_template%":"default","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":8779,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Port Guen","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 Port Guen<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Le Palais \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=\"Plage de Port Guen\" width=\"300\" height=\"224\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-31-1_Photo_Site-300x224.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de Port Guen<\/h2>\n<p>Latitude : 47.33422N | Longitude : 3.14738W<br \/>Commune : Le Palais<\/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-Ren-31FM.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-Ren-31FS.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-Ren-31FM.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-Ren-31FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Le Palais \u2022 2022-2023-2024","location":{"lat":"47.33422","lng":"-3.14738","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-port-guen\/","zoom":7,"extra_fields":{"post_excerpt":"Le Palais \u2022 2022-2023-2024","post_content":"<h2 class=\"site\">Plage de Port Guen<\/h2>\n<p>Latitude : 47.33422N | Longitude : 3.14738W<br \/>Commune : Le Palais<\/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-Ren-31FM.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-Ren-31FS.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-Ren-31FM.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-Ren-31FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Plage de Port Guen","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-port-guen\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de Port Guen\" width=\"300\" height=\"224\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-31-1_Photo_Site-300x224.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.33422","%_wpgmp_metabox_longitude%":"-3.14738","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_31","%_wp_page_template%":"default","%_thumbnail_id%":"11442","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":8780,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Michel Lotte","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 Michel Lotte<\/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 id=\"contenu_article\"><h2>Coll\u00e8ge Michel Lotte<\/h2>\n<p>Commune\u00a0: Le Palais<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>41 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Port Guen\".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Ren-31FM.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-Ren-31FS.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>41 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Port Guen\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-31FM.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-Ren-31FS.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.336686558262286","lng":"-3.160975086739008","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-michel-lotte\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2022-2023-2024","post_content":"<h2>Coll\u00e8ge Michel Lotte<\/h2>\n<p>Commune\u00a0: Le Palais<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>41 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Port Guen\".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Ren-31FM.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-Ren-31FS.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>41 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Port Guen\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-31FM.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-Ren-31FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Michel Lotte","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-michel-lotte\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.336686558262286","%_wpgmp_metabox_longitude%":"-3.160975086739008","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_31#","%_wp_page_template%":"default","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":8781,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Germaine Tillion","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 Germaine Tillion<\/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-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 Germaine Tillion\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren_12-8_Photo_Meso-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Germaine Tillion<\/h2>\n<p>Commune\u00a0: La M\u00e9zi\u00e8re<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>50 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Des Chevrets\" de la commune de Saint-Coulomb.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Ren-12LM.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-Ren-12LS.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>50 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Des Chevrets\" de la commune de Saint-Coulomb.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-12FM.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-Ren-12FS.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>50 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Des Chevrets\" de la commune de Saint-Coulomb. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Ren_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_Ren_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_Ren_12FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2021-2022-2023-2024","location":{"lat":"48.21300763825999","lng":"-1.746214632487204","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-germaine-tillion\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2021-2022-2023-2024","post_content":"<h2>Coll\u00e8ge Germaine Tillion<\/h2>\n<p>Commune\u00a0: La M\u00e9zi\u00e8re<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>50 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Des Chevrets\" de la commune de Saint-Coulomb.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/Pal-23-24-Ren-12LM.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-Ren-12LS.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>50 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Des Chevrets\" de la commune de Saint-Coulomb.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-12FM.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-Ren-12FS.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>50 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Des Chevrets\" de la commune de Saint-Coulomb. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Ren_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_Ren_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_Ren_12FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Germaine Tillion","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-germaine-tillion\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Germaine Tillion\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren_12-8_Photo_Meso-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.21300763825999","%_wpgmp_metabox_longitude%":"-1.746214632487204","%_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:\"31\";}","%refpoint%":"PAL_21-22_Ren_12#","%_wp_page_template%":"default","%_thumbnail_id%":"11452","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":5277,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Locmariaquer","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 Locmariaquer<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Locmariaquer \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\">Plage de Locmariaquer<\/h2>\n<p>Latitude : 47.556228\u00b0N | Longitude : 2.94407117\u00b0W<br \/>Commune : Locmariaquer<\/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-Ren-18FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/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_Ren_18FM.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_Ren_18Fs.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_Ren_18FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Locmariaquer \u2022 2021-2022-2023-2024","location":{"lat":"47.55622879151624","lng":"-2.9440711772366397","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-locmariaquer\/","zoom":7,"extra_fields":{"post_excerpt":"Locmariaquer \u2022 2021-2022-2023-2024","post_content":"<h2 class=\"site\">Plage de Locmariaquer<\/h2>\n<p>Latitude : 47.556228\u00b0N | Longitude : 2.94407117\u00b0W<br \/>Commune : Locmariaquer<\/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-Ren-18FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/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_Ren_18FM.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_Ren_18Fs.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_Ren_18FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage de Locmariaquer","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-locmariaquer\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.55622879151624","%_wpgmp_metabox_longitude%":"-2.9440711772366397","%_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:\"31\";}","%refpoint%":"PAL_21-22_Ren_18","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2021-2022, 2023-2024"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":5288,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Kerplouz LaSalle","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 Kerplouz LaSalle<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Classe de 1er STAV \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 Kerplouz LaSalle<\/h2>\n<p>Commune\u00a0: Auray<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>18 \u00e9l\u00e8ves de Classe de 1er STAV<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Locmariaquer. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Ren-18FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Classe de 1er STAV \u2022 2023-2024","location":{"lat":"47.65764363413467","lng":"-2.9717550301812694","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-kerplouz-lasalle\/","zoom":7,"extra_fields":{"post_excerpt":"Classe de 1er STAV \u2022 2023-2024","post_content":"<h2>Lyc\u00e9e Kerplouz LaSalle<\/h2>\n<p>Commune\u00a0: Auray<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>18 \u00e9l\u00e8ves de Classe de 1er STAV<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Locmariaquer. <ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Ren-18FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Kerplouz LaSalle","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-kerplouz-lasalle\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.65764363413467","%_wpgmp_metabox_longitude%":"-2.9717550301812694","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_18#","%_wp_page_template%":"default","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":12985,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage du moulin blanc","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 moulin blanc<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Le Relecq-Kerhuon \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=\"Plage du moulin blanc\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Ren-22PhotodeSituation-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage du moulin blanc<\/h2>\n<p>Latitude : 48.396876N | Longitude : 4.422743W<br \/>Commune : Le Relecq-Kerhuon<\/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-Ren-22LM.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-Ren-22LS.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-Ren-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-Ren-22FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Le Relecq-Kerhuon \u2022 2022-2023-2024","location":{"lat":"48.396876","lng":"-4.422743","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-moulin-blanc\/","zoom":7,"extra_fields":{"post_excerpt":"Le Relecq-Kerhuon \u2022 2022-2023-2024","post_content":"<h2 class=\"site\">Plage du moulin blanc<\/h2>\n<p>Latitude : 48.396876N | Longitude : 4.422743W<br \/>Commune : Le Relecq-Kerhuon<\/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-Ren-22LM.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-Ren-22LS.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-Ren-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-Ren-22FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Plage du moulin blanc","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-moulin-blanc\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage du moulin blanc\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Ren-22PhotodeSituation-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.396876","%_wpgmp_metabox_longitude%":"-4.422743","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_22","%_wp_page_template%":"default","%_thumbnail_id%":"11447","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":8762,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage des Sables Blancs","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 des Sables Blancs<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Concarneau \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=\"Plage des Sables Blancs\" width=\"300\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren4-1_photo_Site-300x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage des Sables Blancs<\/h2>\n<p>Latitude : 47.881874\u00b0N | Longitude : 3.9333625\u00b0W<br \/>Commune : Concarneau<\/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-Ren-4FM.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-Ren-4FM.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-Ren-4FS.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_Ren_4FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/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_Ren_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_Ren_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_Ren_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_Ren_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_Ren_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_Ren_4_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Concarneau \u2022 2019-2024","location":{"lat":"47.881874","lng":"-3.9333625","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-des-sables-blancs\/","zoom":7,"extra_fields":{"post_excerpt":"Concarneau \u2022 2019-2024","post_content":"<h2 class=\"site\">Plage des Sables Blancs<\/h2>\n<p>Latitude : 47.881874\u00b0N | Longitude : 3.9333625\u00b0W<br \/>Commune : Concarneau<\/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-Ren-4FM.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-Ren-4FM.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-Ren-4FS.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_Ren_4FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/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_Ren_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_Ren_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_Ren_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_Ren_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_Ren_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_Ren_4_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage des Sables Blancs","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-des-sables-blancs\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage des Sables Blancs\" width=\"300\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren4-1_photo_Site-300x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.881874","%_wpgmp_metabox_longitude%":"-3.9333625","%_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:\"31\";}","%refpoint%":"PAL_19-20_Ren_4","%_wp_page_template%":"default","%_thumbnail_id%":"11454","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":4285,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge les Sables Blancs","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 les Sables Blancs<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\u00e8me \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=\"Coll\u00e8ge les Sables Blancs\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren4-5_Photo_VracMacro-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge les Sables Blancs<\/h2>\n<p>Commune : Concarneau<br \/>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>35 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage des Sables Blancs\" de la commune de Concarneau.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Ren-4FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>22 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage des Sables Blancs\" de la commune de Concarneau.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-4FM.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-Ren-4FS.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>20 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage des Sables Blancs\" de la commune de Concarneau. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Ren_4FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>60 \u00e9l\u00e8ves de 2nde\/3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage des Sables Blancs\" de la commune de Concarneau.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Ren_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_Ren_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_Ren_4FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>28 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Ren_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_Ren_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_Ren_4_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2019-2024","location":{"lat":"47.87845967266832","lng":"-3.925235815198558","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-les-sables-blancs\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2019-2024","post_content":"<h2>Coll\u00e8ge les Sables Blancs<\/h2>\n<p>Commune : Concarneau<br \/>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>35 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage des Sables Blancs\" de la commune de Concarneau.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2024\/04\/PAL-23-24-Ren-4FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>22 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage des Sables Blancs\" de la commune de Concarneau.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-4FM.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-Ren-4FS.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>20 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage des Sables Blancs\" de la commune de Concarneau. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Ren_4FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>60 \u00e9l\u00e8ves de 2nde\/3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage des Sables Blancs\" de la commune de Concarneau.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Ren_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_Ren_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_Ren_4FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>28 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Ren_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_Ren_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_Ren_4_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge les Sables Blancs","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-les-sables-blancs\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge les Sables Blancs\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren4-5_Photo_VracMacro-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.87845967266832","%_wpgmp_metabox_longitude%":"-3.925235815198558","%_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:\"31\";}","%refpoint%":"PAL_19-20_Ren_4#","%_wp_page_template%":"default","%_thumbnail_id%":"11455","taxonomy=type-site-classe":"Classes","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-classe.png"},"id":4286,"custom_filters":{"%type-site-classe%":["Classes"],"%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-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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage Des Chevrets","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 Des Chevrets<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint-Coulomb \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=\"Plage Des Chevrets\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren_12-2_Photo_Laisse-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage Des Chevrets<\/h2>\n<p>Latitude : 48.691613\u00b0N | Longitude : 1.942897\u00b0W<br \/>Commune : Saint-Coulomb<\/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-Ren-12LM.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-Ren-12LS.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-Ren-12FM.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-Ren-12FS.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_Ren_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_Ren_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_Ren_12FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Saint-Coulomb \u2022 2021-2022-2023-2024","location":{"lat":"48.691613","lng":"-1.942897","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-des-chevrets\/","zoom":7,"extra_fields":{"post_excerpt":"Saint-Coulomb \u2022 2021-2022-2023-2024","post_content":"<h2 class=\"site\">Plage Des Chevrets<\/h2>\n<p>Latitude : 48.691613\u00b0N | Longitude : 1.942897\u00b0W<br \/>Commune : Saint-Coulomb<\/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-Ren-12LM.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-Ren-12LS.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-Ren-12FM.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-Ren-12FS.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_Ren_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_Ren_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_Ren_12FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage Des Chevrets","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-des-chevrets\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage Des Chevrets\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren_12-2_Photo_Laisse-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.691613","%_wpgmp_metabox_longitude%":"-1.942897","%_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:\"31\";}","%refpoint%":"PAL_21-22_Ren_12","%_wp_page_template%":"default","%_thumbnail_id%":"11451","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":5276,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Ch\u00e2teau Serein","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 Ch\u00e2teau Serein<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Pl\u00e9venon \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 Ch\u00e2teau Serein<\/h2>\n<p>Latitude : 48.64515650034302|Longitude : -2.3077565435200316<br \/>Commune : Pl\u00e9venon<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Pl\u00e9venon \u2022 2023-2024","location":{"lat":"48.64515650034302","lng":"-2.3077565435200316","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-chateau-serein\/","zoom":7,"extra_fields":{"post_excerpt":"Pl\u00e9venon \u2022 2023-2024","post_content":"<h2 class=\"site\">\nPlage de Ch\u00e2teau Serein<\/h2>\n<p>Latitude : 48.64515650034302|Longitude : -2.3077565435200316<br \/>Commune : Pl\u00e9venon<\/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 Ch\u00e2teau Serein","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-chateau-serein\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.64515650034302","%_wpgmp_metabox_longitude%":"-2.3077565435200316","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_56","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":13449,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e du Men\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\">Lyc\u00e9e du Men\u00e9<\/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 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 du Men\u00e9<\/h2>\n<p>Commune\u00a0: Merdrignac<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Ch\u00e2teau Serein. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2023-2024","location":{"lat":"48.1901343126754","lng":"-2.42263118386057","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-du-mene\/","zoom":7,"extra_fields":{"post_excerpt":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2023-2024","post_content":"<h2>Lyc\u00e9e du Men\u00e9<\/h2>\n<p>Commune\u00a0: Merdrignac<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Ch\u00e2teau Serein. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"Lyc\u00e9e du Men\u00e9","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-du-mene\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.1901343126754","%_wpgmp_metabox_longitude%":"-2.42263118386057","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_56#","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":13450,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge du Blavet","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 du Blavet<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Lanester \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 du Blavet<\/h2>\n<p>Latitude : 47.756415|Longitude : 3.3189909<br \/>Commune : Lanester<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Lanester \u2022 2023-2024","location":{"lat":"47.756415","lng":"-3.3189909","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-du-blavet\/","zoom":7,"extra_fields":{"post_excerpt":"Lanester \u2022 2023-2024","post_content":"<h2 class=\"site\">\nBerge du Blavet<\/h2>\n<p>Latitude : 47.756415|Longitude : 3.3189909<br \/>Commune : Lanester<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"Berge du Blavet","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-du-blavet\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.756415","%_wpgmp_metabox_longitude%":"-3.3189909","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_55","%_wp_page_template%":"default","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":13026,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Saint-Suliac","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-Suliac<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint-Suliac \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 Saint-Suliac<\/h2>\n<p>Latitude : 48.564377|Longitude : -1.972631<br \/>Commune : Saint-Suliac<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Saint-Suliac \u2022 2023-2024","location":{"lat":"48.564377","lng":"-1.972631","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-saint-suliac\/","zoom":7,"extra_fields":{"post_excerpt":"Saint-Suliac \u2022 2023-2024","post_content":"<h2 class=\"site\">\nBerge de Saint-Suliac<\/h2>\n<p>Latitude : 48.564377|Longitude : -1.972631<br \/>Commune : Saint-Suliac<\/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 Saint-Suliac","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-saint-suliac\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.564377","%_wpgmp_metabox_longitude%":"-1.972631","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_49","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":13016,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"CLG ROGER VERCEL","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\">CLG ROGER VERCEL<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                coll\u00e8ge \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>CLG ROGER VERCEL<\/h2>\n<p>Commune\u00a0: DINAN<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge de Saint-Suliac. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"coll\u00e8ge \u2022 2023-2024","location":{"lat":"48.450785028067216","lng":"-2.0430359608219284","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-roger-vercel\/","zoom":7,"extra_fields":{"post_excerpt":"coll\u00e8ge \u2022 2023-2024","post_content":"<h2>CLG ROGER VERCEL<\/h2>\n<p>Commune\u00a0: DINAN<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge de Saint-Suliac. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"CLG ROGER VERCEL","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-roger-vercel\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.450785028067216","%_wpgmp_metabox_longitude%":"-2.0430359608219284","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_49#","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":13017,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Plounevezel","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 Plounevezel<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Plounevezel \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 Plounevezel<\/h2>\n<p>Latitude : 48.299995|Longitude : -3.552384<br \/>Commune : Plounevezel<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Plounevezel \u2022 2023-2024","location":{"lat":"48.299995","lng":"-3.552384","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-plounevezel\/","zoom":7,"extra_fields":{"post_excerpt":"Plounevezel \u2022 2023-2024","post_content":"<h2 class=\"site\">\nBerge de Plounevezel<\/h2>\n<p>Latitude : 48.299995|Longitude : -3.552384<br \/>Commune : Plounevezel<\/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 Plounevezel","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-plounevezel\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.299995","%_wpgmp_metabox_longitude%":"-3.552384","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_51","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":13020,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"CLG PR ST TREMEUR","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\">CLG PR ST TREMEUR<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                coll\u00e8ge \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>CLG PR ST TREMEUR<\/h2>\n<p>Commune\u00a0: CARHAIX-PLOUGUER<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge de Plounevezel. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"coll\u00e8ge \u2022 2023-2024","location":{"lat":"48.274468370958985","lng":"-3.5748162608331153","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-pr-st-tremeur\/","zoom":7,"extra_fields":{"post_excerpt":"coll\u00e8ge \u2022 2023-2024","post_content":"<h2>CLG PR ST TREMEUR<\/h2>\n<p>Commune\u00a0: CARHAIX-PLOUGUER<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge de Plounevezel. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"CLG PR ST TREMEUR","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-pr-st-tremeur\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.274468370958985","%_wpgmp_metabox_longitude%":"-3.5748162608331153","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_51#","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":13021,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de Montfort sur Meu","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 Montfort sur Meu<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Montfort sur Meu \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 Montfort sur Meu<\/h2>\n<p>Latitude : 48.1291667|Longitude : -1.9488333333333334<br \/>Commune : Montfort sur Meu<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Montfort sur Meu \u2022 2023-2024","location":{"lat":"48.1291667","lng":"-1.9488333333333334","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-montfort-sur-meu\/","zoom":7,"extra_fields":{"post_excerpt":"Montfort sur Meu \u2022 2023-2024","post_content":"<h2 class=\"site\">\nBerge de Montfort sur Meu<\/h2>\n<p>Latitude : 48.1291667|Longitude : -1.9488333333333334<br \/>Commune : Montfort sur Meu<\/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 Montfort sur Meu","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-montfort-sur-meu\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.1291667","%_wpgmp_metabox_longitude%":"-1.9488333333333334","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_52","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":13022,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"LGT RENE CASSIN","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\">LGT RENE CASSIN<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Lyc\u00e9e \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>LGT RENE CASSIN<\/h2>\n<p>Commune\u00a0: MONTFORT-SUR-MEU<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Lyc\u00e9e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge de Montfort sur Meu. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Lyc\u00e9e \u2022 2023-2024","location":{"lat":"48.14274663970723","lng":"-1.9636687375679691","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lgt-rene-cassin\/","zoom":7,"extra_fields":{"post_excerpt":"Lyc\u00e9e \u2022 2023-2024","post_content":"<h2>LGT RENE CASSIN<\/h2>\n<p>Commune\u00a0: MONTFORT-SUR-MEU<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Lyc\u00e9e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge de Montfort sur Meu. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"LGT RENE CASSIN","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lgt-rene-cassin\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.14274663970723","%_wpgmp_metabox_longitude%":"-1.9636687375679691","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_52#","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":13023,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Port Manec&rsquo;h","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 Port Manec&rsquo;h<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Nevez  \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 Port Manec'h<\/h2>\n<p>Latitude : 47.80456145622553|Longitude : -3.7404910853868496<br \/>Commune : Nevez <\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Nevez  \u2022 2023-2024","location":{"lat":"47.80456145622553","lng":"-3.7404910853868496","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-port-manech\/","zoom":7,"extra_fields":{"post_excerpt":"Nevez  \u2022 2023-2024","post_content":"<h2 class=\"site\">\nPlage de Port Manec'h<\/h2>\n<p>Latitude : 47.80456145622553|Longitude : -3.7404910853868496<br \/>Commune : Nevez <\/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 Port Manec&rsquo;h","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-port-manech\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.80456145622553","%_wpgmp_metabox_longitude%":"-3.7404910853868496","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_53","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":13024,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"CLG LEO FERRE","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\">CLG LEO FERRE<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Coll\u00e8ge \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>CLG LEO FERRE<\/h2>\n<p>Commune\u00a0: SCAER<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Port Manec'h. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Coll\u00e8ge \u2022 2023-2024","location":{"lat":"48.133286895331025","lng":"-3.663776708774959","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-leo-ferre\/","zoom":7,"extra_fields":{"post_excerpt":"Coll\u00e8ge \u2022 2023-2024","post_content":"<h2>CLG LEO FERRE<\/h2>\n<p>Commune\u00a0: SCAER<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Port Manec'h. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"CLG LEO FERRE","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-leo-ferre\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.133286895331025","%_wpgmp_metabox_longitude%":"-3.663776708774959","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_53#","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":13025,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"CLG JEAN LURCAT","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\">CLG JEAN LURCAT<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Coll\u00e8ge \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>CLG JEAN LURCAT<\/h2>\n<p>Commune\u00a0: LANESTER<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge du Blavet. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Coll\u00e8ge \u2022 2023-2024","location":{"lat":"47.7634043322557","lng":"-3.3395495185379134","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-jean-lurcat\/","zoom":7,"extra_fields":{"post_excerpt":"Coll\u00e8ge \u2022 2023-2024","post_content":"<h2>CLG JEAN LURCAT<\/h2>\n<p>Commune\u00a0: LANESTER<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Berge du Blavet. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"CLG JEAN LURCAT","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-jean-lurcat\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"47.7634043322557","%_wpgmp_metabox_longitude%":"-3.3395495185379134","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_55#","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":13027,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage du Dourlin","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 Dourlin<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Pleumeur-Bodou \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=\"Plage du Dourlin\" width=\"300\" height=\"200\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-37-laisse-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage du Dourlin<\/h2>\n<p>Latitude : 48.80029N | Longitude : 3.585766W<br \/>Commune : Pleumeur-Bodou<\/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-Ren-37FM.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-Ren-37FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Pleumeur-Bodou \u2022 2022-2023","location":{"lat":"48.800290","lng":"-3.585766","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-dourlin\/","zoom":7,"extra_fields":{"post_excerpt":"Pleumeur-Bodou \u2022 2022-2023","post_content":"<h2 class=\"site\">Plage du Dourlin<\/h2>\n<p>Latitude : 48.80029N | Longitude : 3.585766W<br \/>Commune : Pleumeur-Bodou<\/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-Ren-37FM.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-Ren-37FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Plage du Dourlin","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-dourlin\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage du Dourlin\" width=\"300\" height=\"200\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-37-laisse-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.800290","%_wpgmp_metabox_longitude%":"-3.585766","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_37","%_wp_page_template%":"default","%_thumbnail_id%":"11445","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":8788,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Gwer Halou","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 Gwer Halou<\/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 id=\"contenu_article\"><h2>Coll\u00e8ge Gwer Halou<\/h2>\n<p>Commune\u00a0: Callac<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>19 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Montrichard\".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-37FM.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-Ren-37FS.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.38812742484462","lng":"-3.3872803308831183","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-gwer-halou\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Gwer Halou<\/h2>\n<p>Commune\u00a0: Callac<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>19 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Montrichard\".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-37FM.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-Ren-37FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Gwer Halou","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-gwer-halou\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.38812742484462","%_wpgmp_metabox_longitude%":"-3.3872803308831183","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_37#","%_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":8789,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Cherrueix","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 Cherrueix<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Cherrueix \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 Cherrueix<\/h2>\n<p>Latitude : 48.607476|Longitude : -1.753561<br \/>Commune : Cherrueix<\/p>\n<h3>Ann\u00e9e 2023-2024<\/h3>\n<p>Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Cherrueix \u2022 2023-2024","location":{"lat":"48.607476","lng":"-1.753561","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-cherrueix\/","zoom":7,"extra_fields":{"post_excerpt":"Cherrueix \u2022 2023-2024","post_content":"<h2 class=\"site\">\nPlage de Cherrueix<\/h2>\n<p>Latitude : 48.607476|Longitude : -1.753561<br \/>Commune : Cherrueix<\/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 Cherrueix","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-cherrueix\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.607476","%_wpgmp_metabox_longitude%":"-1.753561","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_43","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":13004,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"CLG PR ST MICHEL","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\">CLG PR ST MICHEL<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Coll\u00e8ge \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>CLG PR ST MICHEL<\/h2>\n<p>Commune\u00a0: SAINT-AUBIN-D'AUBIGNE<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Cherrueix. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Coll\u00e8ge \u2022 2023-2024","location":{"lat":"48.10806825795469","lng":"-1.659697582818122","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-pr-st-michel\/","zoom":7,"extra_fields":{"post_excerpt":"Coll\u00e8ge \u2022 2023-2024","post_content":"<h2>CLG PR ST MICHEL<\/h2>\n<p>Commune\u00a0: SAINT-AUBIN-D'AUBIGNE<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de Coll\u00e8ge<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Cherrueix. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"CLG PR ST MICHEL","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/clg-pr-st-michel\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.10806825795469","%_wpgmp_metabox_longitude%":"-1.659697582818122","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_43#","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":13005,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge De La Fontaine Blanche","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 De La Fontaine Blanche<\/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 id=\"contenu_article\"><h2>Coll\u00e8ge De La Fontaine Blanche<\/h2>\n<p>Commune\u00a0: Plougastel-Daoulas<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>135 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du moulin blanc\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-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-Ren-22FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2022-2023","location":{"lat":"48.37173051166066","lng":"-4.361848832737221","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-de-la-fontaine-blanche\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge De La Fontaine Blanche<\/h2>\n<p>Commune\u00a0: Plougastel-Daoulas<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>135 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du moulin blanc\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-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-Ren-22FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge De La Fontaine Blanche","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-de-la-fontaine-blanche\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.37173051166066","%_wpgmp_metabox_longitude%":"-4.361848832737221","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_22#","%_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":8763,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage Suscinio","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 Suscinio<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Sarzeau \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=\"Plage Suscinio\" width=\"160\" height=\"120\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Ren-23Laisse-de-mer.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage Suscinio<\/h2>\n<p>Latitude : 47.504683N | Longitude : 2.737493W<br \/>Commune : Sarzeau<\/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_Ren-23_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_Ren-23_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Sarzeau \u2022 2022-2023","location":{"lat":"47.504683","lng":"-2.737493","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-suscinio\/","zoom":7,"extra_fields":{"post_excerpt":"Sarzeau \u2022 2022-2023","post_content":"<h2 class=\"site\">Plage Suscinio<\/h2>\n<p>Latitude : 47.504683N | Longitude : 2.737493W<br \/>Commune : Sarzeau<\/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_Ren-23_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_Ren-23_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Plage Suscinio","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-suscinio\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage Suscinio\" width=\"160\" height=\"120\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Ren-23Laisse-de-mer.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.504683","%_wpgmp_metabox_longitude%":"-2.737493","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_23","%_wp_page_template%":"default","%_thumbnail_id%":"11448","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":8764,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge De Rhuys","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 De Rhuys<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                4\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 id=\"contenu_article\"><h2>Coll\u00e8ge De Rhuys<\/h2>\n<p>Commune\u00a0: Sarzeau<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>25 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Suscinio\".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Ren-23_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_Ren-23_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul><\/div><\/div>","content":"4\u00e8me \u2022 2022-2023","location":{"lat":"47.52755086865526","lng":"-2.759606717422107","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-de-rhuys\/","zoom":7,"extra_fields":{"post_excerpt":"4\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge De Rhuys<\/h2>\n<p>Commune\u00a0: Sarzeau<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>25 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage Suscinio\".<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22_23_Ren-23_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_Ren-23_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge De Rhuys","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-de-rhuys\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.52755086865526","%_wpgmp_metabox_longitude%":"-2.759606717422107","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_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":8765,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge De La Rivi\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\">Coll\u00e8ge De La Rivi\u00e8re<\/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 De La Rivi\u00e8re\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Groupe-Etel-PAL-22-23-Ren-25-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge De La Rivi\u00e8re<\/h2>\n<p>Commune\u00a0: \u00c9tel<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>24 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pointe Pradic\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-25FM.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-Ren-25FS.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.65177721639122","lng":"-3.20137354254692","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-de-la-riviere\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge De La Rivi\u00e8re<\/h2>\n<p>Commune\u00a0: \u00c9tel<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>24 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pointe Pradic\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-25FM.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-Ren-25FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge De La Rivi\u00e8re","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-de-la-riviere\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge De La Rivi\u00e8re\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Groupe-Etel-PAL-22-23-Ren-25-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.65177721639122","%_wpgmp_metabox_longitude%":"-3.20137354254692","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_25#","%_wp_page_template%":"default","%_thumbnail_id%":"11450","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":8769,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de la Grandville","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 la Grandville<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Carantec \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\">Plage de la Grandville<\/h2>\n<p>Latitude : 48.5236099N | Longitude : 2.640950861W<br \/>Commune : Carantec<\/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-Ren-28FM.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-Ren-28FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Carantec \u2022 2022-2023","location":{"lat":"48.52360990683759","lng":"-2.6409508610969743","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-la-grandville\/","zoom":7,"extra_fields":{"post_excerpt":"Carantec \u2022 2022-2023","post_content":"<h2 class=\"site\">Plage de la Grandville<\/h2>\n<p>Latitude : 48.5236099N | Longitude : 2.640950861W<br \/>Commune : Carantec<\/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-Ren-28FM.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-Ren-28FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Plage de la Grandville","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-la-grandville\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.52360990683759","%_wpgmp_metabox_longitude%":"-2.6409508610969743","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_28","%_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":8774,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Jean Racine","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 Racine<\/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 id=\"contenu_article\"><h2>Coll\u00e8ge Jean Racine<\/h2>\n<p>Commune\u00a0: Saint-Brieuc<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>54 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de la Grandville\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-28FM.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-Ren-28FS.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":"48.51002427296404","lng":"-2.7500289480772127","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-racine\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Jean Racine<\/h2>\n<p>Commune\u00a0: Saint-Brieuc<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>54 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de la Grandville\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-28FM.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-Ren-28FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Jean Racine","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-racine\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.51002427296404","%_wpgmp_metabox_longitude%":"-2.7500289480772127","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_28#","%_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":8775,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage du four \u00e0 chaux","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 four \u00e0 chaux<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Paimpol \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\">Plage du four \u00e0 chaux<\/h2>\n<p>Latitude : 48.78308N | Longitude : 3.041013W<br \/>Commune : Paimpol<\/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-Ren-29FM.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-Ren-29FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Paimpol \u2022 2022-2023","location":{"lat":"48.78308","lng":"-3.041013","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-four-a-chaux\/","zoom":7,"extra_fields":{"post_excerpt":"Paimpol \u2022 2022-2023","post_content":"<h2 class=\"site\">Plage du four \u00e0 chaux<\/h2>\n<p>Latitude : 48.78308N | Longitude : 3.041013W<br \/>Commune : Paimpol<\/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-Ren-29FM.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-Ren-29FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Plage du four \u00e0 chaux","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-four-a-chaux\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.78308","%_wpgmp_metabox_longitude%":"-3.041013","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_29","%_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":8776,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Saint Joseph","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 Joseph<\/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 Saint Joseph<\/h2>\n<p>Commune\u00a0: Paimpol<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>12 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du four \u00e0 chaux\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-29FM.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-Ren-29FS.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":"48.78232999920936","lng":"-3.045786157851767","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-joseph-2\/","zoom":7,"extra_fields":{"post_excerpt":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Saint Joseph<\/h2>\n<p>Commune\u00a0: Paimpol<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>12 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du four \u00e0 chaux\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-29FM.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-Ren-29FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Saint Joseph","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-joseph-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.78232999920936","%_wpgmp_metabox_longitude%":"-3.045786157851767","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_29#","%_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":8777,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Portuais","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 Portuais<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Erquy \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=\"Plage de Portuais\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren33_1_photo_site-225x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de Portuais<\/h2>\n<p>Latitude : 48.64801N | Longitude : 2.461828W<br \/>Commune : Erquy<\/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-Ren-33FM.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-Ren-33FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Erquy \u2022 2022-2023-2024","location":{"lat":"48.648013346989345","lng":"-2.4618286371644436","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-portuais\/","zoom":7,"extra_fields":{"post_excerpt":"Erquy \u2022 2022-2023-2024","post_content":"<h2 class=\"site\">Plage de Portuais<\/h2>\n<p>Latitude : 48.64801N | Longitude : 2.461828W<br \/>Commune : Erquy<\/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-Ren-33FM.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-Ren-33FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Plage de Portuais","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-portuais\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de Portuais\" width=\"225\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren33_1_photo_site-225x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.648013346989345","%_wpgmp_metabox_longitude%":"-2.4618286371644436","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_33","%_wp_page_template%":"default","%_thumbnail_id%":"11460","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":8784,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Le Men\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\">Lyc\u00e9e Le Men\u00e9<\/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=\"Lyc\u00e9e Le Men\u00e9\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren33_photo_equipe-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Le Men\u00e9<\/h2>\n<p>Commune\u00a0: Merdrignac<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>50 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Portuais\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-33FM.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-Ren-33FS.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":"48.19011998691538","lng":"-2.4238113578728178","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-le-mene\/","zoom":7,"extra_fields":{"post_excerpt":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023","post_content":"<h2>Lyc\u00e9e Le Men\u00e9<\/h2>\n<p>Commune\u00a0: Merdrignac<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>50 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Portuais\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-33FM.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-Ren-33FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Lyc\u00e9e Le Men\u00e9","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-le-mene\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lyc\u00e9e Le Men\u00e9\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren33_photo_equipe-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.19011998691538","%_wpgmp_metabox_longitude%":"-2.4238113578728178","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_33#","%_wp_page_template%":"default","%_thumbnail_id%":"11461","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":8785,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"LGT JOLIOT-CURIE","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\">LGT JOLIOT-CURIE<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Lyc\u00e9e \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>LGT JOLIOT-CURIE<\/h2>\n<p>Commune\u00a0: RENNES<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de lyc\u00e9e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Portuais. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p><\/div><\/div>","content":"Lyc\u00e9e \u2022 2023-2024","location":{"lat":"48.12668204952406","lng":"-1.6516149473893162","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lgt-joliot-curie\/","zoom":7,"extra_fields":{"post_excerpt":"Lyc\u00e9e \u2022 2023-2024","post_content":"<h2>LGT JOLIOT-CURIE<\/h2>\n<p>Commune\u00a0: RENNES<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire 2023-2024<\/h3>\n<h4>30 \u00e9l\u00e8ves de lyc\u00e9e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site Plage de Portuais. Les donn\u00e9es seront mises en ligne en mai 2024.<\/p>","post_title":"LGT JOLIOT-CURIE","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lgt-joliot-curie\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_page_template%":"default","%_wpgmp_metabox_latitude%":"48.12668204952406","%_wpgmp_metabox_longitude%":"-1.6516149473893162","%_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:\"31\";}","%refpoint%":"PAL_23-24_Ren_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":12995,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage du Porzou","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 Porzou<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Concarneau \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=\"Plage du Porzou\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-34-1-photo-Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage du Porzou<\/h2>\n<p>Latitude : 47.864251N | Longitude : 3.906757W<br \/>Commune : Concarneau<\/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_Ren-34_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_Ren-34_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul><\/div><\/div>","content":"Concarneau \u2022 2022-2023","location":{"lat":"47.864251","lng":"-3.906757","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-porzou\/","zoom":7,"extra_fields":{"post_excerpt":"Concarneau \u2022 2022-2023","post_content":"<h2 class=\"site\">Plage du Porzou<\/h2>\n<p>Latitude : 47.864251N | Longitude : 3.906757W<br \/>Commune : Concarneau<\/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_Ren-34_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_Ren-34_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Plage du Porzou","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-porzou\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage du Porzou\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-34-1-photo-Site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.864251","%_wpgmp_metabox_longitude%":"-3.906757","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_34","%_wp_page_template%":"default","%_thumbnail_id%":"11443","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":8786,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage des Nou\u00eblles","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 des Nou\u00eblles<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Pl\u00e9rin \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\">Plage des Nou\u00eblles<\/h2>\n<p>Latitude : 48.545680\u00b0N | Longitude : 2.72063068\u00b0W<br \/>Commune : Pl\u00e9rin<\/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\/07\/PAL_21-22_Ren_13FM.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_Ren_13FS.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_Ren_13FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Pl\u00e9rin \u2022 2021-2022","location":{"lat":"48.545680","lng":"-2.7206306856100233","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-des-nouelles\/","zoom":7,"extra_fields":{"post_excerpt":"Pl\u00e9rin \u2022 2021-2022","post_content":"<h2 class=\"site\">Plage des Nou\u00eblles<\/h2>\n<p>Latitude : 48.545680\u00b0N | Longitude : 2.72063068\u00b0W<br \/>Commune : Pl\u00e9rin<\/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\/07\/PAL_21-22_Ren_13FM.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_Ren_13FS.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_Ren_13FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage des Nou\u00eblles","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-des-nouelles\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.545680","%_wpgmp_metabox_longitude%":"-2.7206306856100233","%_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:\"31\";}","%refpoint%":"PAL_21-22_Ren_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":5278,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Jean Mac\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 Jean Mac\u00e9<\/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 Jean Mac\u00e9<\/h2>\n<p>Commune\u00a0: Saint Brieuc<br>Acad\u00e9mie : Rennes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>44 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage des Nou\u00eblles\" de la commune de Pl\u00e9rin.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Ren_13FM.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_Ren_13FS.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_Ren_13FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2021-2022","location":{"lat":"48.515381518112775","lng":"-2.7912522108545827","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-mace\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Jean Mac\u00e9<\/h2>\n<p>Commune\u00a0: Saint Brieuc<br>Acad\u00e9mie : Rennes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>44 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage des Nou\u00eblles\" de la commune de Pl\u00e9rin.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Ren_13FM.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_Ren_13FS.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_Ren_13FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Jean Mac\u00e9","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-mace\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.515381518112775","%_wpgmp_metabox_longitude%":"-2.7912522108545827","%_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:\"31\";}","%refpoint%":"PAL_21-22_Ren_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":5279,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Damgan","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 Damgan<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Damgan \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 class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de Damgan\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-14site-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de Damgan<\/h2>\n<p>Latitude : 47.517235\u00b0N | Longitude : 2.582319\u00b0W<br \/>Commune : Damgan<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<p>Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/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_Ren14_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_Ren14_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_Ren14_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Damgan \u2022 2021-2022-2023","location":{"lat":"47.517235","lng":"-2.582319","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-damgan\/","zoom":7,"extra_fields":{"post_excerpt":"Damgan \u2022 2021-2022-2023","post_content":"<h2 class=\"site\">Plage de Damgan<\/h2>\n<p>Latitude : 47.517235\u00b0N | Longitude : 2.582319\u00b0W<br \/>Commune : Damgan<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<p>Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/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_Ren14_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_Ren14_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_Ren14_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage de Damgan","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-damgan\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de Damgan\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-14site-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.517235","%_wpgmp_metabox_longitude%":"-2.582319","%_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:\"31\";}","%refpoint%":"PAL_21-22_Ren_14","%_wp_page_template%":"default","%_thumbnail_id%":"11439","taxonomy=type-site-classe":"Sites","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-site-2.png"},"id":5280,"custom_filters":{"%type-site-classe%":["Sites"],"%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-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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Jean Rostand","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 Rostand<\/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 class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Jean Rostand\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-14-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Jean Rostand<\/h2>\n<p>Commune\u00a0: Muzillac<br>Acad\u00e9mie : Rennes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>28 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Damgan\" de la commune de Damgan. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Ren14_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_Ren14_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_Ren14_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2021-2022","location":{"lat":"47.56648908243993","lng":"-2.505888260009727","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-rostand\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Jean Rostand<\/h2>\n<p>Commune\u00a0: Muzillac<br>Acad\u00e9mie : Rennes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>28 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Damgan\" de la commune de Damgan. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Ren14_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_Ren14_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_Ren14_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Jean Rostand","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-jean-rostand\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Jean Rostand\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-14-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.56648908243993","%_wpgmp_metabox_longitude%":"-2.505888260009727","%_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:\"31\";}","%refpoint%":"PAL_21-22_Ren_14#","%_wp_page_template%":"default","%_thumbnail_id%":"11465","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":5281,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lycee Marcellin Berthelot","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 Marcellin Berthelot<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde \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>Lycee Marcellin Berthelot<\/h2>\n<p>Commune\u00a0: Questembert<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>180 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Montrichard\". Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p><\/div><\/div>","content":"2nde \u2022 2022-2023","location":{"lat":"47.66385437198397","lng":"-2.465163617417336","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-marcellin-berthelot\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2022-2023","post_content":"<h2>Lycee Marcellin Berthelot<\/h2>\n<p>Commune\u00a0: Questembert<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>180 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Montrichard\". Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p>","post_title":"Lycee Marcellin Berthelot","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-marcellin-berthelot\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.66385437198397","%_wpgmp_metabox_longitude%":"-2.465163617417336","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_14#","%_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":8759,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Rives du Goyen","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\">Rives du Goyen<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Pont Croix \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\">Rives du Goyen<\/h2>\n<p>Latitude : 48.03815745239\u00b0N | Longitude : 4.5072530045\u00b0W<br \/>Commune : Pont Croix<\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL_21-22_Ren_15FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" \n<\/ul><\/div><\/div>","content":"Pont Croix \u2022 2021-2022","location":{"lat":"48.03815745239","lng":"-4.507253004505903","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/rives-du-goyen\/","zoom":7,"extra_fields":{"post_excerpt":"Pont Croix \u2022 2021-2022","post_content":"<h2 class=\"site\">Rives du Goyen<\/h2>\n<p>Latitude : 48.03815745239\u00b0N | Longitude : 4.5072530045\u00b0W<br \/>Commune : Pont Croix<\/p>\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL_21-22_Ren_15FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<li><a rel=\"noreferrer noopener\" \n<\/ul>","post_title":"Rives du Goyen","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/rives-du-goyen\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.03815745239","%_wpgmp_metabox_longitude%":"-4.507253004505903","%_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:\"31\";}","%refpoint%":"PAL_21-22_Ren_15","%_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":10770,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge La Mennais Cap Sizun","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 La Mennais Cap Sizun<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3\u00e8me et 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 La Mennais Cap Sizun<\/h2>\n<p>Commune\u00a0: Pont-Croix<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>84 \u00e9l\u00e8ves de 4\u00e8me et 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Rives du Goyen\".\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL_21-22_Ren_15FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"3\u00e8me et 4\u00e8me \u2022 2021-2022","location":{"lat":"48.042330813178026","lng":"-4.49342012502705","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-la-mennais-cap-sizun\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me et 4\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge La Mennais Cap Sizun<\/h2>\n<p>Commune\u00a0: Pont-Croix<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>84 \u00e9l\u00e8ves de 4\u00e8me et 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Rives du Goyen\".\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL_21-22_Ren_15FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge La Mennais Cap Sizun","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-la-mennais-cap-sizun\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.042330813178026","%_wpgmp_metabox_longitude%":"-4.49342012502705","%_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:\"31\";}","%refpoint%":"PAL_21-22_Ren_15#","%_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":10771,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage du St\u00ear","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 St\u00ear<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Guilvinec \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\">Plage du St\u00ear<\/h2>\n<p>Latitude : 47.79945691\u00b0N | Longitude : 4.297173199\u00b0W<br \/>Commune : Guilvinec<\/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\/2023\/05\/PAL_21-22_Ren_16FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Guilvinec \u2022 2021-2022","location":{"lat":"47.79945691850917","lng":"-4.297173199503607","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-ster\/","zoom":7,"extra_fields":{"post_excerpt":"Guilvinec \u2022 2021-2022","post_content":"<h2 class=\"site\">Plage du St\u00ear<\/h2>\n<p>Latitude : 47.79945691\u00b0N | Longitude : 4.297173199\u00b0W<br \/>Commune : Guilvinec<\/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\/2023\/05\/PAL_21-22_Ren_16FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Plage du St\u00ear","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-ster\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.79945691850917","%_wpgmp_metabox_longitude%":"-4.297173199503607","%_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:\"31\";}","%refpoint%":"PAL_21-22_Ren_16","%_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":10772,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Saint-Joseph","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-Joseph<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3\u00e8me et 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 Saint-Joseph<\/h2>\n<p>Commune\u00a0: Guilvinec<br>Acad\u00e9mie : Rennes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>48 \u00e9l\u00e8ves de 4\u00e8me et 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Porsmeur\".\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL_21-22_Ren_16FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul><\/div><\/div>","content":"3\u00e8me et 4\u00e8me \u2022 2021-2022","location":{"lat":"47.801091626116865","lng":"-4.287207171202523","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-joseph-3\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me et 4\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Saint-Joseph<\/h2>\n<p>Commune\u00a0: Guilvinec<br>Acad\u00e9mie : Rennes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>48 \u00e9l\u00e8ves de 4\u00e8me et 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Porsmeur\".\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL_21-22_Ren_16FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Saint-Joseph","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-saint-joseph-3\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_old_slug%":"college-saint-joseph-4","%_wpgmp_metabox_latitude%":"47.801091626116865","%_wpgmp_metabox_longitude%":"-4.287207171202523","%_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:\"31\";}","%refpoint%":"PAL_21-22_Ren_16#","%_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":10773,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Porsmeur","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 Porsmeur<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Plouescat \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\">Plage de Porsmeur<\/h2>\n<p>Latitude : 48.659935\u00b0N | Longitude : 4.219426\u00b0W<br \/>Commune : Plouescat<\/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_Ren_17FM.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_Ren_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_Ren_17FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Plouescat \u2022 2021-2022","location":{"lat":"48.659935","lng":"-4.219426","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-porsmeur\/","zoom":7,"extra_fields":{"post_excerpt":"Plouescat \u2022 2021-2022","post_content":"<h2 class=\"site\">Plage de Porsmeur<\/h2>\n<p>Latitude : 48.659935\u00b0N | Longitude : 4.219426\u00b0W<br \/>Commune : Plouescat<\/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_Ren_17FM.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_Ren_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_Ren_17FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage de Porsmeur","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-porsmeur\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.659935","%_wpgmp_metabox_longitude%":"-4.219426","%_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:\"31\";}","%refpoint%":"PAL_21-22_Ren_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":5286,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Baie du Kernic","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 Baie du Kernic<\/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 Baie du Kernic<\/h2>\n<p>Commune\u00a0: Plouescat<br>Acad\u00e9mie : Rennes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Porsmeur\" de la commune de Plouescat. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Ren_17FM.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_Ren_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_Ren_17FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"4\u00e8me \u2022 2021-2022","location":{"lat":"48.65424259985578","lng":"-4.173939349682304","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-baie-du-kernic\/","zoom":7,"extra_fields":{"post_excerpt":"4\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Baie du Kernic<\/h2>\n<p>Commune\u00a0: Plouescat<br>Acad\u00e9mie : Rennes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>25 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Porsmeur\" de la commune de Plouescat. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Ren_17FM.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_Ren_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_Ren_17FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Baie du Kernic","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-baie-du-kernic\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.65424259985578","%_wpgmp_metabox_longitude%":"-4.173939349682304","%_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:\"31\";}","%refpoint%":"PAL_21-22_Ren_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":5287,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Le Verger","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 Verger<\/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 Le Verger<\/h2>\n<p>Commune\u00a0: Auray<br>Acad\u00e9mie : Rennes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>106 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Locmariaquer\" de la commune de Locmariaquer.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Ren_18FM.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_Ren_18Fs.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_Ren_18FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"4\u00e8me \u2022 2021-2022","location":{"lat":"47.66322871346033","lng":"-2.9858746380807313","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-le-verger\/","zoom":7,"extra_fields":{"post_excerpt":"4\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge Le Verger<\/h2>\n<p>Commune\u00a0: Auray<br>Acad\u00e9mie : Rennes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>106 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Locmariaquer\" de la commune de Locmariaquer.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Ren_18FM.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_Ren_18Fs.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_Ren_18FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Le Verger","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-le-verger\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.66322871346033","%_wpgmp_metabox_longitude%":"-2.9858746380807313","%_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:\"31\";}","%refpoint%":"PAL_21-22_Ren_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":5289,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Pointes des \u00e9migr\u00e9s","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\">Pointes des \u00e9migr\u00e9s<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Penmarch \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\">Pointes des \u00e9migr\u00e9s<\/h2>\n<p>Latitude : 47.631330\u00b0N | Longitude : 2.765121\u00b0W<br \/>Commune : Vannes<\/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_Ren_19_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_Ren_19_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_Ren_19_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Penmarch \u2022 2021-2022","location":{"lat":"47.631330","lng":"-2.765121","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pointes-des-emigres\/","zoom":7,"extra_fields":{"post_excerpt":"Penmarch \u2022 2021-2022","post_content":"<h2 class=\"site\">Pointes des \u00e9migr\u00e9s<\/h2>\n<p>Latitude : 47.631330\u00b0N | Longitude : 2.765121\u00b0W<br \/>Commune : Vannes<\/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_Ren_19_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_Ren_19_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_Ren_19_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Pointes des \u00e9migr\u00e9s","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/pointes-des-emigres\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.631330","%_wpgmp_metabox_longitude%":"-2.765121","%_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:\"31\";}","%refpoint%":"PAL_21-22_Ren_19","%_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":5290,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge St 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 St Exup\u00e9ry<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                4\u00e8me et 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 St Exup\u00e9ry<\/h2>\n<p>Commune\u00a0: Vannes<br>Acad\u00e9mie : Rennes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>48 \u00e9l\u00e8ves de 4\u00e8me et 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pointes des \u00e9migr\u00e9s\" de la commune de Vannes. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Ren_19_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_Ren_19_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_Ren_19_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"4\u00e8me et 3\u00e8me \u2022 2021-2022","location":{"lat":"47.67560311931141","lng":"-2.7700580657934015","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-st-exupery\/","zoom":7,"extra_fields":{"post_excerpt":"4\u00e8me et 3\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge St Exup\u00e9ry<\/h2>\n<p>Commune\u00a0: Vannes<br>Acad\u00e9mie : Rennes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>48 \u00e9l\u00e8ves de 4\u00e8me et 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Pointes des \u00e9migr\u00e9s\" de la commune de Vannes. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Ren_19_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_Ren_19_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_Ren_19_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge St Exup\u00e9ry","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-st-exupery\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.67560311931141","%_wpgmp_metabox_longitude%":"-2.7700580657934015","%_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:\"31\";}","%refpoint%":"PAL_21-22_Ren_19#","%_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":5291,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Saint-Jean du doigt","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 Saint-Jean du doigt<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Saint-Jean du doigt \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=\"Plage de Saint-Jean du doigt\" width=\"169\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Ren-21-site-169x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de Saint-Jean du doigt<\/h2>\n<p>Latitude : 48.7026721123N | Longitude : 3.77765472W<br \/>Commune : Saint-Jean du doigt<\/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-Ren-21FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul><\/div><\/div>","content":"Saint-Jean du doigt \u2022 2022-2023","location":{"lat":"48.702672112328855","lng":"-3.777654726357733","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-saint-jean-du-doigt\/","zoom":7,"extra_fields":{"post_excerpt":"Saint-Jean du doigt \u2022 2022-2023","post_content":"<h2 class=\"site\">Plage de Saint-Jean du doigt<\/h2>\n<p>Latitude : 48.7026721123N | Longitude : 3.77765472W<br \/>Commune : Saint-Jean du doigt<\/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-Ren-21FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>","post_title":"Plage de Saint-Jean du doigt","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-saint-jean-du-doigt\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de Saint-Jean du doigt\" width=\"169\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/Ren-21-site-169x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.702672112328855","%_wpgmp_metabox_longitude%":"-3.777654726357733","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_21","%_wp_page_template%":"default","%_thumbnail_id%":"11446","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":8760,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Fran\u00e7ois Charles","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 Fran\u00e7ois Charles<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                3\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 id=\"contenu_article\"><h2>Coll\u00e8ge Fran\u00e7ois Charles<\/h2>\n<p>Commune\u00a0: Plougasnou<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>25 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Saint-Jean du doigt\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-21FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul><\/div><\/div>","content":"3\u00e8me \u2022 2022-2023","location":{"lat":"48.69475033336432","lng":"-3.793585365785607","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-francois-charles\/","zoom":7,"extra_fields":{"post_excerpt":"3\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Fran\u00e7ois Charles<\/h2>\n<p>Commune\u00a0: Plougasnou<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>25 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Saint-Jean du doigt\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-21FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Fran\u00e7ois Charles","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-francois-charles\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.69475033336432","%_wpgmp_metabox_longitude%":"-3.793585365785607","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_21#","%_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":8761,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Naval","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 Naval<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Lyc\u00e9e \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 id=\"contenu_article\"><h2>Lyc\u00e9e Naval<\/h2>\n<p>Commune\u00a0: Brest<br \/>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>21 \u00e9l\u00e8ves de 1\u00e8re<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Porsmoguer\" de la commune de Plouarzel.<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>21 \u00e9l\u00e8ves de 1\u00e8re<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Porsmoguer\" de la commune de Plouarzel.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-1FM.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-Ren-1FS.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>30 \u00e9l\u00e8ves de 1\u00e8re<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Porsmoguer\" de la commune de Plouarzel.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Ren_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_Ren_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_Ren_1_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>16 \u00e9l\u00e8ves de lyc\u00e9e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Porsmoguer\" de la commune de Plouarzel.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Ren_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_Ren_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_Ren_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>16 \u00e9l\u00e8ves de lyc\u00e9e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Porsmoguer\" de la commune de Plouarzel.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Ren_10_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_Ren_10_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_Ren_10_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Lyc\u00e9e \u2022 2019-2024","location":{"lat":"48.36924400118457","lng":"-4.525272872857031","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-naval\/","zoom":7,"extra_fields":{"post_excerpt":"Lyc\u00e9e \u2022 2019-2024","post_content":"<h2>Lyc\u00e9e Naval<\/h2>\n<p>Commune\u00a0: Brest<br \/>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2023-2024<\/h3>\n<h4>21 \u00e9l\u00e8ves de 1\u00e8re<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Porsmoguer\" de la commune de Plouarzel.<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>21 \u00e9l\u00e8ves de 1\u00e8re<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Porsmoguer\" de la commune de Plouarzel.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-1FM.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-Ren-1FS.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>30 \u00e9l\u00e8ves de 1\u00e8re<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Porsmoguer\" de la commune de Plouarzel.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Ren_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_Ren_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_Ren_1_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>16 \u00e9l\u00e8ves de lyc\u00e9e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Porsmoguer\" de la commune de Plouarzel.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Ren_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_Ren_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_Ren_1FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>16 \u00e9l\u00e8ves de lyc\u00e9e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Porsmoguer\" de la commune de Plouarzel.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Ren_10_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_Ren_10_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_Ren_10_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Naval","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-naval\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.36924400118457","%_wpgmp_metabox_longitude%":"-4.525272872857031","%_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:\"31\";}","%refpoint%":"PAL_19-20_Ren_1#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","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-classe.png"},"id":4284,"custom_filters":{"%type-site-classe%":["Classes"],"%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-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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Chemin de Poulguinan","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\">Chemin de Poulguinan<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Quimper \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=\"Chemin de Poulguinan\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Ren_2-Photo_Site2-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Chemin de Poulguinan<\/h2>\n<p>Latitude : 47.9827047\u00b0N | Longitude : 4.11501869\u00b0W<br \/>Commune : Quimper\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<p>Les r\u00e9sultats seront mis en ligne avant avril 2022<\/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_Ren_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_Ren_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_Ren_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Quimper \u2022 2020-2021-2022","location":{"lat":"47.98270470165616","lng":"-4.115018697568853","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/chemin-de-poulguinan\/","zoom":7,"extra_fields":{"post_excerpt":"Quimper \u2022 2020-2021-2022","post_content":"<h2 class=\"site\">Chemin de Poulguinan<\/h2>\n<p>Latitude : 47.9827047\u00b0N | Longitude : 4.11501869\u00b0W<br \/>Commune : Quimper\/p>\n\n<h3>Ann\u00e9e 2021-2022<\/h3>\n<p>Les r\u00e9sultats seront mis en ligne avant avril 2022<\/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_Ren_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_Ren_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_Ren_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Chemin de Poulguinan","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/chemin-de-poulguinan\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chemin de Poulguinan\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Ren_2-Photo_Site2-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.98270470165616","%_wpgmp_metabox_longitude%":"-4.115018697568853","%_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:\"31\";}","%refpoint%":"PAL_20-21_Ren_2","%_wp_page_template%":"default","%_thumbnail_id%":"4272","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":4287,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Kerguelen","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\">Kerguelen<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Larmor-Plage \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=\"Kerguelen\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-3-Photo-PollutionSite-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Kerguelen<\/h2>\n<p>Latitude : 47.70188\u00b0N | Longitude : 3.39688\u00b0W<br \/>Commune : Larmor-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-Ren-3FM.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-Ren-3FS.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_Ren_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\/2022\/07\/PAL_21-22_Ren_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\/2022\/07\/PAL_21-22_Ren_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\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_Ren_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_Ren_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_Ren_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Larmor-Plage \u2022 2020-2021-2022-2023","location":{"lat":"47.70188","lng":"-3.39688","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/kerguelen\/","zoom":7,"extra_fields":{"post_excerpt":"Larmor-Plage \u2022 2020-2021-2022-2023","post_content":"<h2 class=\"site\">Kerguelen<\/h2>\n<p>Latitude : 47.70188\u00b0N | Longitude : 3.39688\u00b0W<br \/>Commune : Larmor-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-Ren-3FM.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-Ren-3FS.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_Ren_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\/2022\/07\/PAL_21-22_Ren_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\/2022\/07\/PAL_21-22_Ren_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\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_Ren_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_Ren_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_Ren_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Kerguelen","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/kerguelen\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Kerguelen\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-3-Photo-PollutionSite-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.70188","%_wpgmp_metabox_longitude%":"-3.39688","%_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:\"31\";}","%refpoint%":"PAL_20-21_Ren_3","%_wp_page_template%":"default","%_thumbnail_id%":"11462","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":4288,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Kerentrech","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 Kerentrech<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\u00e8me \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=\"Coll\u00e8ge Kerentrech\" width=\"300\" height=\"224\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Ren_3-photoclasse-300x224.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Kerentrech<\/h2>\n<p>Commune : Lorient<br \/>Acad\u00e9mie : Rennes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>20 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Kerguelen\" de la commune de Larmor-Plage.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Ren_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\/2022\/07\/PAL_21-22_Ren_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\/2022\/07\/PAL_21-22_Ren_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>60 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Kerguelen\" de la commune de Larmor-Plage.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Ren_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_Ren_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_Ren_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2020-2021-2022","location":{"lat":"47.75889382903697","lng":"-3.367579872873063","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-kerentrech\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2020-2021-2022","post_content":"<h2>Coll\u00e8ge Kerentrech<\/h2>\n<p>Commune : Lorient<br \/>Acad\u00e9mie : Rennes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>20 \u00e9l\u00e8ves de 3\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Kerguelen\" de la commune de Larmor-Plage.\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/07\/PAL_21-22_Ren_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\/2022\/07\/PAL_21-22_Ren_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\/2022\/07\/PAL_21-22_Ren_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n\n\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>60 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Kerguelen\" de la commune de Larmor-Plage.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Ren_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_Ren_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_Ren_3FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Kerentrech","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-kerentrech\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Kerentrech\" width=\"300\" height=\"224\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Ren_3-photoclasse-300x224.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.75889382903697","%_wpgmp_metabox_longitude%":"-3.367579872873063","%_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:\"31\";}","%refpoint%":"PAL_20-21_Ren_3#","%_wp_page_template%":"default","%_thumbnail_id%":"4273","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":4289,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage du Nohic","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 Nohic<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Port-Louis \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=\"Plage du Nohic\" width=\"300\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-3-Photo-Site-Delimite-300x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage du Nohic<\/h2>\n<p>Latitude : 47.703785\u00b0N | Longitude : 3.355542\u00b0W<br \/>Commune : Port-Louis\/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-Ren-6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/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_Ren_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_Ren_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_Ren_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Port-Louis \u2022 2020-2021","location":{"lat":"47.703785","lng":"-3.355542","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-nohic\/","zoom":7,"extra_fields":{"post_excerpt":"Port-Louis \u2022 2020-2021","post_content":"<h2 class=\"site\">Plage du Nohic<\/h2>\n<p>Latitude : 47.703785\u00b0N | Longitude : 3.355542\u00b0W<br \/>Commune : Port-Louis\/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-Ren-6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/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_Ren_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_Ren_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_Ren_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage du Nohic","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-nohic\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage du Nohic\" width=\"300\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL-22-23-Ren-3-Photo-Site-Delimite-300x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.703785","%_wpgmp_metabox_longitude%":"-3.355542","%_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:\"31\";}","%refpoint%":"PAL_20-21_Ren_6","%_wp_page_template%":"default","%_thumbnail_id%":"11463","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2020-2021, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4290,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2020-2021","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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Berge de la La\u00efta (embouchure)","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 La\u00efta (embouchure)<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Larmor-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 id=\"contenu_article\"><h2 class=\"site\">Berge de la La\u00efta (embouchure)<\/h2>\n<p>Latitude : 47.774647N | Longitude : 3.530678W<br \/>Commune : Larmor-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-Ren-35FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul><\/div><\/div>","content":"Larmor-Plage. \u2022 2022-2023","location":{"lat":"47.774647","lng":"-3.530678","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-la-laita-embouchure\/","zoom":7,"extra_fields":{"post_excerpt":"Larmor-Plage. \u2022 2022-2023","post_content":"<h2 class=\"site\">Berge de la La\u00efta (embouchure)<\/h2>\n<p>Latitude : 47.774647N | Longitude : 3.530678W<br \/>Commune : Larmor-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-Ren-35FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>","post_title":"Berge de la La\u00efta (embouchure)","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/berge-de-la-laita-embouchure\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.774647","%_wpgmp_metabox_longitude%":"-3.530678","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_35","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":8745,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Guidel","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 Guidel<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Larmor-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 id=\"contenu_article\"><h2 class=\"site\">Plage de Guidel<\/h2>\n<p>Latitude : 47.76677 N | Longitude : 3.529943W<br \/>Commune : Larmor-Plage.<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<p>Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p><\/div><\/div>","content":"Larmor-Plage. \u2022 2022-2023","location":{"lat":"47.76677","lng":"-3.529943","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-guidel\/","zoom":7,"extra_fields":{"post_excerpt":"Larmor-Plage. \u2022 2022-2023","post_content":"<h2 class=\"site\">Plage de Guidel<\/h2>\n<p>Latitude : 47.76677 N | Longitude : 3.529943W<br \/>Commune : Larmor-Plage.<\/p>\n<h3>Ann\u00e9e 2022-2023<\/h3>\n<p>Les donn\u00e9es seront mises en ligne avant fin juin 2023.<\/p>","post_title":"Plage de Guidel","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-guidel\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.76677","%_wpgmp_metabox_longitude%":"-3.529943","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_36","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"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":8746,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Henri Wallon","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 Wallon<\/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 id=\"contenu_article\"><h2>Coll\u00e8ge Henri Wallon<\/h2>\n<p>Commune\u00a0: Lanester<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>100 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Kerguelen\", \"Plage du Nohic\", \"Berge de la La\u00efta (embouchure)\" et \"Plage de Guidel\" de la commune de Larmor-Plage.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-3FM.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-Ren-3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-35FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-39FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2022-2023","location":{"lat":"47.77197057137215","lng":"-3.3444644904308283","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-henri-wallon-2\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Henri Wallon<\/h2>\n<p>Commune\u00a0: Lanester<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>100 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Kerguelen\", \"Plage du Nohic\", \"Berge de la La\u00efta (embouchure)\" et \"Plage de Guidel\" de la commune de Larmor-Plage.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-3FM.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-Ren-3FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-35FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-39FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Henri Wallon","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-henri-wallon-2\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.77197057137215","%_wpgmp_metabox_longitude%":"-3.3444644904308283","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_3#","%_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":8747,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e professionnel Julien Crozet","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 Julien Crozet<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                2nde \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 professionnel Julien Crozet<\/h2>\n\n<p>Commune : Port-Louis<br \/>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>29 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur les sites \"Plage du Nohic\" et \"Crique du Nohic\" de la commune de Port-Louis.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Ren_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_Ren_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_Ren_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"2nde \u2022 2020-2021","location":{"lat":"47.70624425410415","lng":"-3.357428315203063","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-professionnel-julien-crozet\/","zoom":7,"extra_fields":{"post_excerpt":"2nde \u2022 2020-2021","post_content":"<h2>Lyc\u00e9e professionnel Julien Crozet<\/h2>\n\n<p>Commune : Port-Louis<br \/>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>29 \u00e9l\u00e8ves de 2nde<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur les sites \"Plage du Nohic\" et \"Crique du Nohic\" de la commune de Port-Louis.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren-6FM.pdf\" target=\"_blank\">Fiche bilan sur les macrod\u00e9chets<\/a><\/li><\/ul>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Ren_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_Ren_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_Ren_6FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e professionnel Julien Crozet","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-professionnel-julien-crozet\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.70624425410415","%_wpgmp_metabox_longitude%":"-3.357428315203063","%_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:\"31\";}","%refpoint%":"PAL_20-21_Ren_6#","%_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":4291,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Le Bocage","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 Bocage<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                5\u00e8me \u2022 2019-2020\/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 Le Bocage<\/h2>\n<p>Commune\u00a0: Dinard<br \/>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>29 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Prieur\u00e9\" de la commune de Dinard.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Ren_8_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_Ren_8_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_Ren_8_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"5\u00e8me \u2022 2019-2020\/2022-2023","location":{"lat":"48.62315810027627","lng":"-2.064305101685985","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-le-bocage\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2019-2020\/2022-2023","post_content":"<h2>Coll\u00e8ge Le Bocage<\/h2>\n<p>Commune\u00a0: Dinard<br \/>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>29 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage du Prieur\u00e9\" de la commune de Dinard.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Ren_8_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_Ren_8_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_Ren_8_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge Le Bocage","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-le-bocage\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.62315810027627","%_wpgmp_metabox_longitude%":"-2.064305101685985","%_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:\"31\";}","%refpoint%":"PAL_19-20_Ren_8#","%_wp_page_template%":"default","taxonomy=type-site-classe":"Classes","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2019-2020, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-classe.png"},"id":4280,"custom_filters":{"%type-site-classe%":["Classes"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2019-2020","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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Kervel","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 Kervel<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Plon\u00e9vez-Porzay \u2022 2019-2020\/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=\"Plage de Kervel\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren9-1_Photo-site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de Kervel<\/h2>\n<p>Latitude : 48.11605\u00b0N | Longitude : 4.281361\u00b0W<br \/>Commune : Plon\u00e9vez-Porzay<\/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_Ren-9_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_Ren-9_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/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_Ren_9_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_Ren_9_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_Ren_9_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Plon\u00e9vez-Porzay \u2022 2019-2020\/2022-2023","location":{"lat":"48.11605","lng":"-4.281361","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-kervel\/","zoom":7,"extra_fields":{"post_excerpt":"Plon\u00e9vez-Porzay \u2022 2019-2020\/2022-2023","post_content":"<h2 class=\"site\">Plage de Kervel<\/h2>\n<p>Latitude : 48.11605\u00b0N | Longitude : 4.281361\u00b0W<br \/>Commune : Plon\u00e9vez-Porzay<\/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_Ren-9_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_Ren-9_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/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_Ren_9_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_Ren_9_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_Ren_9_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage de Kervel","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-kervel\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de Kervel\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren9-1_Photo-site-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.11605","%_wpgmp_metabox_longitude%":"-4.281361","%_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:\"31\";}","%refpoint%":"PAL_19-20_Ren_9","%_wp_page_template%":"default","%_thumbnail_id%":"11456","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2019-2020, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":4281,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2019-2020","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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Lyc\u00e9e Sainte Th\u00e9r\u00e8se","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 Th\u00e9r\u00e8se<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Lyc\u00e9e \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=\"Lyc\u00e9e Sainte Th\u00e9r\u00e8se\" width=\"196\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Ren_9_photo_classe.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Lyc\u00e9e Sainte Th\u00e9r\u00e8se<\/h2>\n<p>Commune\u00a0: Quimper<br \/>Acad\u00e9mie : Rennes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>53 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Chemin de Poulguinan\" de la commune de Quimper. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Ren_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\/2022\/06\/PAL_21-22_Ren_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\/2022\/06\/PAL_21-22_Ren_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de lyc\u00e9e<\/h4>\n<p>L'\u00e9tude porte sur le site \"Chemin de Poulguinan\" de la commune de Quimper.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Ren_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_Ren_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_Ren_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>30 \u00e9l\u00e8ves de lyc\u00e9e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Kervel\" de la commune de Plon\u00e9vez-Porzay.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Ren_9_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_Ren_9_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_Ren_9_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Lyc\u00e9e \u2022 2019-2020-2021-2022","location":{"lat":"47.98148294761469","lng":"-4.09617194403154","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-sainte-therese\/","zoom":7,"extra_fields":{"post_excerpt":"Lyc\u00e9e \u2022 2019-2020-2021-2022","post_content":"<h2>Lyc\u00e9e Sainte Th\u00e9r\u00e8se<\/h2>\n<p>Commune\u00a0: Quimper<br \/>Acad\u00e9mie : Rennes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>53 \u00e9l\u00e8ves de 4\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Chemin de Poulguinan\" de la commune de Quimper. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Ren_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\/2022\/06\/PAL_21-22_Ren_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\/2022\/06\/PAL_21-22_Ren_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2020-2021<\/h3>\n<h4>30 \u00e9l\u00e8ves de lyc\u00e9e<\/h4>\n<p>L'\u00e9tude porte sur le site \"Chemin de Poulguinan\" de la commune de Quimper.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2021\/06\/PAL_20-21_Ren_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_Ren_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_Ren_2FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>\n<h3>Ann\u00e9e scolaire : 2019-2020<\/h3>\n<h4>30 \u00e9l\u00e8ves de lyc\u00e9e<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Kervel\" de la commune de Plon\u00e9vez-Porzay.<\/p>\n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Ren_9_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_Ren_9_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_Ren_9_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Lyc\u00e9e Sainte Th\u00e9r\u00e8se","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/lycee-sainte-therese\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lyc\u00e9e Sainte Th\u00e9r\u00e8se\" width=\"196\" height=\"300\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2020\/12\/PAL_19-20_Ren_9_photo_classe.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.98148294761469","%_wpgmp_metabox_longitude%":"-4.09617194403154","%_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:\"31\";}","%refpoint%":"PAL_19-20_Ren_9#","%_wp_page_template%":"default","%_thumbnail_id%":"1721","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":4282,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge Auguste Brizeux","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 Auguste Brizeux<\/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 Auguste Brizeux\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren9-5_Photo_VracMacro-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge Auguste Brizeux<\/h2>\n<p>Commune\u00a0: Quimper<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>25 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Kervel\" de la commune de Plon\u00e9vez-Porzay.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL_22_23_Ren-9_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_Ren-9_FS.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.992471960591985","lng":"-4.112885259733349","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-auguste-brizeux\/","zoom":7,"extra_fields":{"post_excerpt":"Eco-d\u00e9l\u00e9gu\u00e9s \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge Auguste Brizeux<\/h2>\n<p>Commune\u00a0: Quimper<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>25 Eco-d\u00e9l\u00e9gu\u00e9s<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Kervel\" de la commune de Plon\u00e9vez-Porzay.<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL_22_23_Ren-9_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_Ren-9_FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge Auguste Brizeux","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-auguste-brizeux\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge Auguste Brizeux\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren9-5_Photo_VracMacro-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"47.992471960591985","%_wpgmp_metabox_longitude%":"-4.112885259733349","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_9#","%_wp_page_template%":"default","%_thumbnail_id%":"11457","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":8753,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Saint-Laurent","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 Saint-Laurent<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Pl\u00e9rin \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 class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de Saint-Laurent\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren-10-3_Photo_PollutionSite-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de Saint-Laurent<\/h2>\n<p>Latitude : 48.54516\u00b0N | Longitude : 2.723846239\u00b0W<br \/>Commune : Pl\u00e9rin<\/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-Ren10FM.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-Ren10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/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_Ren_10FM.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_Ren_10FS.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_Ren_10FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Pl\u00e9rin \u2022 2021-2022-2023","location":{"lat":"48.54516438703649","lng":"-2.7238462399200514","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-saint-laurent\/","zoom":7,"extra_fields":{"post_excerpt":"Pl\u00e9rin \u2022 2021-2022-2023","post_content":"<h2 class=\"site\">Plage de Saint-Laurent<\/h2>\n<p>Latitude : 48.54516\u00b0N | Longitude : 2.723846239\u00b0W<br \/>Commune : Pl\u00e9rin<\/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-Ren10FM.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-Ren10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/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_Ren_10FM.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_Ren_10FS.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_Ren_10FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage de Saint-Laurent","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-saint-laurent\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de Saint-Laurent\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren-10-3_Photo_PollutionSite-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.54516438703649","%_wpgmp_metabox_longitude%":"-2.7238462399200514","%_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:\"31\";}","%refpoint%":"PAL_21-22_Ren_10","%_wp_page_template%":"default","%_thumbnail_id%":"11458","taxonomy=type-site-classe":"Sites","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-site-2.png"},"id":5274,"custom_filters":{"%type-site-classe%":["Sites"],"%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-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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge L\u00e9onard de Vinci","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 L\u00e9onard de Vinci<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                6\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 L\u00e9onard de Vinci<\/h2>\n<p>Commune\u00a0: Saint Brieuc<br>Acad\u00e9mie : Rennes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>150 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Saint-Laurent\" de la commune de Pl\u00e9rin. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Ren_10FM.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_Ren_10FS.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_Ren_10FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"6\u00e8me \u2022 2021-2022","location":{"lat":"48.49697909149609","lng":"-2.7507632404331646","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-leonard-de-vinci\/","zoom":7,"extra_fields":{"post_excerpt":"6\u00e8me \u2022 2021-2022","post_content":"<h2>Coll\u00e8ge L\u00e9onard de Vinci<\/h2>\n<p>Commune\u00a0: Saint Brieuc<br>Acad\u00e9mie : Rennes<\/p>\n\n<h3>Ann\u00e9e scolaire : 2021-2022<\/h3>\n<h4>150 \u00e9l\u00e8ves de 6\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Saint-Laurent\" de la commune de Pl\u00e9rin. \n<ul>\n<li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2022\/06\/PAL_21-22_Ren_10FM.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_Ren_10FS.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_Ren_10FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Coll\u00e8ge L\u00e9onard de Vinci","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-leonard-de-vinci\/","post_featured_image":"","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.49697909149609","%_wpgmp_metabox_longitude%":"-2.7507632404331646","%_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:\"31\";}","%refpoint%":"PAL_21-22_Ren_10#","%_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":5275,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage de Porsmoguer","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 Porsmoguer<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Plouarzel \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=\"Plage de Porsmoguer\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren-1_1_Photo_Site-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2 class=\"site\">Plage de Porsmoguer<\/h2>\n<p>Latitude : 48.40725\u00b0N | Longitude : 4.777147\u00b0W<br \/>Commune : Plouarzel<\/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-Ren-1FM.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-Ren-1FS.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_Ren_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_Ren_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_Ren_1_FE.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_Ren_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_Ren_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_Ren_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_Ren_10_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_Ren_10_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_Ren_10_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Plouarzel \u2022 2019-2024","location":{"lat":"48.40725","lng":"-4.777147","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-porsmoguer\/","zoom":7,"extra_fields":{"post_excerpt":"Plouarzel \u2022 2019-2024","post_content":"<h2 class=\"site\">Plage de Porsmoguer<\/h2>\n<p>Latitude : 48.40725\u00b0N | Longitude : 4.777147\u00b0W<br \/>Commune : Plouarzel<\/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-Ren-1FM.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-Ren-1FS.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_Ren_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_Ren_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_Ren_1_FE.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_Ren_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_Ren_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_Ren_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_Ren_10_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_Ren_10_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_Ren_10_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage de Porsmoguer","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-de-porsmoguer\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Plage de Porsmoguer\" width=\"300\" height=\"169\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren-1_1_Photo_Site-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.40725","%_wpgmp_metabox_longitude%":"-4.777147","%_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:\"31\";}","%refpoint%":"PAL_19-20_Ren_1","%_wp_page_template%":"default","%_thumbnail_id%":"11453","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":4283,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Coll\u00e8ge De La Grande 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\">Coll\u00e8ge De La Grande M\u00e9tairie<\/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 De La Grande M\u00e9tairie\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren10-5_Photo_VracMacro-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><div id=\"contenu_article\"><h2>Coll\u00e8ge De La Grande M\u00e9tairie<\/h2>\n<p>Commune\u00a0: Ploufragan<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>52 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Montrichard\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren10FM.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-Ren10FS.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":"48.49425405817851","lng":"-2.7984697866982393","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-de-la-grande-metairie\/","zoom":7,"extra_fields":{"post_excerpt":"5\u00e8me \u2022 2022-2023","post_content":"<h2>Coll\u00e8ge De La Grande M\u00e9tairie<\/h2>\n<p>Commune\u00a0: Ploufragan<br>Acad\u00e9mie : Rennes<\/p>\n<h3>Ann\u00e9e scolaire : 2022-2023<\/h3>\n<h4>52 \u00e9l\u00e8ves de 5\u00e8me<\/h4>\n<h6>Science<\/h6>\n<p>L'\u00e9tude porte sur le site \"Plage de Montrichard\".<\/p>\n<ul><li><a rel=\"noreferrer noopener\" href=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/05\/PAL-22-23-Ren10FM.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-Ren10FS.pdf\" target=\"_blank\">Fiche bilan sur les m\u00e9soplastiques et microplastiques de surface<\/a><\/li><\/ul>","post_title":"Coll\u00e8ge De La Grande M\u00e9tairie","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/college-de-la-grande-metairie\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coll\u00e8ge De La Grande M\u00e9tairie\" width=\"300\" height=\"225\" src=\"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/uploads\/2023\/07\/PAL_22-23_Ren10-5_Photo_VracMacro-300x225.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpgmp_metabox_latitude%":"48.49425405817851","%_wpgmp_metabox_longitude%":"-2.7984697866982393","%_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:\"31\";}","%refpoint%":"PAL_22-23_Ren_10#","%_wp_page_template%":"default","%_thumbnail_id%":"11459","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":8755,"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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]},{"source":"post","title":"Plage du Prieur\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\">Plage du Prieur\u00e9<\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Dinard \u2022 2019-2020\/2021-2022\/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\">Plage du Prieur\u00e9<\/h2>\n<p>Latitude : 48.6258333\u00b0N | Longitude : 2.0527777\u00b0W<br \/>Commune : Dinard<\/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-Ren-8FM.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-Ren-8FS.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_Ren-8_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\/07\/PAL_21-22_Ren-8_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\/07\/PAL_21-22_Ren-8_FE.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_Ren_8_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_Ren_8_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_Ren_8_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul><\/div><\/div>","content":"Dinard \u2022 2019-2020\/2021-2022\/2022-2023","location":{"lat":"48.6258333","lng":"-2.0527777","onclick_action":"marker","redirect_permalink":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-prieure\/","zoom":7,"extra_fields":{"post_excerpt":"Dinard \u2022 2019-2020\/2021-2022\/2022-2023","post_content":"<h2 class=\"site\">Plage du Prieur\u00e9<\/h2>\n<p>Latitude : 48.6258333\u00b0N | Longitude : 2.0527777\u00b0W<br \/>Commune : Dinard<\/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-Ren-8FM.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-Ren-8FS.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_Ren-8_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\/07\/PAL_21-22_Ren-8_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\/07\/PAL_21-22_Ren-8_FE.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_Ren_8_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_Ren_8_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_Ren_8_FE.pdf\" target=\"_blank\">Fiche bilan sur les microplastiques enfouis<\/a><\/li>\n<\/ul>","post_title":"Plage du Prieur\u00e9","post_link":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/sites-classes\/plage-du-prieure\/","post_featured_image":"","post_categories":"","post_tags":"","%_wp_old_slug%":"plage-du-prieure-2","%_wpgmp_metabox_latitude%":"48.6258333","%_wpgmp_metabox_longitude%":"-2.0527777","%_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:\"31\";}","%refpoint%":"PAL_19-20_Ren_8","%_wp_page_template%":"default","taxonomy=type-site-classe":"Sites","taxonomy=etude":"Macro et micro-pollution, Macro-pollution","taxonomy=annee":"2019-2020, 2021-2022, 2022-2023"},"icon":"https:\/\/plastiquealaloupe.fondationtaraocean.org\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/maker-site-2.png"},"id":8558,"custom_filters":{"%type-site-classe%":["Sites"],"%etude%":["Macro et micro-pollution","Macro-pollution"],"%annee%":["2019-2020","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":"Rennes","id":"31","type":"category","extension_fields":{"cat_order":"0"}}]}],"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"}}