Poggio Mirteto
Popolazione: 5987 al 01/01/2009 ( 2919 M. – 3068 F.)
Altitudine: (s.l.m.) 246 m.
Distanza da Roma: 53,7 km.
Distanza da Rieti: 49 km.
La fondazione della cittadina sembra avere inizio fra il XIII e il XIV sec. La zona risulta però occupata fin dal periodo romano, come testimoniato dalla presenza di un impianto termale del I sec.
denominato Bagni di Lucilla, in zona San Valentino.
La fine dell’era feudale e la perdita del valore strategico ed economico del Castrum, determinarono l’attuale assetto urbanistico di Poggio Mirteto. Da quell’epoca si verificò una netta divisione in due parti : quella antica, che conserva tutt’ora il suo aspetto medievale, e la parte moderna che si sviluppò oltre la Porta Farnese, nell’odierna Piazza Martiri della Libertà.
Castel S. Pietro fa parte di Poggio Mirteto, ed è un grazioso borgo arroccato in posizione panoramica a pochi chilometri dal centro. Il borgo pare essere sorto sui resti di una villa romana attribuita a Diocleziano.
Video
Recapiti Telefonici
UFFICI COMUNALI
Indirizzo: PIAZZA MARTIRI DELLA LIBERTA’, 40
C.A.P. 02047
Telefono: +39 0765 545200
Fax: +39 0765 22350
Email: info@comune.poggiomirteto.ri.it
Sito Web: www.comune.poggiomirteto.ri.it
NUMERI UTILI
Carabinieri: 0765/24003 – 423465
Distretto scolastico: 0765/423245
Mappa e Lista dei Punti di Interesse
{"map_options":{"center_lat":"42.2646533","center_lng":"12.6847996","zoom":13,"map_type_id":"SATELLITE","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:\/\/geosabina.it\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","draggable":true,"scroll_wheel":"false","gesture":"auto","marker_default_icon":"https:\/\/geosabina.it\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","infowindow_setting":"<div class=\"fc-item-box fc-item-no-padding\">\n<div class=\"fc-infowindow3\">\n<div class=\"fc-item-title fc-item-primary-text-color\">{marker_title}<\/div>\n<div class=\"fc-item-meta fc-item-secondary-text-color\">{marker_category}<\/div>\n<div class=\"fc-feature-image\">{marker_image}<\/div>\n<\/p><\/div>\n<\/div>\n","infowindow_geotags_setting":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    {post_featured_image}\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"{post_link}\" class=\"fc-post-link\">{post_title}<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","infowindow_skin":{"name":"fano","type":"infowindow","sourcecode":"&lt;div class=&quot;fc-item-box fc-item-no-padding&quot;&gt;\r\n    &lt;div class=&quot;fc-infowindow3&quot;&gt;\r\n        &lt;div class=&quot;fc-item-title fc-item-primary-text-color&quot;&gt;{marker_title}&lt;\/div&gt;\r\n        &lt;div class=&quot;fc-item-meta fc-item-secondary-text-color&quot;&gt;{marker_category}&lt;\/div&gt;\r\n        &lt;div class=&quot;fc-feature-image&quot;&gt;{marker_image}&lt;\/div&gt;\r\n    &lt;\/div&gt;\r\n&lt;\/div&gt;"},"infowindow_post_skin":{"name":"aare","type":"post","sourcecode":"&lt;div class=&quot;fc-item-box fc-item-no-padding &quot;&gt;\r\n    {post_featured_image}\r\n    &lt;div style=&quot;padding: 20px;&quot; class=&quot;fc-itemcontent-padding&quot;&gt;\r\n        &lt;div&gt;\r\n &lt;div class=&quot;fc-item-title fc-item-primary-text-color&quot;&gt;&lt;a target=&quot;_self&quot; href=&quot;{post_link}&quot; class=&quot;fc-post-link&quot;&gt;{post_title}&lt;\/a&gt;&lt;\/div&gt;\r\n            &lt;div class=&quot;fc-item-content fc-item-body-text-color&quot;&gt;{marker_address}&lt;\/div&gt;\r\n        &lt;\/div&gt;\r\n    &lt;\/div&gt;\r\n    &lt;div class=&quot;fc-clear&quot;&gt;&lt;\/div&gt;\r\n&lt;\/div&gt;"},"infowindow_drop_animation":false,"close_infowindow_on_map_click":false,"default_infowindow_open":false,"infowindow_open_event":"click","listing_infowindow_open_event":"click","is_mobile":false,"infowindow_filter_only":false,"infowindow_click_change_zoom":0,"infowindow_click_change_center":false,"full_screen_control":true,"search_control":true,"zoom_control":true,"map_type_control":true,"street_view_control":true,"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":{"smartphone":{"map_zoom_level_mobile":"5"},"ipad":{"map_zoom_level_mobile":"5"},"schermi-di-grandi-dimensioni":{"map_zoom_level_mobile":"5"}},"map_infowindow_customisations":true,"infowindow_width":"100%","infowindow_border_color":"rgba(0, 0, 0, 0.0980392)","infowindow_bg_color":"#ffffff","show_infowindow_header":false,"min_zoom":"6","max_zoom":"19","zoom_level_after_search":"19","url_filters":false,"doubleclickzoom":false,"current_post_only":false,"bound_map_after_filter":false,"display_reset_button":false,"map_reset_button_text":"Reset","height":"600"},"places":[{"source":"post","title":"Cattedrale Santa Maria Assunta","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Cattedrale Santa Maria Assunta\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/cattedrale-1024x576-1-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/cattedrale-santa-maria-assunta\/\" class=\"fc-post-link\">Cattedrale Santa Maria Assunta<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Piazza Martiri della Libert\u00e0, 30, 02047 Poggio Mirteto RI, Italia","location":{"lat":"42.2646533","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6847996","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/cattedrale-santa-maria-assunta\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]Dopo aver percorso il bel viale di platani si accede alla seicentesca Piazza Martiri della Libert\u00e0 sulla quale si affaccia la maestosa Cattedrale Santa Maria Assunta, realizzata tra il 1641 ed il 1725, con facciata in cotto ed interno a tre navate, con tele raffiguranti una Madonna[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner][vc_column_inner][vc_empty_space height=\"25px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.com%2Fmaps%2Fdir%2F%2FCattedrale%2Bdi%2BSanta%2BMaria%2BAssunta%2C%2BPiazza%2BMartiri%2Bdella%2BLibert%25C3%25A0%2C%2B39%2C%2B02047%2BPoggio%2BMirteto%2BRI%2F%4042.264575%2C12.6818856%2C17z%2Fdata%3D!4m9!4m8!1m0!1m5!1m1!1s0x132f0eef480853e7%3A0x48e9fee3d116215c!2m2!1d12.6840837!2d42.2644361!3e0|target:_blank\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Cattedrale <strong>Santa Maria Assunta<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1669575334869{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Piazza Martiri della Libert\u00e0, 30\r\n02047 <strong>Poggio Mirteto<\/strong> (RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695295322115{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Messe festive:<\/strong> 8:00, 10:00, 11:30, 19:00 (ora solare\u00a0alle 17,30)\r\n\r\n<strong>Messe feriali<\/strong>: 7:30, 19:00 (ora solare alle 17,30)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contatti<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695294756498{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Il parroco<\/strong>: 0765 201279\r\n<strong>Mail<\/strong>: <a href=\"mailto:mauroguida@alice.it\">mauroguida@alice.it<\/a>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Dopo aver percorso il bel viale di platani si accede alla seicentesca Piazza Martiri della Libert\u00e0 sulla quale si affaccia la maestosa Cattedrale Santa Maria Assunta, realizzata tra il 1641 ed il 1725, con facciata in cotto ed interno a tre navate, con tele raffiguranti una Madonna in trono con bambino, un Transito di San Giuseppe ed il Battesimo di Cristo e la Chiesa di San Rocco dalle linee baroccheggianti, ultimata nell\u2019anno 1779.[\/vc_column_text][vc_empty_space height=\"40px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"4\" slider_loop=\"yes\" slider_autoplay=\"yes\" slider_navigation=\"yes\" slider_pagination=\"yes\" images=\"6762,6764,6766,6768,6770,6772\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_column_text]\r\n<div class=\"logo-gutter ng-tns-c2676124745-13 ng-star-inserted\">\r\n<div class=\"gutter ng-star-inserted\">\r\n<div class=\"cdk-visually-hidden cdk-focus-trap-anchor\" tabindex=\"0\" aria-hidden=\"true\"><\/div>\r\n<div class=\"container\" role=\"dialog\" aria-live=\"polite\" aria-atomic=\"true\">\r\n<div class=\"recitation-tooltip\" aria-live=\"polite\" aria-atomic=\"true\">\r\n<div class=\"text-container\"><\/div>\r\n<\/div>\r\n<\/div>\r\n<div class=\"cdk-visually-hidden cdk-focus-trap-anchor\" tabindex=\"0\" aria-hidden=\"true\"><\/div>\r\n<div class=\"response-container-content ng-tns-c2676124745-13\">\r\n<div class=\"response-content ng-trigger ng-trigger-responsePopulation ng-tns-c2676124745-13 ng-animate-disabled\">\r\n<div class=\"markdown markdown-main-panel\" dir=\"ltr\">\r\n<p data-sourcepos=\"1:1-1:179\"><span class=\"citation-0 citation-end-0\">La cattedrale di Santa Maria Assunta \u00e8 il principale luogo di culto della citt\u00e0 di Poggio Mirteto, nel Lazio, e sede della sede suburbicaria di Sabina-Poggio Mirteto.<\/span><\/p>\r\n<p data-sourcepos=\"3:1-3:286\">La costruzione della cattedrale inizi\u00f2 nel 1641 per volere dell'abate commendatario dell'Abbazia di Farfa, don Carlo Guglielmi, e fu completata nel 1725. Il progetto \u00e8 attribuito a Martino Longhi il Giovane, ma alcuni studiosi ritengono che sia stato realizzato da un architetto locale.<\/p>\r\n<p data-sourcepos=\"5:1-5:205\">La cattedrale \u00e8 in stile barocco e presenta una facciata in cotto con tre portali e un timpano curvilineo. Il campanile, posto sul lato destro della facciata, \u00e8 in stile neoclassico e risale al XIX secolo.<\/p>\r\n<p data-sourcepos=\"7:1-7:363\">L'interno della cattedrale \u00e8 a tre navate, con una navata centrale pi\u00f9 ampia e due navate laterali pi\u00f9 strette. Le navate sono separate da pilastri e archi a tutto sesto. Il presbiterio \u00e8 rialzato rispetto al resto della chiesa e ospita l'altare maggiore, sul quale \u00e8 collocata una pala d'altare raffigurante l'Assunzione della Vergine Maria di Giovanni Baglione.<\/p>\r\n<p data-sourcepos=\"9:1-9:85\">La cattedrale conserva anche un pregevole organo a canne, costruito nel XVIII secolo.<\/p>\r\n<p data-sourcepos=\"11:1-11:73\">Tra le opere d'arte conservate all'interno della cattedrale si segnalano:<\/p>\r\n\r\n<ul data-sourcepos=\"13:1-18:0\">\r\n \t<li data-sourcepos=\"13:1-13:68\">una Madonna in trono con bambino, attribuita a Antonio da Viterbo;<\/li>\r\n \t<li data-sourcepos=\"14:1-14:50\">un Transito di San Giuseppe, di Antonio Amorosi;<\/li>\r\n \t<li data-sourcepos=\"15:1-15:47\">il Battesimo di Cristo, di Francesco Mancini;<\/li>\r\n \t<li data-sourcepos=\"16:1-16:39\">un crocifisso ligneo, del XVI secolo;<\/li>\r\n \t<li data-sourcepos=\"17:1-18:0\">una croce processionale, del XVI secolo.<\/li>\r\n<\/ul>\r\n<p data-sourcepos=\"19:1-19:162\">La cattedrale di Santa Maria Assunta \u00e8 un importante monumento storico e artistico della citt\u00e0 di Poggio Mirteto. \u00c8 stata dichiarata monumento nazionale nel 1902.<\/p>\r\n<p data-sourcepos=\"21:1-21:35\"><strong>Chi ha costruito la cattedrale?<\/strong><\/p>\r\n<p data-sourcepos=\"23:1-23:141\">La cattedrale \u00e8 stata progettata da Martino Longhi il Giovane, ma alcuni studiosi ritengono che sia stata realizzata da un architetto locale.<\/p>\r\n<p data-sourcepos=\"25:1-25:29\"><strong>Quando \u00e8 stata costruita?<\/strong><\/p>\r\n<p data-sourcepos=\"27:1-27:73\">La costruzione della cattedrale inizi\u00f2 nel 1641 e fu completata nel 1725.<\/p>\r\n<p data-sourcepos=\"29:1-29:29\"><strong>In che stile \u00e8 costruita?<\/strong><\/p>\r\n<p data-sourcepos=\"31:1-31:33\">La cattedrale \u00e8 in stile barocco.<\/p>\r\n<p data-sourcepos=\"33:1-33:71\"><strong>Quali sono le opere d'arte conservate all'interno della cattedrale?<\/strong><\/p>\r\n<p data-sourcepos=\"35:1-35:73\">Tra le opere d'arte conservate all'interno della cattedrale si segnalano:<\/p>\r\n\r\n<ul data-sourcepos=\"37:1-41:42\">\r\n \t<li data-sourcepos=\"37:1-37:68\">una Madonna in trono con bambino, attribuita a Antonio da Viterbo;<\/li>\r\n \t<li data-sourcepos=\"38:1-38:50\">un Transito di San Giuseppe, di Antonio Amorosi;<\/li>\r\n \t<li data-sourcepos=\"39:1-39:47\">il Battesimo di Cristo, di Francesco Mancini;<\/li>\r\n \t<li data-sourcepos=\"40:1-40:39\">un crocifisso ligneo, del XVI secolo;<\/li>\r\n \t<li data-sourcepos=\"41:1-41:42\">una croce processionale, del XVI secolo.<\/li>\r\n<\/ul>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Cattedrale Santa Maria Assunta","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/cattedrale-santa-maria-assunta\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Cattedrale Santa Maria Assunta\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/cattedrale-1024x576-1-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1669575334869{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695295322115{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695294756498{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":586,\"to_translate\":{\"en\":586}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Piazza Martiri della Libert\u00e0, 30, 02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2646533","%_wpgmp_metabox_longitude%":"12.6847996","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"4\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_thumbnail_id%":"7735","%_dp_original%":"4351","%_edit_lock%":"1702548984:6","%_edit_last%":"6","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_title%":"%%title%% - %%page%% %%sep%% Poggio Mirteto","%_yoast_wpseo_focuskw%":"Cattedrale Poggio Mirteto","%_yoast_wpseo_linkdex%":"65","%_yoast_wpseo_metadesc%":"A Poggio Mirteto in Piazza Martiri della Libert\u00e0 si affaccia la maestosa Cattedrale Santa Maria Assunta, realizzata tra il 1641 ed il 1725","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png"},"id":6755,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png","name":"Chiese e Santuari \/ Churches and Sanctuaries","id":"4","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Biblioteca di Poggio Mirteto","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Biblioteca di Poggio Mirteto\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/Screenshot-2023-09-12-104100-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/biblioteca-di-poggio-mirteto\/\" class=\"fc-post-link\">Biblioteca di Poggio Mirteto<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Via Antonio Gramsci, 5, 02047 Poggio Mirteto RI, Italia","location":{"lat":"42.2677635","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6866394","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/biblioteca-di-poggio-mirteto\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]La biblioteca comunale di Poggio Mirteto dedicata a Peppino Impastato, un uomo che perse la vita per le sue idee contro la mafia, \u00e8 un luogo straordinario che merita sicuramente una visita.\r\n\r\n[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][vc_empty_space height=\"25px\"][vc_row_inner][vc_column_inner][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"25px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.com%2Fmaps%2Fdir%2F42.266102%2C12.679045%2FBiblioteca%2BComunale%2B%2522Peppino%2BImpastato%2522%2C%2BVia%2BMatteotti%2C%2BPoggio%2BMirteto%2C%2BRI%2F%4042.2667843%2C12.6843768%2C18.5z%2Fdata%3D!4m9!4m8!1m1!4e1!1m5!1m1!1s0x132f0f464821b28d%3A0x53dcb31c78499c34!2m2!1d12.6864728!2d42.267331%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Biblioteca di <strong>Poggio Mirteto<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1658926671715{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Antonio Gramsci, 5\r\n02047 <strong>Poggio Mirteto<\/strong> (RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_column_text]<strong>Orario di apertura invernale<\/strong>\r\nDal luned\u00ec al venerd\u00ec\r\n9:00-19:00\r\nMarted\u00ec: 9:00-14:00[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contatti<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1693899554564{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Tel.<\/strong> +39 0765.545270\r\n<strong>Mail:<\/strong> poggiomirteto@bibliotechesabine.it[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]La biblioteca comunale di Poggio Mirteto dedicata a Peppino Impastato, un uomo che perse la vita per le sue idee contro la mafia, \u00e8 un luogo straordinario che merita sicuramente una visita.\r\n\r\nChe tu sia un appassionato lettore in cerca di nuovi mondi da esplorare o un viaggiatore curioso desideroso di scoprire la ricca cultura di Poggio Mirteto, questa biblioteca rappresenta un vero e proprio gioiello nascosto nel cuore del paese. La sua atmosfera accogliente, la vasta collezione di libri e le numerose attivit\u00e0 culturali la rendono un punto di riferimento imprescindibile per tutti coloro che desiderano immergersi nella bellezza della conoscenza e della cultura.[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Biblioteca di Poggio Mirteto","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/biblioteca-di-poggio-mirteto\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Biblioteca di Poggio Mirteto\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/Screenshot-2023-09-12-104100-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1658926671715{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1693899554564{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":233,\"to_translate\":{\"en\":233}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Antonio Gramsci, 5, 02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2677635","%_wpgmp_metabox_longitude%":"12.6866394","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_dp_original%":"4542","%_edit_lock%":"1707994028:4","%_edit_last%":"4","%_thumbnail_id%":"7702","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Biblioteca di Poggio Mirteto","%_yoast_wpseo_metadesc%":"la Biblioteca Comunale di Poggio Mirteto \u00e8 un luogo straordinario che merita sicuramente una visita. Che tu sia un appassionato lettore in cerca di nuovi mondi da esplorare o un viaggiatore curioso desideroso di scoprire.","%_yoast_wpseo_linkdex%":"69","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/biblioteche_sito.png"},"id":6739,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/biblioteche_sito.png","name":"Biblioteche \/ Libraries","id":"3","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Palazzo Vescovile","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Palazzo Vescovile\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/02\/palazzo-vescovile-1-300x169.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/palazzo-vescovile\/\" class=\"fc-post-link\">Palazzo Vescovile<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Piazza Mario Dottori, 8, 02047 Poggio Mirteto RI, Italia","location":{"lat":"42.2645687","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6832766","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/palazzo-vescovile\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]La struttura originaria del Palazzo, ha subito nel corso dei secoli diversi e complesse opere di ampiamento, soprattutto quando nel \u2018400 mut\u00f2 la sua funzione originaria per divenire sede principesca dell\u2019abate commendatario di Farfa[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner][vc_column_inner][vc_empty_space height=\"25px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FPiazza%2BMario%2BDottori%2C%2B8%2C%2B02047%2BPoggio%2BMirteto%2BRI%2F%4042.2645221%2C12.6828962%2C19.48z%2Fdata%3D!4m6!3m5!1s0x132f0eef6a5d526f%3A0x561fd7e67a34eb88!8m2!3d42.2645687!4d12.6832766!16s%252Fg%252F11csm19kzg%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Palazzo <strong>Vescovile<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1658924376333{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Piazza Mario Dottori, 8\r\n02047 <strong>Poggio Mirteto<\/strong> (RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695291564990{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Chiuso per ampliamento[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contatti<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1651910896780{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Tel.<\/strong>\r\n<strong>Mail:<\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]La struttura originaria del Palazzo, ha subito nel corso dei secoli diversi e complesse opere di ampiamento, soprattutto quando nel \u2018400 mut\u00f2 la sua funzione originaria per divenire sede principesca dell\u2019abate commendatario di Farfa, poi nell\u2019800 furono aggiunti i corpi di fabbrica per accogliere il seminario.\r\n\r\nSul portale del seminario, la lapide commemorativa , che a sua volta \u00e8 coronata dallo stemma papale. Diversi elementi architettonici compongono la facciata con antichi marmi inglobati sul muro. Sulla porta centrale, che un tempo era l\u2019unica e permetteva di accedere alla rocca \u2013palazzo, in alto si aprono due fessure attraverso le quali operavano i bilancieri che permettevano di sollevare o abbassare il ponte levatoio.\r\n\r\nL\u2019attuale rampa di accesso sostituisce l\u2019antico ponte levatoio sul lato sinistro del palazzo.\r\nL'interno del palazzo ad oggi non \u00e8 visitabile a causa di opere di ampiamento, le quali daranno spazio al museo diocesano che sar\u00e0 proprio all'interno dell'edificio[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Palazzo Vescovile","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/palazzo-vescovile\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Palazzo Vescovile\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/02\/palazzo-vescovile-1-300x169.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1658924376333{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695291564990{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1651910896780{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":270,\"to_translate\":{\"en\":270}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Piazza Mario Dottori, 8, 02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2645687","%_wpgmp_metabox_longitude%":"12.6832766","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_thumbnail_id%":"11267","%_oembed_ef296e728403ede8dcbc10df275b7112%":"<iframe title=\"Il Sentiero della Memoria, Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/jiyMkmJ2Pdg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_ef296e728403ede8dcbc10df275b7112%":"1658912551","%_dp_original%":"6640","%_edit_lock%":"1706788732:6","%_edit_last%":"6","%_yoast_wpseo_focuskw%":"Palazzo Vescovile","%_yoast_wpseo_metadesc%":"La struttura originaria del Palazzo Vescovile, ha subito nel corso dei secoli diversi e complessi restauri, soprattutto quando nel \u2018400 mut\u00f2 la sua funzione originaria per divenire sede principesca dell\u2019abate commendatario di Farfa, poi nell\u2019800 furono aggiunti i corpi di fabbrica per accogliere il seminario.","%_yoast_wpseo_linkdex%":"64","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Poggio Mirteto","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dimore-storiche_sito.png"},"id":6687,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dimore-storiche_sito.png","name":"Dimore Storiche \/ Historic Houses","id":"5","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Convento e Chiesa di San Valentino","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Convento e Chiesa di San Valentino\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/convento-san-valentino-1024-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/convento-e-chiesa-di-san-valentino\/\" class=\"fc-post-link\">Convento e Chiesa di San Valentino<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Via della Chiesa, 4A, 02047 San Valentino RI, Italia","location":{"lat":"42.27261499999999","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.695748","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/convento-e-chiesa-di-san-valentino\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]La primitiva chiesa di San Valentino era inserita nel Castello di Luco di cui segu\u00ec le sorti fino all\u2019abbandono nel 1100 ed il 1300. Il Convento fu affidato nel 1574 dall\u2019Abate Commendatario Alessandro Farnese ai Frati Conventuali.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner][vc_column_inner][vc_empty_space height=\"25px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FSan%2BValentino%2F%4042.2726527%2C12.6953733%2C19.92z%2Fdata%3D!4m15!1m8!3m7!1s0x132f0edf364d0cb7%3A0xc89962dfd1c9c0ca!2sVia%2Bdella%2BChiesa%2C%2B4A%2C%2B02047%2BSan%2BValentino%2BRI!3b1!8m2!3d42.272615!4d12.695748!16s%252Fg%252F11c26_fvdq!3m5!1s0x132f0edf37cab6a7%3A0x42f514c6831957d!8m2!3d42.272656!4d12.6959826!16s%252Fg%252F11ddwys77z%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Convento e Chiesa di <strong>San Valentino<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1658924012406{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via della Chiesa, 4A\r\n02047 <strong>Poggio Mirteto\u00a0<\/strong>(RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695114788256{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Alle ore 11,00[\/vc_column_text][vc_column_text css=\".vc_custom_1651915077990{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"][\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contatti<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695294867828{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Il parroco<\/strong>: 0765 201279\r\n<strong>Mail<\/strong>: <a href=\"mailto:mauroguida@alice.it\">mauroguida@alice.it<\/a>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]La primitiva chiesa di San Valentino era inserita nel Castello di Luco di cui segu\u00ec le sorti fino all\u2019abbandono nel 1100 ed il 1300. Il Convento fu affidato nel 1574 dall\u2019Abate Commendatario Alessandro Farnese ai Frati Conventuali. La chiesa fu arricchita di altari laterali ornati da stucchi di stile barocco, che fanno da cornice alle tele del XVII secolo. La chiesa venne acquistata dalla parrocchia di Poggio Mirteto nel 1892.\r\n\r\nIl convento con il coro e la cappella, che erano dietro l\u2019altare della chiesa, vennero acquistati nel 1893 dai religiosi francesi della Congregazione dello Spirito Santo. Solo nel 1952 il Card. Adeodato Giovanni Piazza acquist\u00f2 l\u2019ex convento , che divenne prima Villa del Seminario Vescovile di Magliano Sabina e poi Seminario Sabino. Attualmente una parte dello stabile \u00e8 adibita a casa del clero e l\u2019altra all\u2019accoglienza per gruppi di giovani. Tra i membri della comunit\u00e0 religiosa spiccano due insigni personaggi :S.Giuseppe da Copertino e Fra Lorenzo Ganganelli , che divenne Papa col nome di Papa Clemente XIV (1769-1774).\r\n\r\nIl caratteristico campanile a vela conserva una delle due campane sopravvissute al degrado . La campana \u00e8 del 1666, ha una salamandra in bassorilievo e l\u2019immagine di S.Antonio da Padova.\r\n\r\nLa pala dell\u2019altare maggiore rappresenta Ges\u00f9 in croce, la Madonna e S. Giovanni. La tela ad olio \u00e8 opera della Scuola di Guido Reni. Abbiamo una prima cappella a sinistra di chi entra dedicata a S.Filippo Neri. Nella seconda cappella un\u2019opera di Vincenzo Manenti (1599-1673) rappresenta S.Antonio da Padova.\r\n\r\nUna tela ad olio rappresentante un paesaggio con la torre dove fu rinchiusa dal padre Santa Barbara, \u00e8 nella terza cappella ; l\u2019opera \u00e8 del XVII secolo.\r\n\r\nA destra di chi entra altre tre cappelle : la prima dedicata a S.Francesco, la seconda dedicata alla Vergine Immacolata, la terza a S.Giuseppe da Copertino[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Convento e Chiesa di San Valentino","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/convento-e-chiesa-di-san-valentino\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Convento e Chiesa di San Valentino\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/convento-san-valentino-1024-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1658924012406{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695114788256{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1651915077990{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695294867828{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":434,\"to_translate\":{\"en\":434}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via della Chiesa, 4A, 02047 San Valentino RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.27261499999999","%_wpgmp_metabox_longitude%":"12.695748","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"4\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_dp_original%":"4497","%_edit_lock%":"1702549209:6","%_edit_last%":"6","%_thumbnail_id%":"7764","%_yoast_wpseo_focuskw%":"Convento e Chiesa di San Valentino","%_yoast_wpseo_metadesc%":"La primitiva chiesa di San Valentino era inserita nel Castello di Luco di cui segu\u00ec le sorti fino all\u2019abbandono nel 1100 ed il 1300. Il Convento fu affidato nel 1574 ai Frati Conventuali.","%_yoast_wpseo_linkdex%":"64","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Poggio Mirteto","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png"},"id":6682,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png","name":"Chiese e Santuari \/ Churches and Sanctuaries","id":"4","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Piazza Martiri della Libert\u00e0","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Piazza Martiri della Libert\u00e0\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/124-1024x576-1-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/piazza-martiri-della-liberta\/\" class=\"fc-post-link\">Piazza Martiri della Libert\u00e0<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Piazza Martiri della Libert\u00e0, 02047 Poggio Mirteto RI, Italia","location":{"lat":"42.264689","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6850232","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/piazza-martiri-della-liberta\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]Questa bella piazza rappresenta il centro sociale e commerciale di Poggio Mirteto. Nel 1610 vennero pose le basi per il suo futuro assetto urbanistico via via ampliate e modificate, come gli edifici i quali vennero alzati di un piano sotto la spinta demografica. La definizione urbanistica continu\u00f2 con la costruzione del muro di sostegno verso Rio Sole e il livellamento stradale del 1893.\r\n\r\nIl monumento ai caduti al centro della piazza, inaugurato il 9 agosto 1926 \u00e8 opera dell\u2019architetto Balestrieri. Sull\u2019 edificio, al n. 34 , una lapide commemorativa ci racconta il soggiorno di Anita Garibaldi, ospitata incinta al quinto mese a casa Lattanzi. Garibaldi volle restare con i suoi uomini in localit\u00e0 Valle Tonda-Rio Sole, dove \u00e8 stato eretto il piccolo monumento vicino alla stazione degli autobus. Un\u2019altra lapide ricorda i Poggiani caduti nelle guerre risorgimentali al seguito di Garibaldi. Altre lapidi ricordano il bombardamento di mortai sui civili del 1944 ed i caduti della seconda guerra mondiale.\r\n\r\nDove ora si trova l\u2019edicola dei giornali, venivano innalzati i patiboli per le decapitazioni dei condannati a morte. L\u2019ultima esecuzione avvenne nel 1844, quando vennero uccisi Bartolomeo Di Pietro di anni 28, e Giovanni Gerardi di 25, condannati per l\u2019uccisione di un monaco di Roccantica. L\u2019esecuzione avvenne per mano del famoso boia \u201cMastro Titta\u201d.\r\n\r\nSulla facciata del numero civico 63, interessante meridiana, su cui si legge: \u201cNARDI POSUIT\u201d, essendo stata impiantata nel 1889 da Ercole Nardi, studioso e storico locale.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner][vc_column_inner][vc_empty_space height=\"25px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FPiazza%2BMartiri%2Bdella%2BLibert%25C3%25A0%2C%2B02047%2BPoggio%2BMirteto%2BRI%2F%4042.2649134%2C12.6842639%2C19z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132f0ee8ad79d231%3A0x4ec4f12283d4bd36!8m2!3d42.2649124!4d12.6849076!16s%252Fg%252F11b6gddj8n%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Piazza Martiri della <strong>Libert\u00e0<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1658923659115{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Piazza Martiri della Libert\u00e0\r\n02047 <strong>Poggio Mirteto\u00a0<\/strong>(RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1694174521887{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Sempre Aperto[\/vc_column_text][vc_column_text css=\".vc_custom_1651915077990{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"][\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contatti<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1651915086405{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Tel.<\/strong>\r\n<strong>Mail:<\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Questa bella piazza rappresenta il centro sociale e commerciale di Poggio Mirteto. Nel 1610 vennero pose le basi per il suo futuro assetto urbanistico via via ampliate e modificate, come gli edifici i quali vennero alzati di un piano sotto la spinta demografica. La definizione urbanistica continu\u00f2 con la costruzione del muro di sostegno verso Rio Sole e il livellamento stradale del 1893.\r\n\r\nIl monumento ai caduti al centro della piazza, inaugurato il 9 agosto 1926 \u00e8 opera dell\u2019architetto Balestrieri. Sull\u2019 edificio, al n. 34 , una lapide commemorativa ci racconta il soggiorno di Anita Garibaldi, ospitata incinta al quinto mese a casa Lattanzi. Garibaldi volle restare con i suoi uomini in localit\u00e0 Valle Tonda-Rio Sole, dove \u00e8 stato eretto il piccolo monumento vicino alla stazione degli autobus. Un\u2019altra lapide ricorda i Poggiani caduti nelle guerre risorgimentali al seguito di Garibaldi. Altre lapidi ricordano il bombardamento di mortai sui civili del 1944 ed i caduti della seconda guerra mondiale.\r\n\r\nDove ora si trova l\u2019edicola dei giornali, venivano innalzati i patiboli per le decapitazioni dei condannati a morte. L\u2019ultima esecuzione avvenne nel 1844, quando vennero uccisi Bartolomeo Di Pietro di anni 28, e Giovanni Gerardi di 25, condannati per l\u2019uccisione di un monaco di Roccantica. L\u2019esecuzione avvenne per mano del famoso boia \u201cMastro Titta\u201d.\r\n\r\nSulla facciata del numero civico 63, interessante meridiana, su cui si legge: \u201cNARDI POSUIT\u201d, essendo stata impiantata nel 1889 da Ercole Nardi, studioso e storico locale.[\/vc_column_text][vc_row_inner el_class=\"video_app\"][vc_column_inner][vc_empty_space height=\"25px\"][vc_empty_space height=\"25px\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row]","post_title":"Piazza Martiri della Libert\u00e0","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/piazza-martiri-della-liberta\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Piazza Martiri della Libert\u00e0\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/124-1024x576-1-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1658923659115{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1694174521887{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1651915077990{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1651915086405{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":311,\"to_translate\":{\"en\":311}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Piazza Martiri della Libert\u00e0, 02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.264689","%_wpgmp_metabox_longitude%":"12.6850232","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_dp_original%":"4497","%_edit_lock%":"1702121131:6","%_edit_last%":"6","%_thumbnail_id%":"7794","%_yoast_wpseo_focuskw%":"Piazza Martiri della Libert\u00e0","%_yoast_wpseo_metadesc%":"Piazza Martiri della libert\u00e0 rappresenta il centro sociale e commerciale di Poggio Mirteto dove nel 1610 vennero pose le basi per il suo futuro assetto urbanistico.","%_yoast_wpseo_linkdex%":"69","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Poggio Mirteto","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png"},"id":6675,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png","name":"Borghi e Centri Storici \/ Villages and Historical Towns","id":"2","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"ITINERARIO | Il Sentiero della Memoria","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"ITINERARIO | Il Sentiero della Memoria\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-naturalistici-anteprima-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/il-sentiero-della-memoria\/\" class=\"fc-post-link\">ITINERARIO | Il Sentiero della Memoria<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"02047 Poggio Mirteto Scalo RI, Italia","location":{"lat":"42.2461204","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6352566","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/il-sentiero-della-memoria\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]\r\n<p data-sourcepos=\"1:1-1:87\"><strong>Il cammino della memoria di Poggio Mirteto: un percorso di riflessione e conoscenza<\/strong> \u00e8 un percorso escursionistico che si snoda nel territorio del comune laziale, in provincia di Rieti. Il sentiero \u00e8 dedicato alla memoria delle vittime della Seconda Guerra Mondiale<\/p>\r\n[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-sm vc_hidden-xs\"][vc_empty_space height=\"20px\"][vc_single_image image=\"9145\" img_size=\"full\" alignment=\"center\" onclick=\"custom_link\" el_class=\"itinerari\" link=\"https:\/\/geosabina.it\/itinerari\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"20px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FStazione%2BFS%2Bdi%2BPoggio%2BMirteto%2F%4042.2422332%2C12.6337795%2C19.62z%2Fdata%3D!4m14!1m7!3m6!1s0x132f0e0801be818b%3A0x9dbbc2eee9b59ccd!2sPoggio%2BMirteto!8m2!3d42.2421604!4d12.6333585!16s%252Fg%252F120qdrb3!3m5!1s0x132f0fcea0fec53d%3A0x9f18d8ae80219290!8m2!3d42.2422151!4d12.633396!16s%252Fg%252F11kbj237kc%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner el_class=\"info_app\" css=\".vc_custom_1696325961236{padding: 20px !important;}\"][vc_column_inner][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Tipologia<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1713539948355{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Percorso a Piedi<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Numero Tappe<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1713539962744{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">1<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Durata<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1713539987856{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">1 Giorno<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Difficolt\u00e0<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1713539993912{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Facile<\/span><\/strong>[\/vc_column_text][vc_column_text el_class=\"info-point\"]\r\n<h4 style=\"padding-top: 5px;\"><strong>Punto di Partenza<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1713540769625{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}\"]<strong><span style=\"color: #ffffff;\">Stazione Ferroviaria di Poggio Mirteto<\/span><\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_row_inner][vc_column_inner][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Il sentiero della<strong> Memoria<\/strong><\/h2>\r\n[\/vc_column_text][vc_column_text css=\".vc_custom_1713540392633{margin-top: -20px !important;}\"]\r\n<h5>Itinerario Naturalistico<\/h5>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695030818478{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Stazione Ferroviaria\r\nPoggio Mirteto Scalo\r\n02047 <strong>Poggio Mirteto<\/strong> (RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1651841472116{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Sempre aperto[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contatti<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1651910896780{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Tel.<\/strong>\r\n<strong>Mail:<\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]\r\n<p data-sourcepos=\"1:1-1:87\"><strong>Il cammino della memoria di Poggio Mirteto: un percorso di riflessione e conoscenza<\/strong> \u00e8 un percorso escursionistico che si snoda nel territorio del comune laziale, in provincia di Rieti. Il sentiero \u00e8 dedicato alla memoria delle vittime della Seconda Guerra Mondiale e della Resistenza. Il sentiero inizia dalla stazione ferroviaria di Poggio Mirteto e si sviluppa su un percorso ad anello di circa 10 chilometri che attraversa boschi, sentieri, strade rurali e siti storici.<\/p>\r\n<p data-sourcepos=\"7:1-7:48\">Il sentiero tocca i seguenti <strong>punti di interesse:<\/strong><\/p>\r\n\r\n<ul data-sourcepos=\"9:1-14:0\">\r\n \t<li data-sourcepos=\"9:1-9:143\"><strong>La stazione ferroviaria di Poggio Mirteto<\/strong>, dove si trova un monumento dedicato ai partigiani caduti nella battaglia di Poggio Mirteto (1944).<\/li>\r\n \t<li data-sourcepos=\"10:1-10:91\"><strong>Il cimitero dei partigiani<\/strong>, dove sono sepolti i caduti della battaglia di Poggio Mirteto.<\/li>\r\n \t<li data-sourcepos=\"11:1-11:83\"><strong>La cava di pietra di Collelungo<\/strong>, dove furono fucilati alcuni partigiani nel 1944.<\/li>\r\n \t<li data-sourcepos=\"12:1-12:89\"><strong>Il cimitero di Collelungo<\/strong>, dove sono sepolti i civili uccisi dai nazifascisti nel 1944.<\/li>\r\n \t<li data-sourcepos=\"13:1-14:0\"><strong>La casa di riposo di Collelungo<\/strong>, dove fu ospitato un campo di concentramento per ebrei e prigionieri politici.<\/li>\r\n<\/ul>\r\n<p data-sourcepos=\"15:1-15:245\">Il cammino della memoria \u00e8 un percorso impegnativo, ma \u00e8 anche un'esperienza significativa. Il percorso permette di conoscere la storia della Seconda Guerra Mondiale e della Resistenza in Sabina, e di riflettere sulle vittime di questa tragedia.<\/p>\r\n<p data-sourcepos=\"39:1-39:163\">attraversando boschi, sentieri, strade rurali e siti storici,\u00a0 permette di immergersi nella natura e di scoprire luoghi nascosti e sconosciuti che permette di conoscere il territorio e di comprendere la sua storia. Il percorso \u00e8 un'occasione per riflettere sul passato e sul presente, e per costruire un futuro migliore.<\/p>\r\n<p data-sourcepos=\"53:1-53:252\">Il cammino della memoria di Poggio Mirteto \u00e8 un percorso importante, che merita di essere conosciuto e apprezzato.<\/p>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][vc_row_inner el_class=\"video_app\"][vc_column_inner][vc_empty_space height=\"25px\"][vc_column_text]\r\n<h2><strong>Video<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=8OzuhFqWGG4\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"ITINERARIO | Il Sentiero della Memoria","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/il-sentiero-della-memoria\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"ITINERARIO | Il Sentiero della Memoria\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-naturalistici-anteprima-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1696325961236{padding: 20px !important;}.vc_custom_1713539948355{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1713539962744{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1713539987856{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1713539993912{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1713540769625{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1713540392633{margin-top: -20px !important;}.vc_custom_1695030818478{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1651841472116{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1651910896780{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":403,\"to_translate\":{\"en\":403}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"02047 Poggio Mirteto Scalo RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2461204","%_wpgmp_metabox_longitude%":"12.6352566","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:4:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";i:3;s:2:\"16\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"19\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_thumbnail_id%":"9195","%_dp_original%":"4351","%_edit_lock%":"1713541614:6","%_edit_last%":"6","%_oembed_ef296e728403ede8dcbc10df275b7112%":"<iframe title=\"Il Sentiero della Memoria, Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/jiyMkmJ2Pdg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_ef296e728403ede8dcbc10df275b7112%":"1658912551","%_yoast_wpseo_focuskw%":"Il Sentiero della Memoria","%_yoast_wpseo_metadesc%":"Il cammino della memoria \u00e8 un percorso escursionistico di riflessione e conoscenza dedicato alla memoria delle vittime della Seconda Guerra Mondiale","%_yoast_wpseo_linkdex%":"63","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_0b796fbec68584d2d75e8dff768a648a%":"<iframe title=\"Sentiero della Memoria   Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/8OzuhFqWGG4?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_0b796fbec68584d2d75e8dff768a648a%":"1694085411","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Poggio Mirteto","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/bellezze-naturali_sito.png"},"id":6640,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/bellezze-naturali_sito.png","name":"Bellezze Naturali \/ Natural Beauties","id":"1","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari_sito.png","name":"Itinerari Naturalistici \/ Nature Trails","id":"19","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Sala Farnese","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sala Farnese\" width=\"300\" height=\"300\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/07\/salafarnese-300x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/sala-farnese\/\" class=\"fc-post-link\">Sala Farnese<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Piazza Giuseppe Garibaldi, 1, 02047 Poggio Mirteto RI, Italia","location":{"lat":"42.2644386","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6828447","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/sala-farnese\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]E\u2019 la prima chiesa dentro le mura della citt\u00e0 costruita forse in un ex posto di guardia accanto al Palazzo abbaziale. Consacrata nel 1478, fu dedicata prima a S. Maria Assunta, in seguito chiesa della SS. Trinit\u00e0; attualmente \u00e8 chiamata sala Farnese ed \u00e8 propriet\u00e0 del Comune che la utilizza come sala polivalente. Della primitiva chiesa rimangono visibili l\u2019abside, tracce murarie delle cappelle laterali e pochi residui di affreschi alle pareti. Il campanile oggi La torre dell\u2019orologio \u00e8 il risultato di una trasformazione avvenuta nel corso dei secoli: nata a difesa della Porta detta di \u201csopra\u201d all\u2019origine la torre merlata \u00e8 circondata da due torrioni di cui oggi sono visibili solo i basamenti.\r\n\r\nAlla fine del 1500 con la costruzione del nuovo sistema difensivo, con relative mura e porte la torre viene sopraelevata creando uno spazio per ospitare le campane della chiesa di San Paolo, e trasformata in torre dell\u2019orologio. In detta sopraelevazione viene creata una monofora per ciascun lato per dare visibilit\u00e0 alle campane, bordata da una coppia di lesene in mattoncini; a coronamento un elegante calotta ottagonale con copertura in piombo. Sulle facciate interne, due quadranti in marmo bianco di forma circolare\r\n\r\nL\u2019edificio sembra sia stato ricavato dai locali adibiti a posto di guardia di Porta Romana.\r\n\r\nVenne consacrata nel 1478 e rimaneggiata nel 1588 , quando l\u2019Abate Alessandro Farnese dette impulso a una profonda ristrutturazione urbanistica della citt\u00e0. Cess\u00f2 di essere chiesa parrocchiale nel 1790, quando venne consacrata la nuova ed attuale Cattedrale. Pass\u00f2 al demanio e poi al Comune. L\u2019esterno presenta semplici strutture in pietra, mentre l\u2019interno \u00e8 ormai quasi spoglio. All\u2019interno , sulla parete dove era l\u2019abside c\u2019\u00e8 uno stemma comunale in marmo , il soffitto restaurato come in origine a mattoni dipinti di bianco e celeste. Affiorano pochi frammenti di affreschi e due croci. Sullo stesso lato un affresco probabile del battesimo di Ges\u00f9\r\n\r\nLa sala si apre su Piazza Garibaldi con palazzo vescovile con il suo ingresso medievale e la torre dell\u2019orologio simbolo della citt\u00e0.\r\n\r\nL\u2019orologio Antico\r\n\u00e8 una macchina unica, originale. E\u2019 uno dei pochi esemplari costruiti interamente a mano realizzato con ferro forgiato e bollito lavorato con lima e seghetto. La sua forma a \u201cpollaio\u201d costruita circa tra 1650\/1680 \u00e8 composta da tre treni e cilindri: i movimenti, suoneria ore e quarti. L\u2019orologio antico e il suo sistema di pesi andr\u00e0 ripulito[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner css=\".vc_custom_1651848833502{padding-right: 10px !important;padding-left: 10px !important;}\" el_class=\"altre-informazioni_app\"][vc_column_inner][vc_empty_space height=\"25px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FSala%2BFarnese%2F%4042.2644622%2C12.6828089%2C21z%2Fdata%3D!4m22!1m15!4m14!1m6!1m2!1s0x132f0ee62f010f87%3A0xefbad483e0df959a!2sPoggio%2BMirteto%2C%2BRI!2m2!1d12.6876246!2d42.2682668!1m6!1m2!1s0x132f0eef6d2a1dcb%3A0xdae174297112bff8!2sPiazza%2BGiuseppe%2BGaribaldi%2C%2B1%2C%2B02047%2BPoggio%2BMirteto%2C%2BRI!2m2!1d12.6828447!2d42.2644386!3m5!1s0x132f0fcb0aa7bab5%3A0xac56f3df8ee34a16!8m2!3d42.2643798!4d12.6829752!16s%252Fg%252F11gntrbydf%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][vc_empty_space height=\"25px\"][vc_column_text]\r\n<h2>Audio<strong>guida<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][zoomsounds_player source=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/Audioguida_Sala_Farnese_1.mp3\" type=\"audio\" artistname=\"San Giovanni\" songname=\"Audioguida\" wrapper_image_type=\"zoomsounds-wrapper-bg-center\"][\/zoomsounds_player][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Sala <strong>Farnese<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1658909523686{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Piazza Giuseppe Garibaldi, 1\r\n02047 \u2013 <strong>Poggio Mirteto\u00a0<\/strong>(RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1651841472116{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Sempre aperto[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contatti<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695633490251{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]\r\n<p style=\"font-size: 11px; font-weight: 400; line-height: 16px;\">Per informazioni e disponibilit\u00e0 di eventuali visite guidate, contatta l\u2019InfopPoint di GeoSabina cliccando sul bottone:<\/p>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text el_class=\"bottone-info\"]\r\n\r\n[popup_trigger id=\"8101\" tag=\"pulsante contatta GeoSabina\"]Contatta l'InfoPoint[\/popup_trigger]\r\n\r\n[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]E\u2019 la prima chiesa dentro le mura della citt\u00e0 costruita forse in un ex posto di guardia accanto al Palazzo abbaziale. Consacrata nel 1478, fu dedicata prima a S. Maria Assunta, in seguito chiesa della SS. Trinit\u00e0; attualmente \u00e8 chiamata sala Farnese ed \u00e8 propriet\u00e0 del Comune che la utilizza come sala polivalente. Della primitiva chiesa rimangono visibili l\u2019abside, tracce murarie delle cappelle laterali e pochi residui di affreschi alle pareti. Il campanile oggi La torre dell\u2019orologio \u00e8 il risultato di una trasformazione avvenuta nel corso dei secoli: nata a difesa della Porta detta di \u201csopra\u201d all\u2019origine la torre merlata \u00e8 circondata da due torrioni di cui oggi sono visibili solo i basamenti.\r\n\r\nAlla fine del 1500 con la costruzione del nuovo sistema difensivo, con relative mura e porte la torre viene sopraelevata creando uno spazio per ospitare le campane della chiesa di San Paolo, e trasformata in torre dell\u2019orologio. In detta sopraelevazione viene creata una monofora per ciascun lato per dare visibilit\u00e0 alle campane, bordata da una coppia di lesene in mattoncini; a coronamento un elegante calotta ottagonale con copertura in piombo. Sulle facciate interne, due quadranti in marmo bianco di forma circolare\r\n\r\nL\u2019edificio sembra sia stato ricavato dai locali adibiti a posto di guardia di Porta Romana.\r\n\r\nVenne consacrata nel 1478 e rimaneggiata nel 1588 , quando l\u2019Abate Alessandro Farnese dette impulso a una profonda ristrutturazione urbanistica della citt\u00e0. Cess\u00f2 di essere chiesa parrocchiale nel 1790, quando venne consacrata la nuova ed attuale Cattedrale. Pass\u00f2 al demanio e poi al Comune. L\u2019esterno presenta semplici strutture in pietra, mentre l\u2019interno \u00e8 ormai quasi spoglio. All\u2019interno , sulla parete dove era l\u2019abside c\u2019\u00e8 uno stemma comunale in marmo , il soffitto restaurato come in origine a mattoni dipinti di bianco e celeste. Affiorano pochi frammenti di affreschi e due croci. Sullo stesso lato un affresco probabile del battesimo di Ges\u00f9\r\n\r\nLa sala si apre su Piazza Garibaldi con palazzo vescovile con il suo ingresso medievale e la torre dell\u2019orologio simbolo della citt\u00e0.\r\n\r\nL\u2019orologio Antico\r\n\u00e8 una macchina unica, originale. E\u2019 uno dei pochi esemplari costruiti interamente a mano realizzato con ferro forgiato e bollito lavorato con lima e seghetto. La sua forma a \u201cpollaio\u201d costruita circa tra 1650\/1680 \u00e8 composta da tre treni e cilindri: i movimenti, suoneria ore e quarti. L\u2019orologio antico e il suo sistema di pesi andr\u00e0 ripulito[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Sala Farnese","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/sala-farnese\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sala Farnese\" width=\"300\" height=\"300\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/07\/salafarnese-300x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1651848833502{padding-right: 10px !important;padding-left: 10px !important;}.vc_custom_1658909523686{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1651841472116{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695633490251{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":476,\"to_translate\":{\"en\":476}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Piazza Giuseppe Garibaldi, 1, 02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2644386","%_wpgmp_metabox_longitude%":"12.6828447","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_thumbnail_id%":"6602","%_dp_original%":"4070","%_edit_lock%":"1702121650:6","%_edit_last%":"6","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Sala Farnese","%_yoast_wpseo_metadesc%":"E\u2019 la prima chiesa dentro le mura della citt\u00e0 costruita forse in un ex posto di guardia accanto al Palazzo abbaziale. Consacrata nel 1478, fu dedicata prima a S. Maria Assunta,.","%_yoast_wpseo_linkdex%":"65","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Poggio Mirteto","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png"},"id":6600,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png","name":"Borghi e Centri Storici \/ Villages and Historical Towns","id":"2","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Torre dell\u2019Orologio","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Torre dell\u2019Orologio\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/11\/torre_orologio_poggio_1024-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/torre-dellorologio\/\" class=\"fc-post-link\">Torre dell\u2019Orologio<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Piazza Mario Dottori, 11\/12, 02047 Poggio Mirteto RI, Italia","location":{"lat":"42.2644204","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6829503","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/torre-dellorologio\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]La <strong>Torre dell\u2019Orologio<\/strong> di Poggio Mirteto \u00e8 contemporanea alla pi\u00f9 antica cinta muraria della citt\u00e0, e quindi databile intorno alla met\u00e0 del 200.In origine costituiva l\u2019elemento centrale delle fortificazioni di Porta Romana, di cui era parte integrante in quanto essa si apriva proprio nel suo corpo.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner][vc_column_inner][vc_empty_space height=\"25px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.com%2Fmaps%2Fdir%2F%2F''%2F%4042.2644786%2C12.647931%2C13z%2Fdata%3D!4m9!4m8!1m0!1m5!1m1!1s0x132f0f646289c9df%3A0x66cb504c5a1c41b6!2m2!1d12.6829503!2d42.2644204!3e0|target:_blank\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Torre dell\u2019<strong>Orologio<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1658908652959{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Piazza Mario Dottori, 11-12\r\n02047 <strong>Poggio Mirteto\u00a0<\/strong>(RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1702549905832{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]non visitabile all'interno[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contatti<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1651913531616{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Tel.<\/strong>\r\n<strong>Mail:<\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]La <strong>Torre dell\u2019Orologio<\/strong> di Poggio Mirteto \u00e8 contemporanea alla pi\u00f9 antica cinta muraria della citt\u00e0, e quindi databile intorno alla met\u00e0 del 200.In origine costituiva l\u2019elemento centrale delle fortificazioni di Porta Romana, di cui era parte integrante in quanto essa si apriva proprio nel suo corpo.\r\n\r\nSub\u00ec una prima ristrutturazione nel 1487, quando divenne torre campanaria della SS. Trinit\u00e0 , ed in quella occasione accolse le antiche campane tolte dal campanile di San Paolo.[\/vc_column_text][vc_empty_space height=\"40px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"4\" slider_loop=\"yes\" slider_autoplay=\"yes\" slider_navigation=\"yes\" slider_pagination=\"yes\" images=\"6576,6578,6580,6582,7198,6584\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_column_text]Tra il 1566 e il 1588 sub\u00ec ulteriori restauri e si volle dotarla di un orologio il cui meccanismo era azionato da pesi; per far posto a tali pesi fu necessario chiudere l\u2019antica Porta Romana.[\/vc_column_text][vc_row_inner el_class=\"video_app\"][vc_column_inner][vc_empty_space height=\"25px\"][vc_column_text]\r\n<h2><strong>Video<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][vc_video link=\"https:\/\/youtu.be\/yS0G_kCocTc?si=s_LO4TRlK9GEXS61\"][vc_empty_space height=\"25px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Torre dell\u2019Orologio","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/torre-dellorologio\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Torre dell\u2019Orologio\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/11\/torre_orologio_poggio_1024-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1658908652959{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1702549905832{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1651913531616{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":244,\"to_translate\":{\"en\":244}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Piazza Mario Dottori, 11\/12, 02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2644204","%_wpgmp_metabox_longitude%":"12.6829503","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_dp_original%":"4399","%_edit_lock%":"1708016857:4","%_edit_last%":"6","%_oembed_4c90539eacbca4711b6973a0a7492e17%":"<iframe title=\"La bella Fiorana, Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/ToxL7oTJaZI?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_4c90539eacbca4711b6973a0a7492e17%":"1658908615","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Torre dell'Orologio Poggio Mirteto","%_yoast_wpseo_title%":"Torre dell'Orologio %%sep%% Poggio Mirteto","%_yoast_wpseo_linkdex%":"63","%_thumbnail_id%":"7212","%_yoast_wpseo_metadesc%":"La Torre dell\u2019Orologio di Poggio Mirteto \u00e8 contemporanea alla pi\u00f9 antica cinta muraria della citt\u00e0, e quindi databile intorno alla met\u00e0 del 200.","%_oembed_3d3bb15660616d49f0a91b24030f2fe1%":"<iframe title=\"La leggenda della bella Fiorana   Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/yS0G_kCocTc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_3d3bb15660616d49f0a91b24030f2fe1%":"1693843987","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/monumenti_sito.png"},"id":6572,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/monumenti_sito.png","name":"Monumenti \/ Monuments","id":"8","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Villa Romana detta Bagni di Lucilla","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Villa Romana detta Bagni di Lucilla\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/lucilla-1024-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/villa-romana-detta-bagni-di-lucilla\/\" class=\"fc-post-link\">Villa Romana detta Bagni di Lucilla<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Via Efisina, 7, 02047 Poggio Mirteto RI, Italia","location":{"lat":"42.271322","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6936439","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/villa-romana-detta-bagni-di-lucilla\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]Il rinvenimento di una tegola con impresso il bollo : <strong>DOMIT PFLVCILL T\u2019EPRCOS,<\/strong> fece ritenere che la villa fosse appartenuta a Lucilla, l\u2019imperatrice figlia di Marco Aurelio, sposata a Lucio Vero, uccisa nel 186 da suo fratello Lucio Commodo nell\u2019isola di Capri.\r\n\r\nLa villa fu oggetto di successivi scavi, <strong>che portarono al rinvenimento di una statuetta di Diana Efesina ed un martelletto per la messa in opera delle tessere di un mosaico<\/strong>. E\u2019 controversa e misteriosa la provenienza di tale mosaico che mostra Diana Efesina (corrispondente ad Artemide dell\u2019isola di Efeso) incoronata e dalle molte mammelle, eretta al centro di un serto di lauro, l\u2019aquila che la sovrasta e che trattiene tra gli artigli delle folgori, simboli sacri del fuoco, le figure allegoriche e mistiche poste attorno, alberi ed uccelli, simboleggianti la potenza generatrice della natura governata dalla dea.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner][vc_column_inner][vc_empty_space height=\"25px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FVia%2BEfisina%2C%2B7%252F21%2C%2B02047%2BSan%2BValentino%2BRI%2F%4042.2713099%2C12.6911162%2C17z%2Fdata%3D!3m1!4b1!4m5!3m4!1s0x132f0edef9127f71%3A0xa51dccf161fd2149!8m2!3d42.271306!4d12.6936911%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Villa Romana detta <strong>\"Bagni di Lucilla\"<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1652137984626{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Efisina, 7-21\r\n02047 San Luigi <strong>Poggio Mirteto<\/strong> (RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1652138017844{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Non definito[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contattaci<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695634222578{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]\r\n<p style=\"font-size: 11px; font-weight: 400; line-height: 16px;\">Per informazioni e disponibilit\u00e0 di eventuali visite guidate, contatta l\u2019InfopPoint di GeoSabina cliccando sul bottone:<\/p>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text el_class=\"bottone-info\"]\r\n\r\n[popup_trigger id=\"8101\" tag=\"pulsante contatta GeoSabina\"]Contatta l'InfoPoint[\/popup_trigger]\r\n\r\n[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Il rinvenimento di una tegola con impresso il bollo : <strong>DOMIT PFLVCILL T\u2019EPRCOS,<\/strong> fece ritenere che la villa fosse appartenuta a Lucilla, l\u2019imperatrice figlia di Marco Aurelio, sposata a Lucio Vero, uccisa nel 186 da suo fratello Lucio Commodo nell\u2019isola di Capri.\r\n\r\nLa villa fu oggetto di successivi scavi, <strong>che portarono al rinvenimento di una statuetta di Diana Efesina ed un martelletto per la messa in opera delle tessere di un mosaico<\/strong>. E\u2019 controversa e misteriosa la provenienza di tale mosaico che mostra Diana Efesina (corrispondente ad Artemide dell\u2019isola di Efeso) incoronata e dalle molte mammelle, eretta al centro di un serto di lauro, l\u2019aquila che la sovrasta e che trattiene tra gli artigli delle folgori, simboli sacri del fuoco, le figure allegoriche e mistiche poste attorno, alberi ed uccelli, simboleggianti la potenza generatrice della natura governata dalla dea.[\/vc_column_text][vc_column_text]La villa si sviluppa su una superficie di circa un ettaro, costituita da una piattaforma sostenuta su tre lati da potenti mura con contrafforti in opus reticulatum. Un complesso sistema di acquedotti provenienti dal Monte San Cosimo alimentava la villa di copiose acque.[\/vc_column_text][vc_empty_space height=\"25px\"][vc_row_inner el_class=\"video_app\"][vc_column_inner][vc_empty_space height=\"25px\"][vc_column_text]\r\n<h2><strong>Video<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=Oxd5iDkMOOc\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Villa Romana detta Bagni di Lucilla","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/villa-romana-detta-bagni-di-lucilla\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Villa Romana detta Bagni di Lucilla\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/lucilla-1024-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1652137984626{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1652138017844{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695634222578{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":274,\"to_translate\":{\"en\":274}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Efisina, 7, 02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.271322","%_wpgmp_metabox_longitude%":"12.6936439","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_dp_original%":"4527","%_edit_lock%":"1702121733:6","%_edit_last%":"6","%_oembed_9b9c47394d1fbb521e3fc839fedabaaa%":"<iframe title=\"I Casoni e i Bagni di Lucilla, Montopoli di Sabina e Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/rMl9W-sSIvo?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_9b9c47394d1fbb521e3fc839fedabaaa%":"1660335745","%_yoast_wpseo_focuskw%":"Villa Romana detta Bagni di Lucilla","%_yoast_wpseo_metadesc%":"Il rinvenimento di una tegola con impresso il bollo : DOMIT PFLVCILL T\u2019EPRCOS, fece ritenere che la villa fosse appartenuta a Lucilla.","%_yoast_wpseo_linkdex%":"62","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_0cff8a66b85ed10fbe945d0e378a03c6%":"<iframe title=\"Casoni e Bagni di Lucilla\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/Oxd5iDkMOOc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_0cff8a66b85ed10fbe945d0e378a03c6%":"1694092317","%_thumbnail_id%":"7828","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Poggio Mirteto","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/archeologia_sito.png"},"id":4599,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/archeologia_sito.png","name":"Siti Archeologici \/ Archeological Sites","id":"13","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Municipio di Poggio Mirteto","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Municipio di Poggio Mirteto\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/Minucipio_poggio_mirteto.1024_576-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/municipio-di-poggio-mirteto\/\" class=\"fc-post-link\">Municipio di Poggio Mirteto<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Piazza Martiri della Libert\u00e0, 40, 02047 Poggio Mirteto RI, Italia","location":{"lat":"42.26445183153405","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.683873233694829","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/municipio-di-poggio-mirteto\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]L\u2019edificio originario del municipio di Poggio Mirteto, che si trova in Piazza Martiri ella Libert\u00e0, \u00a0risale alla fine del Cinquecento, ed aveva solo due piani; poi, nei primi anni del Settecento venne aggiunto un piano e ancora un altro alla fine dell\u2019Ottocento.\r\n\r\n[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-sm vc_hidden-xs\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner][vc_column_inner][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FComune%2BDi%2BPoggio%2BMirteto%2F%4042.2645322%2C12.6843945%2C20.5z%2Fdata%3D!4m6!3m5!1s0x132f0eef47bbeb93%3A0x65a394f287fe7819!8m2!3d42.2644455!4d12.6838721!16s%252Fg%252F1tl_19jf%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"25px\"][\/vc_column][vc_column width=\"2\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][\/vc_column_inner][\/vc_row_inner][vc_column_text]\r\n<h2>Municipio di <strong>Poggio Mirteto<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1694421484368{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Piazza Martiri della Libert\u00e0, 40\r\n02047 San Luigi <strong>Poggio Mirteto<\/strong> (RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1652137753944{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Non definito[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contatti<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1651910896780{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Tel.<\/strong>\r\n<strong>Mail:<\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]L\u2019edificio originario risale alla fine del Cinquecento, ed aveva solo due piani; poi, nei primi anni del Settecento venne aggiunto un piano e ancora un altro alla fine dell\u2019Ottocento.\r\n\r\nSono ancora evidenti i vari periodi di ristrutturazione: il piano terra e il secondo rappresentano la costruzione originaria tardo-cinquecentesca, mentre le bugnature e le teste leonine risalgono probabilmente ad un rifacimento del Seicento. Al terzo piano due scudetti ai lati della finestra centrale sono stati realizzati negli anni \u201920, quello di destra contiene lo stemma comunale.\r\n\r\nA sinistra del balcone vediamo la lapide in memoria di Vittorio Emanuele II , \u201cPadre della Patria\u201d. A destra del balcone c\u2019\u00e8 la lapide commemorativa dei caduti delle guerre di indipendenza dal 1848 al 1877. Altre lapidi ci ricordano : la commemorazione di Andrea Costa, promotore di moti insurrezionali, anarchico e seguace di Bakunin, fu inoltre tra i fondatori del Partito dei Lavoratori Italiani. La lapide in basso a sinistra, \u00a0Felice Cavallotti e Matteo Renato Imbriani che nel 1898 affermavano nuovi ideali di libert\u00e0.[\/vc_column_text][vc_column_text]Ai lati della balaustra del balcone al secondo piano , vi \u00e8 una sola palla di marmo, l\u2019altra \u00e8 andata distrutta; da qui il nome di Pallarotta dato ad uno degli spazi dove sorgeva la vetreria. All\u2019interno del palazzo sul pianerottolo della prima rampa di scale,, \u00e8 infissa sulla parete una lastra di calcare che \u00e8 il pi\u00f9 antico stemma esistente di Poggio Mirteto, datato 1689; la dicitura LETTER- LA POSTA doveva indicare non l\u2019attuale servizio postale , ma la \u201cposta dei cavalli\u201d.[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Municipio di Poggio Mirteto","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/municipio-di-poggio-mirteto\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Municipio di Poggio Mirteto\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/Minucipio_poggio_mirteto.1024_576-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1694421484368{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1652137753944{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1651910896780{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":371,\"to_translate\":{\"en\":371}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Piazza Martiri della Libert\u00e0, 40, 02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.26445183153405","%_wpgmp_metabox_longitude%":"12.683873233694829","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_dp_original%":"4527","%_edit_lock%":"1702286708:4","%_edit_last%":"4","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Municipio Piazza Martiri della libert\u00e0","%_yoast_wpseo_metadesc%":"L\u2019edificio del municipio risale alla fine del Cinquecento, ed aveva solo due piani; poi, nei primi anni del Settecento venne aggiunto un piano e ancora un altro alla fine dell\u2019Ottocento.","%_yoast_wpseo_linkdex%":"54","%_thumbnail_id%":"7682","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Poggio Mirteto","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dimore-storiche_sito.png"},"id":4594,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dimore-storiche_sito.png","name":"Dimore Storiche \/ Historic Houses","id":"5","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Chiesa Santa Maria della Piet\u00e0","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chiesa Santa Maria della Piet\u00e0\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/chiesa-della-pieta-1024x576-1-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/chiesa-santa-maria-della-pieta\/\" class=\"fc-post-link\">Chiesa Santa Maria della Piet\u00e0<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Via Circonvallazione, 3, 02047 Castel San Pietro RI, Italia","location":{"lat":"42.2566424","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.7163829","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/chiesa-santa-maria-della-pieta\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]La chiesa Chiesa della Vergine della Piet\u00e0 o di San Pietro <strong>situata nel bellissimo bordo di Castel San Pietro<\/strong> (Poggio Mirteto) era dedicata a San Pietro, di qui forse l\u2019origine del nome del borgo, poi venne dedicata alla Vergine della Piet\u00e0[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner][vc_column_inner][vc_empty_space height=\"25px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FSanta%2BMaria%2Bdella%2BPiet%25C3%25A0%2F%4042.256279%2C12.7167997%2C19z%2Fdata%3D!4m15!1m8!3m7!1s0x132f09347dbe32ab%3A0xbaabf5d3f94f98ca!2sVia%2BCirconvallazione%2C%2B3%2C%2B02047%2BCastel%2BSan%2BPietro%2BRI!3b1!8m2!3d42.2566424!4d12.7163829!16s%252Fg%252F11c22689y8!3m5!1s0x132f09347d54a923%3A0xa755551ee5e0ad3b!8m2!3d42.2564649!4d12.7164125!16s%252Fg%252F11ckwbl8x2%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Chiesa Santa <strong>Maria della Piet\u00e0<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1652135522140{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Circonvallazione, 3\r\n02047 Castel San Pietro <strong>Poggio Mirteto<\/strong> (RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1652134046708{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Non definito[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contattaci<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695630914953{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]\r\n<p style=\"font-size: 11px; font-weight: 400; line-height: 16px;\">Per informazioni e disponibilit\u00e0 di eventuali visite guidate, contatta l\u2019InfopPoint di GeoSabina cliccando sul bottone:<\/p>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text el_class=\"bottone-info\"]\r\n\r\n[popup_trigger id=\"8101\" tag=\"pulsante contatta GeoSabina\"]Contatta l'InfoPoint[\/popup_trigger]\r\n\r\n[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]La chiesa Chiesa della Vergine della Piet\u00e0 o di San Pietro <strong>situata nel bellissimo bordo di Castel San Pietro<\/strong> (Poggio Mirteto) era dedicata a San Pietro, di qui forse l\u2019origine del nome del borgo, poi venne dedicata alla Vergine della Piet\u00e0.\r\n\r\nLa facciata, piuttosto spoglia, si presenta in forme tardo barocche, e risulta leggermente concava. L\u2019interno ad unica navata, presenta anch\u2019esso un certo movimentato impianto.[\/vc_column_text][vc_empty_space height=\"25px\"][vc_column_text]La pala d\u2019altare \u00e8 una tela sei-settecentesca raffigurante una deposizione. Al di sopra della pittura, compare la scritta: \u201cALTARE PRIVILEGIATUM\u201d, avvertendo quindi che a questo altare sono concesse particolari indulgenze.\r\n\r\nNella seconda cappella a destra troviamo una tela con S. Biagio, mentre nella prima cappella, sempre a destra, un moderno Crocifisso nasconde parzialmente una lapide del 1605 dedicata alla Beata Maria Vergine del Rosario.[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Chiesa Santa Maria della Piet\u00e0","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/chiesa-santa-maria-della-pieta\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chiesa Santa Maria della Piet\u00e0\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/chiesa-della-pieta-1024x576-1-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1652135522140{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1652134046708{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695630914953{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":256,\"to_translate\":{\"en\":256}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Circonvallazione, 3, 02047 Castel San Pietro RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2566424","%_wpgmp_metabox_longitude%":"12.7163829","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"4\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_dp_original%":"4532","%_edit_lock%":"1702549125:6","%_edit_last%":"6","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Chiesa Santa Maria della Piet\u00e0","%_yoast_wpseo_metadesc%":"La chiesa Santa Maria della Piet\u00e0 si trova nel bellissimo bordo di Castel San Pietro (Poggio Mirteto)","%_yoast_wpseo_linkdex%":"64","%_thumbnail_id%":"7717","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Castel San Pietro","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png"},"id":4552,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png","name":"Chiese e Santuari \/ Churches and Sanctuaries","id":"4","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Museo Arti e Mestieri","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Museo Arti e Mestieri\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/foto-1-1-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/museo-arti-e-mestieri\/\" class=\"fc-post-link\">Museo Arti e Mestieri<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Via Antonio Gramsci, 2, 02047 Poggio Mirteto RI, Italia","location":{"lat":"42.26720599999999","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6854463","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/museo-arti-e-mestieri\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]Il Museo Arti e Mestieri, conosciuto anche come\u00a0 collezioni Guardati e Vulpiani sono due collezioni di arte popolare e artigianato locale, conservate nel Museo Civico di Poggio Mirteto, donate dai due collezionisti, Fabrizio Guardati e Antonio Vulpiani[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner][vc_column_inner][vc_empty_space height=\"25px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FMuseo%2BArti%2Be%2BMestieri%2F%4042.2674233%2C12.6858769%2C19.75z%2Fdata%3D!4m20!1m13!4m12!1m4!2m2!1d12.6779392!2d42.2641664!4e1!1m6!1m2!1s0x132f0ee6f57581db%3A0xe88fc88750d4be7f!2sVia%2BAntonio%2BGramsci%2C%2B2%2C%2B02047%2BPoggio%2BMirteto%2BRI!2m2!1d12.6854463!2d42.267206!3m5!1s0x132f0ee65f165ecb%3A0xee325abccaf116ef!8m2!3d42.2675961!4d12.6864834!16s%252Fg%252F11gg4st9mm%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Museo <strong>Arti e Mestieri<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1652135176069{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Antonio Gramsci, 2\r\n02047 <strong>Poggio Mirteto<\/strong> (RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695196076828{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Tutti i <strong>sabato<\/strong>, <strong>domenica<\/strong> e <strong>festivi;<\/strong>\r\n<strong>10:00<\/strong> -<strong>13:00<\/strong> e <strong>17:00<\/strong> -<strong>19:00<\/strong>[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contatti<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695196204340{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Tel. <\/strong>0765405231\r\n<strong>Mail: <\/strong>settore1@comune.poggiomirteto.ri.it\r\n<strong>Referente<\/strong>: Dott. Andrea Leopaldi[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Il Museo Arti e Mestieri,conosciuto anche come\u00a0 collezioni Guardati e Vulpiani sono due collezioni di arte popolare e artigianato locale, conservate nel Museo Civico di Poggio Mirteto, donate dai due collezionisti, Fabrizio Guardati e Antonio Vulpiani.Il primo di loro ha donato circa 2.000 oggetti, tra cui mobili, tessuti, ceramiche, strumenti musicali e oggetti di uso quotidiano.La collezione Vulpiani,invece, \u00e8 composta da circa 1.000 oggetti, tra cui attrezzi agricoli, strumenti da lavoro, utensili domestici e oggetti vari.\r\nL'insieme di questi oggetti formano un importante patrimonio culturale per il paese, descrivendone la vita quotidiana delle persone che hanno vissuto in sabina.\r\nLa collezione di Fabrizio Guardati \u00e8 stata raccolta nel corso di oltre 40 anni ed \u00e8 composta da pezzi unici come ad esempio:\r\nUn letto a baldacchino in legno di cipresso del XVII secolo, proveniente da un palazzo signorile.\r\nUn tavolo in legno di noce del XVIII secolo, proveniente da un'antica osteria.\r\nUn telaio per la tessitura del lino del XIX secolo.\r\nUna serie di strumenti musicali popolari, risalenti al XIX-XX secolo.\r\nLa collezione Vulpiani \u00e8 stata raccolta da Antonio Vulpiani nel corso di oltre 30 anni, un appassionato di storia e cultura locale che ha donato pezzi unici come:\r\nUn aratro in legno e ferro del XVIII secolo.\r\nUn mulino a mano in legno del XIX secolo.\r\nUn telaio per la tessitura della lana del XIX secolo.\r\nTutti gli oggetti descritti sopra si trovano nel museo civile di Poggio Mirteto che tiene in mostra le collezioni al pubblico in maniera gratuita.[\/vc_column_text][vc_empty_space height=\"40px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"4\" slider_loop=\"yes\" slider_autoplay=\"yes\" slider_navigation=\"yes\" slider_pagination=\"yes\" images=\"8035,8037,8039,8041\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_column_text]Un magnifico torchio per la lavorazione dell\u2019olivo \u00e8 interamente realizzato in legno, ed \u00e8 del 1800. Uno dei\u201dpezzi\u201d pi\u00f9 notevoli \u00e8 il meccanismo di un orologio da campanile del 1894, perfettamente funzionante. Ancora, \u201cLa Farmacia del Dr.Laus\u201d, comprende contenitori, vasi e flaconi in vetro, realizzati nella Vetreria Faiella di Poggio Mirteto.[\/vc_column_text][vc_row_inner el_class=\"video_app\"][vc_column_inner offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_empty_space height=\"25px\"][vc_column_text]\r\n<h2><strong>Video<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][vc_video link=\"https:\/\/youtu.be\/vF4cAi5cPrU\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Museo Arti e Mestieri","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/museo-arti-e-mestieri\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Museo Arti e Mestieri\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/foto-1-1-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1652135176069{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695196076828{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695196204340{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":446,\"to_translate\":{\"en\":446}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Antonio Gramsci, 2, 02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.26720599999999","%_wpgmp_metabox_longitude%":"12.6854463","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"9\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_dp_original%":"4542","%_edit_lock%":"1702551562:6","%_edit_last%":"6","%_thumbnail_id%":"8033","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Museo Arti e Mestieri","%_yoast_wpseo_metadesc%":"il Museo Arti e Mestieri, conosciuto anche come collezioni Guardati e Vulpiani sono due collezioni di arte popolare e artigianato locale, conservate nel Museo Civico di Poggio Mirteto.","%_yoast_wpseo_linkdex%":"72","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Poggio Mirteto","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/musei_sito.png"},"id":4547,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/musei_sito.png","name":"Musei \/ Museum","id":"9","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Mola di Castel San Pietro","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Mola di Castel San Pietro\" width=\"300\" height=\"150\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/07\/chi-siamo-300x150.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/mola-di-castel-san-pietro\/\" class=\"fc-post-link\">Mola di Castel San Pietro<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Via Dell' Oliveto, 1, 02047 Castel San Pietro RI, Italia","location":{"lat":"42.2568187","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.7181184","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/mola-di-castel-san-pietro\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]La mola di Castel San Pietro \u00e8 un edificio storico risalente al XIII secolo. \u00c8 uno dei pi\u00f9 importanti esempi di archeologia industriale della Sabina, e rappresenta un simbolo della cultura e della storia di questo territorio e si trova lungo il corso del fiume Farfa, in un punto in cui il fiume forma una cascata. L'edificio \u00e8 composto da un'unica stanza, con un'alta volta a botte dove ,al centro della stanza, si trova la macina che \u00e8 alimentata dall'acqua della cascata.\r\nLa mola era utilizzata per la produzione di farina, e rappresentava un'importante risorsa per la popolazione locale. In passato, era gestita da un mugnaio, che era responsabile della macinazione del grano.\r\nRestaurata poi nel 2000, \u00e8 oggi \u00e8 visitabile su prenotazione. Inoltre l'edificio \u00e8 stato inserito tra i beni culturali del Comune di Poggio Mirteto, ed \u00e8 un importante testimonianza della storia e della cultura locale.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner][vc_column_inner][vc_empty_space height=\"25px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FVia%2BDell'%2BOliveto%2C%2B1%2C%2B02047%2BCastel%2BSan%2BPietro%2BRI%2F%4042.2567023%2C12.7174832%2C20z%2Fdata%3D!4m6!3m5!1s0x132f09340a16cbff%3A0xaef9748f97d84b4b!8m2!3d42.2568187!4d12.7181184!16s%252Fg%252F11csf89l8t%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Mola di <strong>Castel San Pietro<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1652134509156{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Dell' Oliveto, 1\r\n02047 Castel San Pietro <strong>Poggio Mirteto<\/strong> (RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1652134046708{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Non definito[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contattaci<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695632502770{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]\r\n<p style=\"font-size: 11px; font-weight: 400; line-height: 16px;\">Per informazioni e disponibilit\u00e0 di eventuali visite guidate, contatta l\u2019InfopPoint di GeoSabina cliccando sul bottone:<\/p>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text el_class=\"bottone-info\"]\r\n\r\n[popup_trigger id=\"8101\" tag=\"pulsante contatta GeoSabina\"]Contatta l'InfoPoint[\/popup_trigger]\r\n\r\n[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]La mola di Castel San Pietro \u00e8 un edificio storico risalente al XIII secolo. \u00c8 uno dei pi\u00f9 importanti esempi di archeologia industriale della Sabina, e rappresenta un simbolo della cultura e della storia di questo territorio e si trova lungo il corso del fiume Farfa, in un punto in cui il fiume forma una cascata. L'edificio \u00e8 composto da un'unica stanza, con un'alta volta a botte dove ,al centro della stanza, si trova la macina che \u00e8 alimentata dall'acqua della cascata.\r\nLa mola era utilizzata per la produzione di farina, e rappresentava un'importante risorsa per la popolazione locale. In passato, era gestita da un mugnaio, che era responsabile della macinazione del grano.\r\nRestaurata poi nel 2000, \u00e8 oggi \u00e8 visitabile su prenotazione. Inoltre l'edificio \u00e8 stato inserito tra i beni culturali del Comune di Poggio Mirteto, ed \u00e8 un importante testimonianza della storia e della cultura locale.[\/vc_column_text][vc_empty_space height=\"40px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"4\" slider_loop=\"yes\" slider_autoplay=\"yes\" slider_navigation=\"yes\" slider_pagination=\"yes\" images=\"4560\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_column_text]La piccola ciminiera in mattoni \u00e8 ancora salda, ed anche i vari corpi di cui si componeva questo frantoio sono ancora in discrete condizioni.\r\n\r\nSu una facciata vi \u00e8 ancora una piccola edicola con Madonna.[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Mola di Castel San Pietro","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/mola-di-castel-san-pietro\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Mola di Castel San Pietro\" width=\"300\" height=\"150\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/07\/chi-siamo-300x150.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1652134509156{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1652134046708{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695632502770{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":92,\"to_translate\":{\"en\":92}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Dell' Oliveto, 1, 02047 Castel San Pietro RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2568187","%_wpgmp_metabox_longitude%":"12.7181184","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_dp_original%":"4532","%_edit_lock%":"1702120371:6","%_edit_last%":"6","%_last_translation_edit_mode%":"native-editor","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"6151","%_yoast_wpseo_focuskw%":"La Mola di Castel San Pietro","%_yoast_wpseo_metadesc%":"La mola di Castel San Pietro \u00e8 uno dei pi\u00f9 importanti esempi di archeologia industriale della Sabina","%_yoast_wpseo_linkdex%":"70","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Poggio Mirteto","%_wp_attachment_metadata%":"","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/archeologia_sito.png"},"id":4538,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/archeologia_sito.png","name":"Siti Archeologici \/ Archeological Sites","id":"13","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Chiesa di Sant\u2019Antonio","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chiesa di Sant\u2019Antonio\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/chiesa-santantonio-1-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/chiesa-di-santantonio\/\" class=\"fc-post-link\">Chiesa di Sant\u2019Antonio<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Via Formello, 7, 02047 Poggio Mirteto RI, Italia","location":{"lat":"42.2492089","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6459685","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/chiesa-di-santantonio\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]\r\n<p data-sourcepos=\"1:1-1:291\">La chiesa di Sant'Antonio di Poggio Mirteto \u00e8 una chiesa cattolica situata nel centro storico della citt\u00e0. Fu costruita nel XVI secolo dai frati francescani, che vi fondarono anche un convento.<\/p>\r\n[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner][vc_column_inner][vc_empty_space height=\"25px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FTenuta%2BS.%2BAntonio%2F%4042.2491717%2C12.645581%2C19.62z%2Fdata%3D!4m15!1m8!3m7!1s0x132f0e72bf8f119b%3A0xf254ab5de568cbd7!2sVia%2BFormello%2C%2B7%2C%2B02047%2BPoggio%2BMirteto%2BRI!3b1!8m2!3d42.2491985!4d12.6459104!16s%252Fg%252F11j318tv91!3m5!1s0x132f0e72bfccb739%3A0x10028be5aed40b15!8m2!3d42.2492488!4d12.6454729!16s%252Fg%252F1tfd__3m%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Chiesa di <strong>Sant\u2019Antonio<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1652134035670{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Formello, 7\r\n02047 <strong>Poggio Mirteto<\/strong> (RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1652134046708{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Non definito[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contattaci<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695632228463{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]\r\n<p style=\"font-size: 11px; font-weight: 400; line-height: 16px;\">Per informazioni e disponibilit\u00e0 di eventuali visite guidate, contatta l\u2019InfopPoint di GeoSabina cliccando sul bottone:<\/p>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text el_class=\"bottone-info\"]\r\n\r\n[popup_trigger id=\"8101\" tag=\"pulsante contatta GeoSabina\"]Contatta l'InfoPoint[\/popup_trigger]\r\n\r\n[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]\r\n<p data-sourcepos=\"1:1-1:291\">La chiesa di Sant'Antonio di Poggio Mirteto \u00e8 una chiesa cattolica situata nel centro storico della citt\u00e0. Fu costruita nel XVI secolo dai frati francescani, che vi fondarono anche un convento. La chiesa \u00e8 dedicata a Sant'Antonio da Padova, uno dei santi pi\u00f9 venerati dalla Chiesa cattolica.<\/p>\r\n<p data-sourcepos=\"3:1-3:199\">L'esterno \u00e8 in stile romanico-gotico, la facciata \u00e8 semplice, con un portale centrale e due finestre laterali. Il campanile \u00e8 a pianta quadrata e si trova sul lato sinistro della chiesa.<\/p>\r\n<p data-sourcepos=\"5:1-5:207\">L'interno\u00a0 \u00e8 a tre navate, separate da pilastri. La navata centrale \u00e8 pi\u00f9 alta delle navate laterali e termina nell'abside. L'abside \u00e8 decorata con affreschi raffiguranti la vita di Sant'Antonio.<\/p>\r\n<p data-sourcepos=\"7:1-7:214\">La chiesa custodisce un'importante opera d'arte, un dipinto di Sant'Antonio da Padova realizzato da un artista della scuola di Pietro Perugino. Il dipinto \u00e8 datato al XVI secolo ed \u00e8 collocato sull'altare maggiore.<\/p>\r\n<p data-sourcepos=\"9:1-9:170\">La chiesa di Sant'Antonio \u00e8 un importante luogo di culto per la citt\u00e0 di Poggio Mirteto. \u00c8 anche un luogo di interesse storico e artistico, che merita di essere visitato.<\/p>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][vc_column_text]Un tempo era la chiesa principale di Poggio Mirteto Scalo, prima della costruzione della moderna chiesa della Sacra Famiglia.[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Chiesa di Sant\u2019Antonio","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/chiesa-di-santantonio\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chiesa di Sant\u2019Antonio\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/chiesa-santantonio-1-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1652134035670{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1652134046708{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695632228463{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":341,\"to_translate\":{\"en\":341}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Formello, 7, 02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2492089","%_wpgmp_metabox_longitude%":"12.6459685","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"4\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_dp_original%":"4527","%_edit_lock%":"1702375800:6","%_edit_last%":"6","%_yoast_wpseo_focuskw%":"Chiesa di Sant'Antonio","%_yoast_wpseo_metadesc%":"La chiesa di Sant'Antonio di Poggio Mirteto \u00e8 una chiesa cattolica situata nel centro storico della citt\u00e0. Fu costruita nel XVI secolo dai frati francescani, che vi fondarono anche un convento. La chiesa \u00e8 dedicata a Sant'Antonio da Padova, uno dei santi pi\u00f9 venerati dalla Chiesa cattolica.","%_yoast_wpseo_linkdex%":"67","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"7756","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Poggio Mirteto","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png"},"id":4532,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png","name":"Chiese e Santuari \/ Churches and Sanctuaries","id":"4","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Vetreria Faiella","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Vetreria Faiella\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/vetreria-1024x576-1-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/vetreria-faiella\/\" class=\"fc-post-link\">Vetreria Faiella<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Piazza Vetreria, 4, 02047 Poggio Mirteto RI, Italia","location":{"lat":"42.265698","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6850651","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/vetreria-faiella\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]Nel comune di Poggio Mirteto,Scendendo per Via S. Paolo si arriva a <strong>Piazza della Vetreria<\/strong>, dominata dall\u2019alta ciminiera ;la prima vetreria industriale in Italia per la produzione di lastre di vetro.Venne iniziata il 6 maggio del 1826[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner css=\".vc_custom_1651848833502{padding-right: 10px !important;padding-left: 10px !important;}\" el_class=\"altre-informazioni_app\"][vc_column_inner][vc_empty_space height=\"25px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fdir%2FPoggio%2BMirteto%2C%2BRI%2FPiazza%2BVetreria%2C%2B4%2C%2B02047%2BPoggio%2BMirteto%2BRI%2F%4042.265748%2C12.6851794%2C21z%2Fdata%3D!4m13!4m12!1m5!1m1!1s0x132f0ee62f010f87%3A0xefbad483e0df959a!2m2!1d12.6876246!2d42.2682668!1m5!1m1!1s0x132f0ee60170d6af%3A0x23eedfb8acca91f0!2m2!1d12.6850801!2d42.2655982%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Vetreria <strong>Faiella<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1652105128503{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Piazza Vetreria, 4\r\n02047 <strong>Poggio Mirteto\u00a0<\/strong>(RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1652104470788{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Non definito[\/vc_column_text][vc_column_text css=\".vc_custom_1651915077990{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"][\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contatti<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1651915086405{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Tel.<\/strong>\r\n<strong>Mail:<\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Nel comune di Poggio Mirteto, scendendo per Via S. Paolo si arriva a <strong>Piazza della Vetreria<\/strong>, dominata dall\u2019alta ciminiera; la prima vetreria industriale in Italia per la produzione di lastre di vetro.\r\n\r\nVenne iniziata il 6 maggio del 1826 e gi\u00e0 nel 1827 produsse le prime lastre. Per qualche tempo produsse anche bicchieri ed altra chincaglieria, ma poi tale ramo produttivo venne abbandonato.[\/vc_column_text][vc_empty_space height=\"40px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"4\" slider_loop=\"yes\" slider_autoplay=\"yes\" slider_navigation=\"yes\" slider_pagination=\"yes\" images=\"8051\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_column_text]Nei momenti di massima attivit\u00e0 arriv\u00f2 ad avere circa 120 operai. Veniva alimentata con sabbie silicee provenienti dalla Sicilia, e per qualche tempo venne utilizzata anche la sabbia proveniente dai sedimenti sottostanti il monte Soratte.\r\n\r\nEntr\u00f2 in crisi agli inizi del Novecento e poco dopo smise di funzionare. Oggi \u00e8 completamente smantellata, mentre in origine l\u2019intero piazzale era occupato dagli edifici della fabbrica.[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Vetreria Faiella","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/vetreria-faiella\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Vetreria Faiella\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/vetreria-1024x576-1-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1651848833502{padding-right: 10px !important;padding-left: 10px !important;}.vc_custom_1652105128503{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1652104470788{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1651915077990{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1651915086405{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":229,\"to_translate\":{\"en\":229}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Piazza Vetreria, 4, 02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.265698","%_wpgmp_metabox_longitude%":"12.6850651","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"13\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_thumbnail_id%":"7815","%_dp_original%":"4429","%_edit_lock%":"1708016372:4","%_edit_last%":"4","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Vetreria Faiella","%_yoast_wpseo_metadesc%":"Scendendo per Via S. Paolo si arriva a Piazza della Vetreria, dominata dall\u2019alta ciminiera ;la prima vetreria industriale in Italia per la produzione di lastre di vetro.","%_yoast_wpseo_linkdex%":"58","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Poggio Mirteto","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/archeologia_sito.png"},"id":4502,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/archeologia_sito.png","name":"Siti Archeologici \/ Archeological Sites","id":"13","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Borgo di Castel San Pietro","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Borgo di Castel San Pietro\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/Castel_san_pietro.wide_-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/borgo-di-castel-san-pietro\/\" class=\"fc-post-link\">Borgo di Castel San Pietro<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Piazza Grande, 13, 02047 Castel San Pietro RI, Italia","location":{"lat":"42.2561462","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.7164232","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/borgo-di-castel-san-pietro\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]Castel San Pietro \u00e8 un piccolo <strong>borgo panoramico<\/strong>, tradizioni locali lo vogliono sorto sui resti di una villa romana attribuita a Diocleziano. La presenza di blocchi calcarei tipicamente romani e la fontana ancora funzionante nei sotterranei del Palazzo Baronale, fanno ritenere valida l\u2019ipotesi che tutta l\u2019area era occupata da un\u2019 imponente villa patrizia. Successivamente Castel San Pietro divenne possesso della Chiesa di Roma, e nel 1449 il Vaticano ne effettu\u00f2 la vendita alla famiglia Orsini. Vari passaggi di propriet\u00e0 ad altre nobili casate, fino al 1706, quando Clemente XI autorizz\u00f2 la vendita a ulteriori terzi per conto di Simone Bonaccorsi. L\u2019attuale palazzo che oggi ne prende il nome \u00e8 di forme cinquecentesche, ma con rimaneggiamenti di varie epoche.\r\n\r\nSul fondo di Piazza Grande inizia il parco del castello, all\u2019interno sorge un monumentale albero di tasso, cui viene attribuita un\u2019et\u00e0 di 500 anni. Da vedere la chiesa di San Pietro, poi dedicata alla Vergine della Piet\u00e0. Nell\u2019altare maggiore la pala dell\u2019altare \u00e8 una tela sei-settecentesca raffigurante una deposizione. La scritta \u201cAltare privilegiatum\u201d avverte che a questo altare sono concesse particolari indulgenze.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][vc_empty_space height=\"25px\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner css=\".vc_custom_1651848833502{padding-right: 10px !important;padding-left: 10px !important;}\" el_class=\"altre-informazioni_app\"][vc_column_inner][vc_empty_space height=\"25\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2F02047%2BCastel%2BSan%2BPietro%2BRI%2F%4042.2558578%2C12.7151664%2C17z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132f093412d43207%3A0xf78f74335ea823aa!8m2!3d42.2565579!4d12.7181804!16s%252Fg%252F1232jn5c%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Borgo di\u00a0<strong>Castel San Pietro<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695035788768{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Piazza Grande, 13,\r\n02047 Castel San Pietro\r\n<strong>Poggio Mirteto\u00a0<\/strong>(RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695035811152{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Sempre aperto[\/vc_column_text][vc_column_text css=\".vc_custom_1651915077990{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"][\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contatti<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1651915086405{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Tel.<\/strong>\r\n<strong>Mail:<\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Castel San Pietro \u00e8 un piccolo <strong>borgo panoramico<\/strong>, tradizioni locali lo vogliono sorto sui resti di una villa romana attribuita a Diocleziano. La presenza di blocchi calcarei tipicamente romani e la fontana ancora funzionante nei sotterranei del Palazzo Baronale, fanno ritenere valida l\u2019ipotesi che tutta l\u2019area era occupata da un\u2019 imponente villa patrizia. Successivamente Castel San Pietro divenne possesso della Chiesa di Roma, e nel 1449 il Vaticano ne effettu\u00f2 la vendita alla famiglia Orsini. Vari passaggi di propriet\u00e0 ad altre nobili casate, fino al 1706, quando Clemente XI autorizz\u00f2 la vendita a ulteriori terzi per conto di Simone Bonaccorsi. L\u2019attuale palazzo che oggi ne prende il nome \u00e8 di forme cinquecentesche, ma con rimaneggiamenti di varie epoche.\r\n\r\nSul fondo di Piazza Grande inizia il parco del castello, all\u2019interno sorge un monumentale albero di tasso, cui viene attribuita un\u2019et\u00e0 di 500 anni. Da vedere la chiesa di San Pietro, poi dedicata alla Vergine della Piet\u00e0. Nell\u2019altare maggiore la pala dell\u2019altare \u00e8 una tela sei-settecentesca raffigurante una deposizione. La scritta \u201cAltare privilegiatum\u201d avverte che a questo altare sono concesse particolari indulgenze.[\/vc_column_text][vc_empty_space height=\"40px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"4\" slider_loop=\"yes\" slider_autoplay=\"yes\" slider_navigation=\"yes\" slider_pagination=\"yes\" images=\"4436,4438,4440,7926\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_column_text]L\u2019unica struttura rimasta integra della cinta muraria \u00e8 la Porta Romana che si apre alla base di un torrione, sec. XIII e XIV.\u00a0Nei dintorni di Castel San Pietro, troviamo la piccola chiesa rurale di San Sebastiano.\u00a0Sorge su ruderi romani di cui resta ben poco, risale all\u2019incirca all\u2019XI sec. e per secoli fu officiata da un monaco eremita.\u00a0Interessante, lungo la strada che porta a S.Sebastiano, una struttura in pietra e in legno di un vecchio lavatoio del 1893.[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Borgo di Castel San Pietro","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/borgo-di-castel-san-pietro\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Borgo di Castel San Pietro\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/Castel_san_pietro.wide_-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1651848833502{padding-right: 10px !important;padding-left: 10px !important;}.vc_custom_1695035788768{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695035811152{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1651915077990{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1651915086405{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":335,\"to_translate\":{\"en\":335}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Piazza Grande, 13, 02047 Castel San Pietro RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2561462","%_wpgmp_metabox_longitude%":"12.7164232","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_thumbnail_id%":"7930","%_dp_original%":"4070","%_edit_lock%":"1707409985:4","%_edit_last%":"6","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Borgo di Castel San Pietro","%_yoast_wpseo_metadesc%":"Castel San Pietro \u00e8 un piccolo borgo panoramico, tradizioni locali lo vogliono sorto sui resti di una villa romana attribuita a Diocleziano.","%_yoast_wpseo_linkdex%":"72","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Poggio Mirteto","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png"},"id":4429,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png","name":"Borghi e Centri Storici \/ Villages and Historical Towns","id":"2","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Chiesa di San Paolo","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chiesa di San Paolo\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/san-paolo-1024-576-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/chiesa-di-san-paolo\/\" class=\"fc-post-link\">Chiesa di San Paolo<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Via Antonio Gramsci, 4, 02047 Poggio Mirteto RI, Italia","location":{"lat":"42.26747","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.686008","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/chiesa-di-san-paolo\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]La <strong>Chiesa di San Paolo di Poggio Mirteto<\/strong> \u00e8 un importante monumento storico-artistico situato ai margini del centro storico del paese. La chiesa risale al XII secolo ed \u00e8 stata oggetto di numerose ristrutturazioni nel corso dei secoli.\r\n\r\nGi\u00e0 nell\u2019anno 1000 viene citata una chiesa di San Paolo, che doveva sorgere nei pressi o, come probabile, sullo stesso sito dell\u2019attuale e quindi successivamente demolita per far posto alla nuova fabbrica.\r\n\r\nGli affreschi e la struttura architettonica fanno risalire la <strong>nascita di tale sito al \u2018200<\/strong>. Nel corso dei secoli sub\u00ec numerosi restauri e modifiche; sulla facciata sono evidenti i segni di un rifacimento, forse costituito da un avancorpo\u00a0 che le era stato appoggiato , per cui l\u2019attuale portale si apriva su un ambiente chiuso, oppure costituito da un ampliamento della chiesa stessa.\r\n\r\nGli affreschi della controfacciata e della parete sinistra, i pi\u00f9 antichi,sembrano risalire al XIV sec., gli affreschi dell\u2019abside portano la data del 1521, mentre gli affreschi della cappella Ippoliti sono del 1621.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner css=\".vc_custom_1651848833502{padding-right: 10px !important;padding-left: 10px !important;}\" el_class=\"altre-informazioni_app\"][vc_column_inner][vc_empty_space height=\"25px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2Fsan%2BPaolo%2F%4042.2674739%2C12.6834331%2C17z%2Fdata%3D!4m15!1m8!3m7!1s0x132f0ee6612e6843%3A0x1aab3c74a0c9dd5!2sVia%2BAntonio%2BGramsci%2C%2B4%2C%2B02047%2BPoggio%2BMirteto%2BRI!3b1!8m2!3d42.26747!4d12.686008!16s%252Fg%252F11c2c39gbf!3m5!1s0x132f0ee67cf998b7%3A0xccf0c73b5f213859!8m2!3d42.267877!4d12.6856061!16s%252Fg%252F12hk5js1m%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Chiesa di <strong>San Paolo<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1651914673124{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Antonio Gramsci, 4\r\n02047 <strong>Poggio Mirteto\u00a0<\/strong>(RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695048630735{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Aperto su prenotazione[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contattaci<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695629914137{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]\r\n<p style=\"font-size: 11px; font-weight: 400; line-height: 16px;\">Per informazioni e disponibilit\u00e0 di eventuali visite guidate, contatta l\u2019InfopPoint di GeoSabina cliccando sul bottone:<\/p>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text el_class=\"bottone-info\"]\r\n\r\n[popup_trigger id=\"8101\" tag=\"pulsante contatta GeoSabina\"]Contatta l'InfoPoint[\/popup_trigger]\r\n\r\n[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]La <strong>Chiesa di San Paolo di Poggio Mirteto<\/strong> \u00e8 un importante monumento storico-artistico situato ai margini del centro storico del paese. La chiesa risale al XII secolo ed \u00e8 stata oggetto di numerose ristrutturazioni nel corso dei secoli.\r\n\r\nGi\u00e0 nell\u2019anno 1000 viene citata una chiesa di San Paolo, che doveva sorgere nei pressi o, come probabile, sullo stesso sito dell\u2019attuale e quindi successivamente demolita per far posto alla nuova fabbrica.\r\n\r\nGli affreschi e la struttura architettonica fanno risalire la <strong>nascita di tale sito al \u2018200<\/strong>. Nel corso dei secoli sub\u00ec numerosi restauri e modifiche; sulla facciata sono evidenti i segni di un rifacimento, forse costituito da un avancorpo\u00a0 che le era stato appoggiato , per cui l\u2019attuale portale si apriva su un ambiente chiuso, oppure costituito da un ampliamento della chiesa stessa.\r\n\r\nGli affreschi della controfacciata e della parete sinistra, i pi\u00f9 antichi,sembrano risalire al XIV sec., gli affreschi dell\u2019abside portano la data del 1521, mentre gli affreschi della cappella Ippoliti sono del 1621.[\/vc_column_text][vc_empty_space height=\"40px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"4\" slider_loop=\"yes\" slider_autoplay=\"yes\" slider_navigation=\"yes\" slider_pagination=\"yes\" images=\"6053,6049,6057,6047,4422,4416,4420,4424,6055\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_column_text]Il campanile \u00e8 a 5 livelli, di cui due con bifore ed un ultimo monoforo. L\u2019interno \u00e8 un\u2019aula semplice in cui lo spazio \u00e8 scandito da 4 arcate a sesto acuto che accennano al gotico, poggianti su pilastrini. In origine non vi erano cappelle laterali, quelle esistenti vennero aggiunte successivamente. \u00a0Nella parte bassa \u00e8 di gran pregio il dipinto \u201c Deposizione di Ges\u00f9 nel sepolcro\u201d. Lo stile assomiglia molto alle maniere di Giotto, manca per\u00f2 l\u2019emozionalit\u00e0 di tutti i volti, ed \u00e8 probabilmente del XVI secolo.[\/vc_column_text][vc_row_inner el_class=\"video_app\"][vc_column_inner][vc_empty_space height=\"25px\"][vc_column_text]\r\n<h2><strong>Video<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=F6JOJ17cFhQ\"][vc_empty_space height=\"50px\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row]","post_title":"Chiesa di San Paolo","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/chiesa-di-san-paolo\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chiesa di San Paolo\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/san-paolo-1024-576-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1651848833502{padding-right: 10px !important;padding-left: 10px !important;}.vc_custom_1651914673124{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695048630735{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695629914137{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":353,\"to_translate\":{\"en\":353}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Antonio Gramsci, 4, 02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.26747","%_wpgmp_metabox_longitude%":"12.686008","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"4\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_thumbnail_id%":"8948","%_dp_original%":"4070","%_edit_lock%":"1702120770:6","%_edit_last%":"6","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Poggio Mirteto","%_yoast_wpseo_focuskw%":"Chiesa di San Paolo","%_yoast_wpseo_metadesc%":"La Chiesa di San Paolo di Poggio Mirteto \u00e8 un importante monumento storico-artistico situato ai margini del centro storico del paese. La chiesa risale al XII secolo ed \u00e8 stata oggetto di numerose ristrutturazioni nel corso dei secoli.","%_yoast_wpseo_linkdex%":"72","%_oembed_ff986bd666cf43d73ae4be5492aad373%":"<iframe title=\"CHIESA SAN PAOLO - Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/F6JOJ17cFhQ?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_ff986bd666cf43d73ae4be5492aad373%":"1695049539","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png"},"id":4411,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png","name":"Chiese e Santuari \/ Churches and Sanctuaries","id":"4","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Santuario della Madonna della Misericordia","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Santuario della Madonna della Misericordia\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/opificio-700-1024-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/santuario-della-madonna-della-misericordia\/\" class=\"fc-post-link\">Santuario della Madonna della Misericordia<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Via Provinciale Stazione, 34, 02047 Misericordia RI, Italia","location":{"lat":"42.2569411","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6731663","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/santuario-della-madonna-della-misericordia\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]Poggio Mirteto,1738, la tradizione che in un bel pomeriggio d\u2019estate Lucia Del Bufalo recitava il suo rosario nel cortile di casa,quando apparve l\u2019immagine della Madonna con il Bambino. Da quel giorno vi fu un grande accorrere di popolo dai dintorni[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\" offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][vc_row_inner][vc_column_inner][vc_empty_space height=\"25px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FMadonna%2Bdella%2BMisericordia%2F%4042.2567892%2C12.6731662%2C21z%2Fdata%3D!4m23!1m16!4m15!1m6!1m2!1s0x132f0ee62f010f87%3A0xefbad483e0df959a!2sPoggio%2BMirteto%2C%2B02047%2BRI!2m2!1d12.6876246!2d42.2682668!1m6!1m2!1s0x132f0e8b55142d43%3A0xbbce8d66cfa9606!2sVia%2BProvinciale%2BStazione%2C%2B34%2C%2B02047%2BMisericordia%2BRI!2m2!1d12.6731663!2d42.2569411!3e0!3m5!1s0x132f0e8b54f365c3%3A0xd54fa75ec0903a63!8m2!3d42.2569384!4d12.6730389!16s%252Fg%252F11ddywjtgm%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner css=\".vc_custom_1651848833502{padding-right: 10px !important;padding-left: 10px !important;}\" el_class=\"altre-informazioni_app\"][vc_column_inner offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]\r\n<h2>Audio<strong>guida<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][zoomsounds_player source=\"#\" type=\"audio\" artistname=\"San Giovanni\" songname=\"Audioguida\" wrapper_image_type=\"zoomsounds-wrapper-bg-center\"][\/zoomsounds_player][vc_empty_space height=\"25px\"][vc_column_text]\r\n<h2>Guida <strong>turistica<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][vc_btn title=\"<strong>DOWNLOAD PDF<\/strong>\" style=\"outline-custom\" outline_custom_color=\"#00b801\" outline_custom_hover_background=\"#009907\" outline_custom_hover_text=\"#ffffff\" shape=\"square\" size=\"lg\" align=\"left\" i_icon_fontawesome=\"fas fa-angle-double-down\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Fwp-content%2Fuploads%2F2022%2F04%2Fguida-it.pdf|title:Scarica%20la%20guida\"][vc_empty_space height=\"25px\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Santuario della <strong>Madonna della Misericordia<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695028288716{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Provinciale Stazione, 34\r\n02047 Misericordia\r\n<strong>Poggio Mirteto\u00a0<\/strong>(RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695028324913{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"][\/vc_column_text][vc_column_text]Messe festive:\r\nOre 18,00; (con <em>l\u2019<strong>ora solare<\/strong><\/em>\u00a0alle 16,00)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contatti<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695292973013{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Il parroco<\/strong>: 0765 201279\r\n<strong>Mail<\/strong>: <a href=\"mailto:mauroguida@alice.it\">mauroguida@alice.it<\/a>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Poggio Mirteto,1738, la tradizione che in un bel pomeriggio d\u2019estate Lucia Del Bufalo recitava il suo rosario nel cortile di casa,quando apparve l\u2019immagine della Madonna con il Bambino. Da quel giorno vi fu un grande accorrere di popolo dai dintorni per venerare la sacra immagine, cosa che non poteva non destare l\u2019attenzione delle autorit\u00e0 ecclesiastiche.\r\n\r\nVenne dunque\u00a0 avviato un regolare processo di \u201cautentica\u201d, in seguito al quale il miracolo venne ufficialmente riconosciuto. Si decise quindi di trovare un luogo dove conservare l\u2019affresco miracoloso, dando cos\u00ec inizio ad una campanilistica diatriba tra Poggio Mirteto e i comuni vicini. La contesa venne risolta con la decisione di erigere una cappella sul luogo esatto del miracolo, e cos\u00ec avvenne.\r\n\r\nProgetto e costruzione vennero affidati all\u2019architetto Angelo Sani\u00a0 nel 1741; la chiesa fu ultimata nelle strutture principali nel 1748 e consacrata a ottobre dello stesso anno. La struttura esterna \u00e8 molto semplice ma armoniosa, movimentata solo dal garbato campanile.[\/vc_column_text][vc_column_text]All\u2019interno sulla parete di sinistra, una Deposizione affrescata e sullo stesso lato vicino all\u2019altare un affresco della Visitazione di S.Elisabetta. Sulla parete dell\u2019altare , in una nicchia protetta da vetro, l\u2019affresco del miracolo, dipinto di scuola umbra del XV-XVI sec., rappresenta la Madonna con il Bambino e sotto S.Antonio Abate.\r\n\r\nSull\u2019altare dell\u2019ultima cappella a destra, olio su tela con l\u2019Annunciazione di Maria. Ancora da notare sul soffitto, un grande affresco riproducente l\u2019evento miracoloso di Lucia Del Bufalo davanti la Sacra Immagine, con alcune persone accorse alle sue grida di stupore.[\/vc_column_text][vc_empty_space height=\"30px\"][vc_row_inner][vc_column_inner][vc_text_separator title=\"CURIOSITA'\" i_icon_fontawesome=\"fas fa-question\" i_color=\"custom\" i_background_style=\"rounded\" i_background_color=\"green\" i_size=\"xs\" title_align=\"separator_align_left\" align=\"align_left\" color=\"custom\" border_width=\"2\" add_icon=\"true\" accent_color=\"#81d742\" i_custom_color=\"#ffffff\"][vc_column_text css=\".vc_custom_1695292413459{margin-top: 6px !important;border-top-width: 0px !important;border-right-width: 2px !important;border-bottom-width: 2px !important;border-left-width: 2px !important;padding-top: 0px !important;padding-right: 16px !important;padding-bottom: 16px !important;padding-left: 16px !important;border-left-color: #81d742 !important;border-left-style: solid !important;border-right-color: #81d742 !important;border-right-style: solid !important;border-top-color: #81d742 !important;border-top-style: solid !important;border-bottom-color: #81d742 !important;border-bottom-style: solid !important;}\"]\r\n<h4><b>L'Opificio settecentesco<\/b><\/h4>\r\nScendendo sulla provinciale stazione ,di fronte a questa antica chiesa \u00e8 situato l' Opificio settecentesco di Poggio Mirteto.\r\n<div class=\"wpb_text_column wpb_content_element \">\r\n<div class=\"wpb_wrapper\">\r\n\r\nL\u2019edificio localmente viene chiamato \u201cla Fabbrica\u201d, per via della durata dei lavori di costruzione che sembra siano durati svariati decenni.\r\n\r\nLa struttura dell\u2019edificio indica che esso venne costruito verso la seconda met\u00e0 del settecento, essenzialmente per ottenere la materia prima da cui ricavare la seta. Era infatti l\u2019epoca in cui alla Cina era stato strappato il segreto di come si otteneva il richiestissimo e prezioso tessuto, che per millenni era giunto esclusivamente dal Celeste Impero.\r\n\r\n<\/div>\r\n<\/div>\r\n<div class=\"vc_empty_space\"><\/div>\r\n<div class=\"wpb_text_column wpb_content_element \">\r\n<div class=\"wpb_wrapper\">\r\n\r\nLo Stato Pontificio ne impose il monopolio e istitu\u00ec numerosi opifici-setifici, di cui questo di Poggio Mirteto potrebbe essere uno dei pochi rimasti.\r\n\r\nDa notare le aperture ad arco, attualmente occluse e sostituite da finestre, per far prendere luce ed aria alle lettiere di foglie di gelso. Un avancorpo aggiunto successivamente, con finestre goticheggianti ad arco a sesto acuto.\r\n\r\n<\/div>\r\n<\/div>\r\n[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row]","post_title":"Santuario della Madonna della Misericordia","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/santuario-della-madonna-della-misericordia\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Santuario della Madonna della Misericordia\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/opificio-700-1024-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1651848833502{padding-right: 10px !important;padding-left: 10px !important;}.vc_custom_1695028288716{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695028324913{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695292973013{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695292413459{margin-top: 6px !important;border-top-width: 0px !important;border-right-width: 2px !important;border-bottom-width: 2px !important;border-left-width: 2px !important;padding-top: 0px !important;padding-right: 16px !important;padding-bottom: 16px !important;padding-left: 16px !important;border-left-color: #81d742 !important;border-left-style: solid !important;border-right-color: #81d742 !important;border-right-style: solid !important;border-top-color: #81d742 !important;border-top-style: solid !important;border-bottom-color: #81d742 !important;border-bottom-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":577,\"to_translate\":{\"en\":577}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Provinciale Stazione, 34, 02047 Misericordia RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2569411","%_wpgmp_metabox_longitude%":"12.6731663","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"4\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_dp_original%":"4070","%_edit_lock%":"1712061654:4","%_edit_last%":"6","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Chiesa della Madonna della Misericordia","%_yoast_wpseo_metadesc%":"Vuole la tradizione che in un bel pomeriggio d\u2019estate del 1738, Lucia Del Bufalo recitava il suo rosario nel cortile di casa,quando apparve l\u2019immagine della Madonna con il Bambino. Da quel giorno vi fu un grande accorrere di popolo dai dintorni per venerare la sacra immagine, cosa che non poteva non destare l\u2019attenzione delle autorit\u00e0 ecclesiastiche.","%_yoast_wpseo_linkdex%":"57","%_thumbnail_id%":"7801","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Poggio Mirteto","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png"},"id":4399,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png","name":"Chiese e Santuari \/ Churches and Sanctuaries","id":"4","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Chiesa di San Rocco","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chiesa di San Rocco\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/san-rocco2-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/chiesa-di-san-rocco\/\" class=\"fc-post-link\">Chiesa di San Rocco<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Via Pietro Bonfante, 1, 02047 Poggio Mirteto RI, Italia","location":{"lat":"42.2653537","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6862468","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/chiesa-di-san-rocco\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]Si contrappone a Porta Farnese\u00a0 spiccando come elemento caratteristico di Piazza Martiri della Libert\u00e0.\r\n\r\nLa chiesa di San Rocco fu per lungo tempo gestita dalla Societ\u00e0 del Gonfalone, eretta con Bolla del papa Paolo V nel 1607. A causa di necessari restauri per problemi strutturali la chiesa venne demolita e ricostruita nello stesso luogo con l\u2019inaugurazione nell\u2019agosto 1785.\r\n\r\nAll\u2019interno il presbiterio \u00e8 dominato\u00a0 da un\u2019immagine della Madonna con il Bambino, incastonata in una grande raggiera di angeli. In alto spiccano in latino due invocazioni: SALUS INFIRMORUM ORA PRO NOBIS ( Salute \u00a0dei malati prega per noi) e TU HONORIFICENTIA POPULI NOSTRI ( Tu Vanto del nostro popolo). A destra dell\u2019arco trionfale la nicchia con la statua di S.Sebastiano, a sinistra la statua di S. Rocco, tutte e due opere di Michele Chiesa (1689).[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner css=\".vc_custom_1651848833502{padding-right: 10px !important;padding-left: 10px !important;}\" el_class=\"altre-informazioni_app\"][vc_column_inner][vc_empty_space height=\"25px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FChiesa%2Bdi%2BSan%2BRocco%2F%4042.2653329%2C12.6856456%2C19.25z%2Fdata%3D!4m15!1m8!3m7!1s0x132f0ee62022ad19%3A0x1e110bb21cadd12b!2sVia%2BPietro%2BBonfante%2C%2B1%2C%2B02047%2BPoggio%2BMirteto%2BRI!3b1!8m2!3d42.2653537!4d12.6862468!16s%252Fg%252F11c4f6n4w_!3m5!1s0x132f0ee8a090d7c7%3A0x7bec3c0786772a03!8m2!3d42.2653044!4d12.6860986!16s%252Fg%252F11dylz7sn1%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Chiesa di <strong>San Rocco<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1651911428562{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Pietro Bonfante, 1\r\n02047 Poggio Mirteto (RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695658519334{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Aperto su prenotazione[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contattaci<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695631272157{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]\r\n<p style=\"font-size: 11px; font-weight: 400; line-height: 16px;\">Per informazioni e disponibilit\u00e0 di eventuali visite guidate, contatta l\u2019InfopPoint di GeoSabina cliccando sul bottone:<\/p>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text el_class=\"bottone-info\"]\r\n\r\n[popup_trigger id=\"8101\" tag=\"pulsante contatta GeoSabina\"]Contatta l'InfoPoint[\/popup_trigger]\r\n\r\n[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Si contrappone a Porta Farnese\u00a0 spiccando come elemento caratteristico di Piazza Martiri della Libert\u00e0.\r\n\r\nLa chiesa di San Rocco fu per lungo tempo gestita dalla Societ\u00e0 del Gonfalone, eretta con Bolla del papa Paolo V nel 1607. A causa di necessari restauri per problemi strutturali la chiesa venne demolita e ricostruita nello stesso luogo con l\u2019inaugurazione nell\u2019agosto 1785.\r\n\r\nAll\u2019interno il presbiterio \u00e8 dominato\u00a0 da un\u2019immagine della Madonna con il Bambino, incastonata in una grande raggiera di angeli. In alto spiccano in latino due invocazioni: SALUS INFIRMORUM ORA PRO NOBIS ( Salute \u00a0dei malati prega per noi) e TU HONORIFICENTIA POPULI NOSTRI ( Tu Vanto del nostro popolo). A destra dell\u2019arco trionfale la nicchia con la statua di S.Sebastiano, a sinistra la statua di S. Rocco, tutte e due opere di Michele Chiesa (1689).[\/vc_column_text][vc_empty_space height=\"40px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"4\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"yes\" slider_pagination=\"yes\" images=\"4368,7999,7997,7995\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_column_text]Il primo altare a destra di chi entra dalla porta principale \u00e8 dedicato a S.Lucia, il secondo a S.Francesco D\u2019Assisi. A sinistra, un primo altare \u00e8 dedicato ai santi Valentino Martire e Carlo Borromeo, un secondo altare che rappresenta la Nascita di Ges\u00f9, \u00e8 \u00a0attribuito a Giuseppe Puglia ( 1600-1636). Nella cantoria c\u2019\u00e8 un efficiente organo a canne, che viene usato ancora oggi per i concerti.[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Chiesa di San Rocco","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/chiesa-di-san-rocco\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chiesa di San Rocco\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/san-rocco2-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1651848833502{padding-right: 10px !important;padding-left: 10px !important;}.vc_custom_1651911428562{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695658519334{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695631272157{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":285,\"to_translate\":{\"en\":285}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Pietro Bonfante, 1, 02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2653537","%_wpgmp_metabox_longitude%":"12.6862468","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"4\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_thumbnail_id%":"8049","%_dp_original%":"4070","%_edit_lock%":"1702243902:6","%_edit_last%":"6","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Chiesa di San Rocco","%_yoast_wpseo_metadesc%":"Si contrappone a Porta Farnese\u00a0 spiccando come elemento caratteristico di Piazza Martiri della Libert\u00e0, eretta con Bolla del papa Paolo V nel 1607","%_yoast_wpseo_linkdex%":"65","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Poggio Mirteto","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png"},"id":4361,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png","name":"Chiese e Santuari \/ Churches and Sanctuaries","id":"4","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Borgo Medievale di Poggio Mirteto","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Borgo Medievale di Poggio Mirteto\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/099-1-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/borgo-medievale-di-poggio-mirteto\/\" class=\"fc-post-link\">Borgo Medievale di Poggio Mirteto<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Via Ferruccio, 8, 02047 Poggio Mirteto RI, Italia","location":{"lat":"42.2644492","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6825738","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/borgo-medievale-di-poggio-mirteto\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]La parte pi\u00f9 antica di Poggio Mirteto \u00e8 racchiusa tra due diversi ordini di mura, di cui la <strong>pi\u00f9 antica del 200<\/strong> e la pi\u00f9 recente 400\/500 presenta scorci suggestivi ed alcuni elementi interessanti, ed \u00e8 visitabile in non pi\u00f9 di un\u2019ora.\r\n\r\n<strong>L\u2019itinerario si pu\u00f2 iniziare da Piazza M.Dottori<\/strong>, raggiungibile dalla <strong>porta Farnese<\/strong>\u00a0adiacente al Municipio ,da dove si scende per Via Aspromonte. Subito dopo la prima curva si ha la vista del torrione semicircolare, dove inizia via dei Mille e si prosegue tramite una nuova breve rampa di scale alla cui base si converge in via Cavour. Via Cavour prosegue in discesa,\u00a0 costeggia sulla sinistra le mura quattrocentesche dette \u201cMontorsesi\", perch\u00e9 come vuole la tradizione, costruite a carico degli abitanti del castello di Montorso quando chiesero di essere accolti da Poggio Mirteto. Proseguendo ancora , dopo circa 100m, si arriva a<strong> Porta di Sotto,<\/strong> la porta costruita insieme alle mura Montorsesi e che raccordava queste con la cerchia duecentesca.\r\n\r\nSono ancora presenti le antiche porte, tutte rinforzate da borchie metalliche. A sinistra vi \u00e8 l\u2019edicola con il dipinto della Madonna della Vittoria, opera del XVI-XVII sec.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][vc_row_inner][vc_column_inner][vc_empty_space height=\"25px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FVia%2BFerruccio%2C%2B8%2C%2B02047%2BPoggio%2BMirteto%2BRI%2F%4042.2644502%2C12.6813204%2C19z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132f0eef0d4f6093%3A0x318802f3bc7e715e!8m2!3d42.2644492!4d12.6825738!16s%252Fg%252F11c23l3tq6%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Borgo medievale di <strong>Poggio Mirteto<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695034465076{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Porta Farnese\r\nPiazza Martiri della Libert\u00e0\r\n02047 <strong>Poggio Mirteto<\/strong> (RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1651841472116{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Sempre aperto[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contatti<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1651910896780{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Tel.<\/strong>\r\n<strong>Mail:<\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]La parte pi\u00f9 antica di Poggio Mirteto \u00e8 racchiusa tra due diversi ordini di mura, di cui la <strong>pi\u00f9 antica del 200<\/strong> e la pi\u00f9 recente 400\/500 presenta scorci suggestivi ed alcuni elementi interessanti, ed \u00e8 visitabile in non pi\u00f9 di un\u2019ora.\r\n\r\n<strong>L\u2019itinerario si pu\u00f2 iniziare da Piazza M.Dottori<\/strong>, raggiungibile dalla <strong>porta Farnese<\/strong>\u00a0adiacente al Municipio ,da dove si scende per Via Aspromonte. Subito dopo la prima curva si ha la vista del torrione semicircolare, dove inizia via dei Mille e si prosegue tramite una nuova breve rampa di scale alla cui base si converge in via Cavour. Via Cavour prosegue in discesa,\u00a0 costeggia sulla sinistra le mura quattrocentesche dette \u201cMontorsesi\", perch\u00e9 come vuole la tradizione, costruite a carico degli abitanti del castello di Montorso quando chiesero di essere accolti da Poggio Mirteto. Proseguendo ancora , dopo circa 100m, si arriva a<strong> Porta di Sotto,<\/strong> la porta costruita insieme alle mura Montorsesi e che raccordava queste con la cerchia duecentesca.\r\n\r\nSono ancora presenti le antiche porte, tutte rinforzate da borchie metalliche. A sinistra vi \u00e8 l\u2019edicola con il dipinto della Madonna della Vittoria, opera del XVI-XVII sec.[\/vc_column_text][vc_empty_space height=\"40px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"4\" slider_loop=\"yes\" slider_autoplay=\"yes\" slider_navigation=\"yes\" slider_pagination=\"yes\" images=\"3542,3540,3538,7915,3552,3546,3548\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_column_text]Tornando indietro su via Cavour, si risale su via del Forte e si raggiungono costeggiandole di nuovo le mura del 200 fino a Porta Giannetta, una delle porte originarie\u00a0 del borgo antico.\r\n\r\nLa porta, ad arco semplice prende il nome da un capomastro che nel 1550 vi apport\u00f2 importanti opere di restauro e di rinforzo, tale Mastro Giovanni. Da Porta Giannetta inizia via Novara che continua a risalire attraverso altri scorci pittoreschi del borgo fino a via Ferruccio, dalla quale si raggiunge Sala Farnese e quindi Piazza Garibaldi.\r\n\r\nUscendo dal nucleo antico a destra inizia via Cavalliera sotto la parte posteriore della Cattedrale. A pochi metri , sempre con le spalle a Porta Farnese , ma a sinistra, si scende per via del Lavatore, dove ancora oggi si pu\u00f2 vedere i resti dell\u2019antico lavatoio pubblico.[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Borgo Medievale di Poggio Mirteto","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/borgo-medievale-di-poggio-mirteto\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Borgo Medievale di Poggio Mirteto\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/099-1-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1695034465076{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1651841472116{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1651910896780{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":399,\"to_translate\":{\"en\":399}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Ferruccio, 8, 02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2644492","%_wpgmp_metabox_longitude%":"12.6825738","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_thumbnail_id%":"7706","%_dp_original%":"4070","%_edit_lock%":"1702288766:4","%_edit_last%":"6","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Borgo Medievale di Poggio Mirteto","%_yoast_wpseo_metadesc%":"La parte pi\u00f9 antica di Poggio Mirteto \u00e8 racchiusa tra due diversi ordini di mura, di cui la pi\u00f9 antica del 200 che presenta scorci suggestivi ed alcuni elementi interessanti.","%_yoast_wpseo_linkdex%":"62","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png"},"id":4351,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png","name":"Borghi e Centri Storici \/ Villages and Historical Towns","id":"2","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Chiesa di San Giovanni Battista","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chiesa di San Giovanni Battista\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/san_giovanni-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div style=\"padding: 20px;\" class=\"fc-itemcontent-padding\">\r\n        <div>\r\n <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https:\/\/geosabina.it\/poggio-mirteto\/chiesa-di-san-giovanni-battista\/\" class=\"fc-post-link\">Chiesa di San Giovanni Battista<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}<\/div>\r\n        <\/div>\r\n    <\/div>\r\n    <div class=\"fc-clear\"><\/div>\r\n<\/div>","address":"Piazza Mario Dottori, 18, 02047 Poggio Mirteto RI, Italia","location":{"lat":"42.2645394","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6835546","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/chiesa-di-san-giovanni-battista\/","zoom":13,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_column_text]Si dice che la chiesa sia stata costruita su progetto di <strong>Angelo Savi da Parma<\/strong>. Nel <strong>1720 la chiesa fu poi restaurata<\/strong> su progetto di Alessandro Specchi.La chiesa \u00e8 dedicata a San Giovanni Battista e <strong>fu eretta nel 1601<\/strong>[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][vc_single_image image=\"3888\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/poggio-mirteto\/\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner][vc_column_inner][vc_empty_space height=\"25px\"][vc_btn title=\"Ottieni indicazioni stradali\" style=\"outline\" shape=\"square\" color=\"success\" align=\"center\" i_icon_fontawesome=\"fas fa-map-signs\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2Fsan%2BGiovanni%2BDecollato%2F%4042.2643498%2C12.6827351%2C18.75z%2Fdata%3D!4m15!1m8!3m7!1s0x132f0eef4103e2e3%3A0xc45717904df8d3b6!2sPiazza%2BMario%2BDottori%2C%2B18%2C%2B02047%2BPoggio%2BMirteto%2BRI!3b1!8m2!3d42.2645394!4d12.6835546!16s%252Fg%252F11cs8wvb3_!3m5!1s0x132f0eef12cb98a3%3A0x82f801a0386e01b5!8m2!3d42.2644654!4d12.6827411!16s%252Fg%252F11dxb2cvp7%3Fentry%3Dttu\" el_id=\"bottoneindicazioni\"][vc_empty_space height=\"25px\"][vc_column_text]\r\n<h2>Guida <strong>turistica<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][vc_btn title=\"<strong>DOWNLOAD PDF<\/strong>\" style=\"outline-custom\" outline_custom_color=\"#00b801\" outline_custom_hover_background=\"#009907\" outline_custom_hover_text=\"#ffffff\" shape=\"square\" size=\"lg\" align=\"left\" i_icon_fontawesome=\"fas fa-angle-double-down\" button_block=\"true\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Fwp-content%2Fuploads%2F2022%2F04%2Fguida-it.pdf|title:Scarica%20la%20guida\"][vc_empty_space height=\"25px\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_empty_space height=\"40px\"][\/vc_column_inner][\/vc_row_inner][vc_column_text]\r\n<h2>Chiesa di <strong>San Giovanni Battista<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner el_class=\"info_app\"][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/infopin.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Posizione<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1651847683494{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Piazza Mario Dottori, 18\r\n02047 \u2013 <strong>Poggio Mirteto\u00a0<\/strong>(RI)[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/time.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Orari di apertura<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1695050932180{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Sabato<\/strong> dalle ore 08:00 alle 10:00 o su prenotazione[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/3\"][vc_column_text el_class=\"info-point\"]<img class=\"alignleft\" style=\"width: 100%; max-width: 30px; padding-top: 0; padding-right: 5px;\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Contatti<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1651849103353{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Tel.<\/strong> 0765 546120\r\n<strong>Mail:<\/strong> info@confraternitaom.it[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Si dice che la chiesa sia stata costruita su progetto di <strong>Angelo Savi da Parma<\/strong>. Nel <strong>1720 la chiesa fu poi restaurata<\/strong> su progetto di Alessandro Specchi.\r\n\r\nLa chiesa \u00e8 dedicata a San Giovanni Battista e <strong>fu eretta nel 1601 nel Comune di Poggio Mirteto<\/strong>, come si legge sull'architrave delle due porte della facciata.\r\n\r\nDIVO IOANNI BAPTISTAE SOC. MISERICORDIAE AD MDCI\r\n<em>(San Giovanni Battista Societ\u00e0 della Misericordia nell'anno del Signore 1601).<\/em>\r\n\r\nLa Societ\u00e0 o <strong>Compagnia della Misericordia fu fondata per la prima volta a Poggio Mirteto nel 1570<\/strong> e fu poi riconosciuta con un titolo giuridico nel 1610. Il suo luogo di culto era la chiesa di San Giovanni Battista, che gestiva autonomamente con un cappellano e con le rendite di terreni ed edifici.\r\n\r\nLa chiesa fu utilizzata anche come luogo di sepoltura fino all'inizio del 1800, quando una legge viet\u00f2 di seppellire i morti all'interno delle mura dei luoghi abitati. I morti venivano seppelliti anche sotto la chiesa, alla quale si accedeva attraverso una scala che scendeva dall'adiacente sacrestia.\r\n\r\nLa Societ\u00e0 della Misericordia ebbe una forte crisi di identit\u00e0 nel 1814, quando il recupero dei beni sottratti alla Compagnia durante la dominazione francese fu possibile solo in minima parte.\r\n\r\nA met\u00e0 dell'Ottocento la Societ\u00e0 della Misericordia si chiam\u00f2 Confraternita della Misericordia, della Morte e dell'Oracion.\r\n\r\n\u00c8 interessante vedere, sulla facciata, il campanile a vela, che sostitu\u00ec la torre campanaria, quando il cardinale Lambruschini volle dare pi\u00f9 spazio al seminario, che aveva trasferito da S. Salvatore Maggiore a Poggio Mirteto nel 1837.\r\n\r\nSu due delle tre campane si legge che furono realizzate a proprie spese dalla Societ\u00e0 della Misericordia nel 1774, sotto il pontificato di Clemente XIV, il \"protettore\" e vi \u00e8 anche la riproduzione dello stemma del Papa. Per capire meglio \u00e8 necessario sapere che Fra Lorenzo Ganganelli, frate conventuale e futuro Papa con il nome di Clemente XIV (1769-1774, era stato nel Convento di San Valentino a Poggio Mirteto). Dopo essere diventato cardinale, le Compassionate della Misericordia gli chiesero di essere il loro protettore. Una delle due lettere autografe ritrovate nell'archivio parrocchiale \u00e8 la risposta del Cardinale, in cui scrive che sarebbe stato felice di accettare. La Protettoria rimase anche quando Frair Lorenzo divenne Papa.\r\n\r\n&nbsp;\r\n<h4>Entriamo in chiesa<\/h4>\r\nLa chiesa \u00e8 a navata unica con due cappelle sul lato destro e due cappelle sul lato sinistro.\r\n\r\nNel presbiterio, la pala d'altare principale \u00e8 particolare: \u00e8 decorata su entrambi i lati. Da un lato \u00e8 rappresentata la nascita di Giovanni Battista, dall'altro Giovanni Battista decapitato e un servo che porta la sua testa alla figlia di Erodiade.\r\n\r\nIl quadro era in origine uno stendardo processionale, dipinto da Plautilla Bricci (Roma 1616-1690), realizzato in occasione dell'Anno Santo del 1675.\r\n\r\nDipinto a olio su tela. Ultimo restauro nel 1992.\r\n\r\n&nbsp;\r\n<h4>La prima cappella, a destra degli ingressi.<\/h4>\r\n\u00c8 dedicata alla Madonna del Carmelo, rappresentata nel quadro del XVII secolo. I due santi che pregano la Madonna sono S. Antonio di Padova, che riceve lo scapolare, e S. Filippo Neri. In alto si legge: \"DECOR CARMELI\" (decorazione del Carmelo).[\/vc_column_text][vc_empty_space height=\"40px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"4\" slider_loop=\"yes\" slider_autoplay=\"yes\" slider_navigation=\"yes\" slider_pagination=\"yes\" images=\"4083,4081,4085,4087,4089\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_column_text]\r\n<h4>La seconda cappella.<\/h4>\r\n\u00e8 dedicata a S. Gaetano. L'immagine rappresenta la SS. Trinit\u00e0 in alto, in basso, in atteggiamento contemplativo, S. Gaetano che scrive le Regole Teatine e S. Francesco Saverio in cotta bianca e stola bianca.\r\n\r\nLa scritta \"PATRON PRINCIPALE\" indica S. Gaetano come patrono principale di Poggio Mirteto.\r\n\r\nQuesto altare \u00e8 il pi\u00f9 importante della chiesa, perch\u00e9 qui nasce la devozione verso S. Gaetano. La prima festa solenne del santo fu celebrata nel 1698, appena 27 anni dopo che papa Clemente X lo aveva proclamato santo (12 aprile 1671).\r\n\r\nLa festa, che fu celebrata ogni anno fino al 1805, fu sempre gestita dai Deputati della Societ\u00e0 della Misericordia. Di particolare valore \u00e8 anche il dipinto del 1745.\r\n\r\nLa Compagnia della Misericordia aveva incaricato il canonico d. Sebastiano Picchi e il cavaliere Clemente Maria Amici di recarsi a Roma per ordinare il dipinto a un famoso pittore. Tutti erano convinti che il dipinto fosse stato realizzato dal Cav. Sebastiano Conca (Gaeta 1680-Napoli 1764) al quale furono consegnati 65 scudi, ma nella ricevuta, che rilasci\u00f2, il Cav. Conca dichiara di aver ricevuto il denaro non per s\u00e9, ma per conto di Gaspero Serenario, autore del dipinto (Palermo 1707-1759). Dopo il 1730 Gaspero Serenario si trasfer\u00ec da Palermo a Roma, dove era entrato a far parte della cerchia di Conca).\r\n\r\nLa Compagnia della Misericordia aveva anche realizzato nel 1777 la statua di S. Gaetano \"simile a quella che ancora oggi si trova nella chiesa di S. Rocco\". La statua, che veniva solennemente portata fuori nella processione in onore di S. Gaetano, usc\u00ec e torn\u00f2 nella chiesa di S. Giovanni, dove fu conservata in modo sicuro. Solo nel 1970 la statua fu portata in Cattedrale, dove si pu\u00f2 ammirare sull'altare di S. Gaetano.\r\n\r\n&nbsp;\r\n<h4>La prima cappella, a sinistra dell'ingresso.<\/h4>\r\n\u00c8 dedicata al Crocifisso (sec. XVII). In alto il testo: IN HOC VINCES (con questo simbolo vincerai).\r\n\r\nA fianco una nicchia con la statua processionale di S. Antonio Abate.\r\n\r\n&nbsp;\r\n<h4>La seconda cappella a sinistra<\/h4>\r\n\u00c8 dedicata alla Madonna. La sua immagine con il Bambino occupa la parte superiore del dipinto, in basso a sinistra c'\u00e8 S. Pio V, che riceve l'ispirazione dallo Spirito Santo (una colomba), e a destra S. Francesco di Paola, che offre un cuore ardente alla Madonna (il motto del santo \u00e8 Charitas).\r\n\r\nSopra un'iscrizione:\" AVE MARIA\".\r\n\r\nPittura a olio su tela, sec. XVII, ultimo restauro 1992[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Chiesa di San Giovanni Battista","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/chiesa-di-san-giovanni-battista\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chiesa di San Giovanni Battista\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/san_giovanni-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":1064,\"to_translate\":{\"en\":1064}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Piazza Mario Dottori, 18, 02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2645394","%_wpgmp_metabox_longitude%":"12.6835546","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"4\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%qodef_page_content_behind_header_meta%":"no","%qodef_boxed_background_image_attachment_meta%":"fixed","%qodef_slider_frame_meta%":"no","%qodef_disable_header_widget_logo_area_meta%":"no","%qodef_disable_header_widget_menu_area_meta%":"no","%qodef_title_area_type_meta%":"centered","%qodef_disable_footer_meta%":"no","%qodef_show_title_area_meta%":"no","%_oembed_94503de1ba163647932b665425681cd3%":"<iframe title=\"Sguardi su Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/vF4cAi5cPrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_94503de1ba163647932b665425681cd3%":"1649776557","%_thumbnail_id%":"7945","%_dp_original%":"3525","%_edit_lock%":"1707478067:6","%_edit_last%":"6","%_wpb_shortcodes_custom_css%":".vc_custom_1651847683494{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695050932180{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1651849103353{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}","%_oembed_0b6cfd06347fd7cbcc71717b720ca9f5%":"<iframe title=\"La leggenda del lupo   Cantalupo\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/FHawXob-YpQ?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_0b6cfd06347fd7cbcc71717b720ca9f5%":"1664544552","%_oembed_7adb6123afc234f2d047ca8bd17322e0%":"<iframe title=\"Cantalupo   Pasta fatta in casa\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/v_hjOc5nW0E?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_7adb6123afc234f2d047ca8bd17322e0%":"1664544552","%_oembed_4c90539eacbca4711b6973a0a7492e17%":"<iframe title=\"La bella Fiorana, Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/ToxL7oTJaZI?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_4c90539eacbca4711b6973a0a7492e17%":"1669484690","%_oembed_428c81e28f84154eb0dfbe1d6e95fab4%":"<iframe title=\"Chiesa Valdese   Forano\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/ppinU4E0HsA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_428c81e28f84154eb0dfbe1d6e95fab4%":"1680091936","%_oembed_d7e6b0337307eb3be5be38f7dfbdce62%":"<iframe title=\"Borgo di Gavignano\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/cCPlLU0euIQ?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_d7e6b0337307eb3be5be38f7dfbdce62%":"1680092093","%_oembed_19c0b0ba2cd0433ffac89125e61636bd%":"<iframe title=\"Teatro Manlio   Magliano Sabina\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/6CHExK5Crss?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_19c0b0ba2cd0433ffac89125e61636bd%":"1680093503","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"7","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_3d3bb15660616d49f0a91b24030f2fe1%":"<iframe title=\"La leggenda della bella Fiorana   Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/yS0G_kCocTc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_3d3bb15660616d49f0a91b24030f2fe1%":"1693843975","%_yoast_wpseo_focuskw%":"Chiesa di San Giovanni Poggio Mirteto","%_yoast_wpseo_metadesc%":"La chiesa di San Giovanni Battista a poggio Mirteto fu eretta nel 1601, come si legge sull'architrave delle due porte della facciata.","%_yoast_wpseo_linkdex%":"65","%_oembed_ef296e728403ede8dcbc10df275b7112%":"<iframe title=\"Il Sentiero della Memoria, Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/jiyMkmJ2Pdg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_ef296e728403ede8dcbc10df275b7112%":"1694085032","%_oembed_0b796fbec68584d2d75e8dff768a648a%":"<iframe title=\"Sentiero della Memoria   Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/8OzuhFqWGG4?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_0b796fbec68584d2d75e8dff768a648a%":"1694085378","%_oembed_9b9c47394d1fbb521e3fc839fedabaaa%":"<iframe title=\"I Casoni e i Bagni di Lucilla, Montopoli di Sabina e Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/rMl9W-sSIvo?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_9b9c47394d1fbb521e3fc839fedabaaa%":"1694089668","%_oembed_0cff8a66b85ed10fbe945d0e378a03c6%":"<iframe title=\"Casoni e Bagni di Lucilla\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/Oxd5iDkMOOc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_0cff8a66b85ed10fbe945d0e378a03c6%":"1694091063","%_oembed_c63384fbc51ce2155bdca2e5a3ea032f%":"<iframe title=\"Borgo di Bocchignano\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/TUh05y-eWXw?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_c63384fbc51ce2155bdca2e5a3ea032f%":"1694415333","%_oembed_e35df5ee800766ddc3c982fbae737422%":"<iframe title=\"Borgo di Montopoli di sabina\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/eH1U0Q9qe7Y?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_e35df5ee800766ddc3c982fbae737422%":"1694416488","%_oembed_7b6459f1c42c0443573e9f4033c19060%":"<iframe title=\"Riserva Naturale Tevere Farfa\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/l96wxeTT-Fc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_7b6459f1c42c0443573e9f4033c19060%":"1694416937","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% | Poggio Mirteto","%_oembed_ff986bd666cf43d73ae4be5492aad373%":"<iframe title=\"CHIESA SAN PAOLO - Poggio Mirteto\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/F6JOJ17cFhQ?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_ff986bd666cf43d73ae4be5492aad373%":"1695049477","%_oembed_508f4067048d8e74334e52950b5fc609%":"<iframe title=\"Modern Automata Museum   Montopoli di Sabina\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/0Lul-wvnO0w?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_508f4067048d8e74334e52950b5fc609%":"1696320798","%_oembed_786910fae9e41ded3a3d625dd28cd55c%":"<iframe title=\"Borgo di Tarano\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/gk-4SJEIX4o?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_786910fae9e41ded3a3d625dd28cd55c%":"1698048803","%_oembed_46c7b92d0ca027274a6879e49d6a2523%":"<iframe title=\"Museo Maria Petrucci   Toffia\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/fpBUEqBhzfs?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_46c7b92d0ca027274a6879e49d6a2523%":"1698130621","%_oembed_6e6dc704872f853fa6d47f810f0ea6f2%":"<iframe title=\"Velodromo   Forano\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/gU4lALJb7vY?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_6e6dc704872f853fa6d47f810f0ea6f2%":"1700914204","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png"},"id":4070,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png","name":"Chiese e Santuari \/ Churches and Sanctuaries","id":"4","type":"category","extension_fields":{"cat_order":"1"}}]}],"listing":{"listing_header":"Lista dei punti di interesse del Comune di Poggio Mirteto","display_search_form":false,"search_field_autosuggest":false,"display_category_filter":true,"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":"Categoria AZ","category__desc":"Categoria ZA","title__asc":"Titolo AZ","title__desc":"PER Titolo","address__asc":"Indirizzo dalla A alla Z","address__desc":"Indirizzo ZA"},"default_sorting":{"orderby":"title","inorder":"asc"},"listing_container":".location_listing2","tabs_container":".location_listing2","hide_locations":false,"filters_position":"default","hide_map":false,"pagination":{"listing_per_page":"30"},"list_grid":"wpgmp_listing_grid","listing_placeholder":"<div class=\"fc-item-box fc-component-2 wpgmp_locations \">\r\n    <div class=\"fc-component-block\">\r\n        <div class=\"fc-component-content\">\r\n            <ul>\r\n                <li class=\"fc-item-featured fc-component-thumb fc-item-top_space\">\r\n                    <div class=\"fc-featured-hoverdiv\">\r\n                        <div class=\"fc-featured-hoverinner \"><a {onclick_action}=\"\" class=\"map\"><\/a><\/div>\r\n                        {marker_image}\r\n                    <\/div>\r\n                <\/li>\r\n\r\n                <li class=\"fc-component-text\">\r\n                    <div class=\"fc-itemcontent-padding\">\r\n                        <div class=\"fc-item-title fc-item-primary-text-color \">{marker_title}<\/div>\r\n                        <div class=\"fc-item-content fc-item-body-text-color\">\r\n                            {marker_message}\r\n                        <\/div>\r\n                        <a {onclick_action}=\"\" class=\"read-more fc-item-primary-text-color fc-css\">VISUALIZZA SULLA MAPPA\/VIEW ON MAP<\/a>\r\n                    <\/div>\r\n                <\/li>\r\n            <\/ul>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","list_item_skin":{"name":"aare","type":"item","sourcecode":"&lt;div class=&quot;fc-item-box fc-component-2 wpgmp_locations &quot;&gt;\r\n    &lt;div class=&quot;fc-component-block&quot;&gt;\r\n        &lt;div class=&quot;fc-component-content&quot;&gt;\r\n            &lt;ul&gt;\r\n                &lt;li class=&quot;fc-item-featured fc-component-thumb fc-item-top_space&quot;&gt;\r\n                    &lt;div class=&quot;fc-featured-hoverdiv&quot;&gt;\r\n                        &lt;div class=&quot;fc-featured-hoverinner &quot;&gt;&lt;a {onclick_action}=&quot;&quot; class=&quot;map&quot;&gt;&lt;\/a&gt;&lt;\/div&gt;\r\n                        {marker_image}\r\n                    &lt;\/div&gt;\r\n                &lt;\/li&gt;\r\n\r\n                &lt;li class=&quot;fc-component-text&quot;&gt;\r\n                    &lt;div class=&quot;fc-itemcontent-padding&quot;&gt;\r\n                        &lt;div class=&quot;fc-item-title fc-item-primary-text-color &quot;&gt;{marker_title}&lt;\/div&gt;\r\n                        &lt;div class=&quot;fc-item-content fc-item-body-text-color&quot;&gt;\r\n                            {marker_message}\r\n                        &lt;\/div&gt;\r\n                        &lt;a {onclick_action}=&quot;&quot; class=&quot;read-more fc-item-primary-text-color fc-css&quot;&gt;VISUALIZZA SULLA MAPPA\/VIEW ON MAP&lt;\/a&gt;\r\n                    &lt;\/div&gt;\r\n                &lt;\/li&gt;\r\n            &lt;\/ul&gt;\r\n        &lt;\/div&gt;\r\n    &lt;\/div&gt;\r\n&lt;\/div&gt;"}},"map_property":{"map_id":"2","debug_mode":true},"map_marker_spiderfier_setting":{"minimum_markers":"0"},"shapes":{"drawing_editable":false},"filters":{"filters_container":"[data-container=\"wpgmp-filters-container\"]"},"marker_category_icons":{"1":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/bellezze-naturali_sito.png","2":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png","3":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/biblioteche_sito.png","4":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png","5":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dimore-storiche_sito.png","6":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dove-dormire_sito.png","7":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dove-mangiare_sito.png","8":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/monumenti_sito.png","9":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/musei_sito.png","10":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/produzione-tipica_sito.png","11":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png","12":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/servizi-di-persone_sito.png","13":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/archeologia_sito.png","14":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/teatri_sito.png","15":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/stazione_sito.png","16":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/curiosita_sito.png","17":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-generico_sito.png","18":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/info_sito.png","19":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari_sito.png","20":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/piazze-digitali_sito.png","22":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-artistici_sito.png","23":"https:\/\/geosabina.it\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png"}}