Il Monumento ai Caduti di Toffia, è stato inaugurato il 19 settembre 1919 “alla presenza del Consigliere Provinciale Comm. Avv. Luigi Pacieri, del Sindaco Comm. Gaspare Castellani Brancaleoni, del Procuratore del Re Comm. Spartaco Manzoni
{"map_options":{"center_lat":"42.212503941506924","center_lng":"12.7529593593857","zoom":18,"map_type_id":"SATELLITE","center_by_nearest":false,"fit_bounds":false,"center_circle_fillcolor":"#8CAEF2","center_circle_strokecolor":"#dd3333","show_center_circle":false,"show_center_marker":true,"center_marker_icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/geopin-4.png","center_marker_infowindow":"<p>Il punto di interesse che stai consultando \u00e8 in questa posizione<\/p>\n","draggable":true,"scroll_wheel":"true","gesture":"auto","infowindow_setting":"<div class=\"fc-item-box fc-item-no-padding\">\n    {post_featured_image}<\/p>\n<div class=\"fc-itemcontent-padding\">\n<div class=\"fc-item-padding-content_20\">\n<div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">{post_categories}<\/div>\n<div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">{post_title}<\/div>\n<div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\n                {post_excerpt}\n<\/div>\n<\/p><\/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":"udine","type":"infowindow","sourcecode":"&lt;div class=&quot;fc-item-box fc-item-no-padding&quot;&gt;\r\n    {post_featured_image}\r\n    &lt;div class=&quot;fc-itemcontent-padding&quot;&gt;\r\n        &lt;div class=&quot;fc-item-padding-content_20&quot;&gt;\r\n            &lt;div class=&quot;fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center&quot;&gt;{post_categories}&lt;\/div&gt;\r\n            &lt;div class=&quot;fc-item-title fc-item-primary-text-color fc-text-center&quot;&gt;{post_title}&lt;\/div&gt;\r\n            &lt;div class=&quot;fc-item-content fc-item-body-text-color fc-item-top-space&quot;&gt;\r\n                {post_excerpt}\r\n&lt;\/div&gt;\r\n        &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_bounce_animation":"mouseover","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":false,"locateme_control":false,"mobile_specific":false,"zoom_mobile":5,"draggable_mobile":true,"scroll_wheel_mobile":true,"full_screen_control_position":"TOP_RIGHT","search_control_position":"TOP_LEFT","locateme_control_position":"TOP_LEFT","zoom_control_position":"TOP_LEFT","map_type_control_position":"TOP_RIGHT","map_type_control_style":"HORIZONTAL_BAR","street_view_control_position":"TOP_LEFT","map_control":false,"screens":{"smartphone":{"map_zoom_level_mobile":"5"},"ipad":{"map_zoom_level_mobile":"5"},"schermi-di-grandi-dimensioni":{"map_zoom_level_mobile":"5"}},"map_infowindow_customisations":false,"infowindow_width":"100%","infowindow_border_color":"rgba(0, 0, 0, 0.0980392)","infowindow_bg_color":"#000000","show_infowindow_header":false,"min_zoom":"0","max_zoom":"19","zoom_level_after_search":"10","url_filters":false,"doubleclickzoom":false,"current_post_only":false,"bound_map_after_filter":false,"display_reset_button":false,"map_reset_button_text":"Reset","height":"600"},"places":[{"source":"post","title":"Chiesa di Santa Caterina","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 Santa Caterina\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/10\/chiesa_santa_caterina-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\/roccantica\/chiesa-di-santa-caterina\/\" class=\"fc-post-link\">Chiesa di Santa Caterina<\/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 Torre, 25, 02040 Roccantica RI, Italia","location":{"lat":"42.3210513","city":"Roccantica","state":"Lazio","country":"Italia","lng":"12.6934268","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/roccantica\/chiesa-di-santa-caterina\/","zoom":18,"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 Santa Caterina<\/strong>, pi\u00f9 correttamente definita una cappella per le sue dimensioni ridotte (6,27 x 4,83 m), si trova sulla sommit\u00e0 di Roccantica.\u00a0L'edificio \u00e8 documentato fin dal 1343 nel <strong>Registrum omnium ecclesiarum diocesis sabinensis<\/strong>, dove \u00e8 indicata con la dedica a <strong>\"Sancte Marie et Sancte Catherine\"<\/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 gap=\"20\" 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=\"15434\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/roccantica\/\"][\/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%2Fchiesa%2Bsanta%2Bcaterina%2Broccantica%2F%4042.3208987%2C12.693106%2C19z%2Fdata%3D!4m8!4m7!1m0!1m5!1m1!1s0x132f05f2593b7441%3A0xf9edc033ab946847!2m2!1d12.6937504!2d42.3208426%3Fentry%3Dttu%26g_ep%3DEgoyMDI0MTAwMS4wIKXMDSoASAFQAw%253D%253D|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<h1>Chiesa di <strong>Santa Caterina<\/strong><\/h1>\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_1728031422050{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via della Torre, 25\r\n02040 - Roccantica (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_1728031372182{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Chiusa per restauro[\/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_row_inner][vc_empty_space height=\"40px\"][vc_column_text]\r\n<div class=\"flex-shrink-0 flex flex-col relative items-end\">\r\n<div class=\"pt-0\">\r\n<div class=\"gizmo-bot-avatar flex h-8 w-8 items-center justify-center overflow-hidden rounded-full\">\r\n<div class=\"relative p-1 rounded-sm flex items-center justify-center bg-token-main-surface-primary text-token-text-primary h-8 w-8\">\r\n\r\nLa <strong>Chiesa di Santa Caterina<\/strong>, pi\u00f9 correttamente definita una cappella per le sue dimensioni ridotte (6,27 x 4,83 m), si trova sulla sommit\u00e0 di Roccantica.\r\n\r\nL'edificio \u00e8 documentato fin dal 1343 nel <strong>Registrum omnium ecclesiarum diocesis sabinensis<\/strong>, dove \u00e8 indicata con la dedica a <strong>\"Sancte Marie et Sancte Catherine\"<\/strong>.\r\n\r\nNel XV secolo, la cappella venne acquisita da <strong>Armelleo de Bastonis<\/strong>, nominato da Papa Martino V governatore e castellano del borgo sabino. Armelleo trasform\u00f2 la cappella in uno spazio intimo, celebrativo del potere della sua famiglia, destinato a ospitare il matrimonio del figlio Antonio con <strong>Lucia Trinci<\/strong>, figlia di Bartolomeo Trinci. Le nozze si svolsero il 2 gennaio 1432, e la cappella venne decorata con splendidi affreschi per l\u2019occasione.\r\n\r\n<strong>Armelleo de Bastonis<\/strong> fu il principale promotore della decorazione pittorica dell\u2019edificio, realizzata dal pittore <strong>Pietro Coleberti da Piperno<\/strong>, come attestato dalla firma in caratteri gotici, e conclusa nel 1430. Gli affreschi presenti nella cappella sono un prezioso esempio di architettura e decorazione legata alla tradizione cortese e religiosa del tempo.\r\n\r\nUn luogo ricco di storia e fascino, la <strong>Chiesa di Santa Caterina<\/strong> \u00e8 oggi uno dei simboli del borgo di <strong>Roccantica<\/strong>, testimonianza di un passato nobile e di grande valore artistico.\r\n\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n[\/vc_column_text][vc_row_inner disable_element=\"yes\"][vc_column_inner][vc_empty_space height=\"30px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"3\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"15898,15894,15886\"][vc_empty_space height=\"30px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Chiesa di Santa Caterina","post_link":"https:\/\/geosabina.it\/roccantica\/chiesa-di-santa-caterina\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chiesa di Santa Caterina\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/10\/chiesa_santa_caterina-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1728031422050{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1728031372182{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;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":331,\"to_translate\":{\"en\":331}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via della Torre, 25, 02040 Roccantica RI, Italia","%_wpgmp_location_city%":"Roccantica","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.3210513","%_wpgmp_metabox_longitude%":"12.6934268","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"36\";}","%_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","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Chiesa di Santa Caterina","%_yoast_wpseo_metadesc%":"La Chiesa di Santa Caterina, pi\u00f9 correttamente definita una cappella per le sue dimensioni ridotte.\u00a0L'edificio \u00e8 documentato fin dal 1343 nel Registrum omnium ecclesiarum diocesis sabinensis, dove \u00e8 indicata con la dedica a \"Sancte Marie et Sancte Catherine\".","%_yoast_wpseo_linkdex%":"69","%_thumbnail_id%":"16034","%_dp_original%":"15881","%_edit_lock%":"1728032247:4","%_edit_last%":"4","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Roccantica","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png"},"id":16030,"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 Pie&#8217; di Rocca","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 Pie&#8217; di Rocca\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/10\/IMG_4996-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\/roccantica\/chiesa-di-pie-di-rocca\/\" class=\"fc-post-link\">Chiesa di Pie&#8217; di Rocca<\/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 del Municipio, 2, 02040 Roccantica RI, Italia","location":{"lat":"42.321125929333895","city":"Roccantica","state":"Lazio","country":"Italia","lng":"12.692650870534882","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/roccantica\/chiesa-di-pie-di-rocca\/","zoom":18,"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 piccola chiesa, dedicata alla Nativit\u00e0 della Madonna, fu edificata nel 1790 dai Marchesi Vincentini, signori di Roccantica dal 1690. In quell'anno, infatti, avevano riscattato il paese, ottenendo anche il titolo nobiliare, da Marie Anne de la Tr\u00e9moille, vedova di Flavio Orsini.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"15434\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/roccantica\/\"][\/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%2Bdel%2BMunicipio%2C%2B1%2C%2B02040%2BRoccantica%2BRI%2F%4042.3211639%2C12.692061%2C19z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132f05f2efd53b0f%3A0x6bff5d1ac172eb34!8m2!3d42.3211639!4d12.6927061!16s%252Fg%252F11g6224f_4%3Fentry%3Dttu%26g_ep%3DEgoyMDI0MDkzMC4wIKXMDSoASAFQAw%253D%253D|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<h1>Chiesa di <strong>Pie' di Rocca<\/strong><\/h1>\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_1727853094128{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via del Municipio, 1\r\nRoccantica, 02040, 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_1727853115474{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Aperta durante le funzioni religiose[\/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_row_inner][vc_empty_space height=\"40px\"][vc_column_text]\r\n<div class=\"flex-shrink-0 flex flex-col relative items-end\">\r\n<div>\r\n<div class=\"pt-0\">\r\n<div class=\"gizmo-bot-avatar flex h-8 w-8 items-center justify-center overflow-hidden rounded-full\">\r\n<div class=\"relative p-1 rounded-sm flex items-center justify-center bg-token-main-surface-primary text-token-text-primary h-8 w-8\"><\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<div class=\"group\/conversation-turn relative flex w-full min-w-0 flex-col agent-turn\">\r\n<div class=\"flex-col gap-1 md:gap-3\">\r\n<div class=\"flex max-w-full flex-col flex-grow\">\r\n<div class=\"min-h-8 text-message flex w-full flex-col items-end gap-2 whitespace-normal break-words [.text-message+&amp;]:mt-5\" dir=\"auto\" data-message-author-role=\"assistant\" data-message-id=\"c387b1c9-8b84-44d2-9ad2-e35aa39b349e\">\r\n<div class=\"flex w-full flex-col gap-1 empty:hidden first:pt-[3px]\">\r\n<div class=\"markdown prose w-full break-words dark:prose-invert dark\">\r\n\r\nLa piccola chiesa, dedicata alla Nativit\u00e0 della Madonna, fu edificata nel 1790 dai Marchesi Vincentini, signori di Roccantica dal 1690. In quell'anno, infatti, avevano riscattato il paese, ottenendo anche il titolo nobiliare, da Marie Anne de la Tr\u00e9moille, vedova di Flavio Orsini. La chiesa fu costruita nel punto pi\u00f9 alto del paese, ai piedi della cosiddetta torre di Nicol\u00f2 II. Oltre a celebrare i cento anni del possesso, \u00e8 praticamente certo che la sua edificazione servisse anche come una sorta di \"riparazione\" da parte dei marchesi, i quali non avevano contribuito finanziariamente alla ricostruzione della chiesa parrocchiale nel 1740.\r\n\r\nFin dall'inizio, la piccola chiesa divenne un simbolo per la comunit\u00e0, tanto che nelle devozioni riusc\u00ec a soppiantare la chiesa matrice, dedicata alla Madonna Assunta. La festa dell'8 settembre, giorno della Nativit\u00e0, \u00e8 sempre stata particolarmente sentita a Roccantica. Fino a qualche decennio fa, in occasione di questa ricorrenza, anche gli emigranti tornavano al paese. La festa segnava inoltre la fine dell'estate e l'inizio della vendemmia, unendo sacro e profano come era consuetudine.\r\n\r\nAlla statua della Madonna di Piedirocca venivano affissi ex-voto preziosi, come collane, anelli e vari monili. Purtroppo, alcuni anni fa, la statua fu spogliata a seguito di un furto sacrilego. Oggi la chiesa appare completamente trasformata rispetto al suo impianto originario. Il parroco don Guerrino Giacobini la ristruttur\u00f2 secondo il suo gusto personale. Abile nella lavorazione del ferro e del legno, decise di decorare le pareti con immagini sacre in ferro battuto. Anche il pavimento venne rifatto in legno d'olivo, con un'immagine della Madonna, sempre in ferro battuto, incastonata al centro.\r\n\r\nL'accesso alla chiesa avviene attraverso un cancello, ovviamente in ferro battuto, che apre alla prima scalinata realizzata in pietre \"opus incertum\", con simboli incastonati in ferro. Sul lato destro della salita si trovano alcune stazioni della Via Crucis, anch'esse in ferro battuto, e una ricostruzione della grotta di Lourdes. Una piccola piazza conduce a un secondo cancello, da cui si diparte una seconda scalinata. Sul lato sinistro si trova un mezzobusto di Papa Giovanni XXIII. Dal sagrato della chiesa si accede anche alla Torre di Nicol\u00f2 II.\r\n\r\nLa torre, di stile normanno, \u00e8 una torre di avvistamento e segnalazione, non di difesa, edificata dopo il 1059, quando l'esercito degli Altavilla era schierato con Papa Nicol\u00f2 II. Ha subito danni nel tempo, sia a causa dei terremoti che per l'incuria, ma \u00e8 stata fortunatamente restaurata negli ultimi anni, recuperando parte della sua struttura originaria. Una scala interna permette di salire fino a un belvedere, dal quale si pu\u00f2 ammirare un panorama mozzafiato sull'intera valle del Tevere, essendo la torre situata in uno dei punti pi\u00f9 elevati della Sabina.\r\n\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n[\/vc_column_text][vc_empty_space height=\"30px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"3\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"15898,15894,15886\"][vc_empty_space height=\"30px\"][vc_column_text]La torre \u00e8 al centro della rievocazione storica chiamata \"Assalto alla Rocca\", che si svolge il 15 agosto durante la festa medievale. Si narra che Roberto il Guiscardo abbia liberato Papa Nicol\u00f2 II dai rivali Crescenzi, ma la realt\u00e0 storica \u00e8 diversa: l'assalto fu condotto contro la cinta muraria del paese, e n\u00e9 il Guiscardo n\u00e9 il Papa misero mai piede a Roccantica. Roberto de Hauteville, infatti, era impegnato nell'assedio di Reggio Calabria, mentre il Papa partecipava al Concilio di Melfi. L'unica volta in cui si incontrarono fu durante il Concilio, nella notte tra il 23 e il 24 giugno 1059. In realt\u00e0, l'assalto riguard\u00f2 un legato papale, e le truppe coinvolte non erano del Guiscardo, ma guerrieri al suo servizio, probabilmente saraceni. Solo dodici abitanti di Rocca de Antiquo sopravvissero all'assalto, e il paese ottenne uno status privilegiato per la fedelt\u00e0 dimostrata al Papa. Tale privilegio dur\u00f2 fino al 1415, quando i territori papali furono ceduti al conte Francesco Orsini di Gravina da Papa Giovanni XXIII, Baldassarre Cossa, successivamente dichiarato antipapa nel 1947.\r\n\r\nLa rievocazione storica, che si svolge al lume di torce, vede la partecipazione di gran parte della popolazione, che indossa costumi d'epoca. Durante la costruzione della chiesa di Piedirocca, fu aperta la \"porta nuova\", oggi affacciata su una scalinata costruita circa vent'anni fa, frutto di un'opera di riqualificazione dell'area, precedentemente molto degradata.[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Chiesa di Pie&#8217; di Rocca","post_link":"https:\/\/geosabina.it\/roccantica\/chiesa-di-pie-di-rocca\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chiesa di Pie&#8217; di Rocca\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/10\/IMG_4996-300x169.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1727853094128{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1727853115474{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;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":813,\"to_translate\":{\"en\":813}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via del Municipio, 2, 02040 Roccantica RI, Italia","%_wpgmp_location_city%":"Roccantica","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.321125929333895","%_wpgmp_metabox_longitude%":"12.692650870534882","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"36\";}","%_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","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Chiesa di Pie' di Rocca","%_yoast_wpseo_metadesc%":"La piccola chiesa, dedicata alla Nativit\u00e0 della Madonna, fu edificata nel 1790 dai Marchesi Vincentini, signori di Roccantica dal 1690. In quell'anno, infatti, avevano riscattato il paese, ottenendo anche il titolo nobiliare, da Marie Anne de la Tr\u00e9moille, vedova di Flavio Orsini.","%_yoast_wpseo_linkdex%":"59","%_dp_original%":"15447","%_edit_lock%":"1728029993:4","%_edit_last%":"4","%_thumbnail_id%":"15890","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png"},"id":15881,"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":"Punto panoramico Roccantica","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Punto panoramico Roccantica\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/10\/punto_panoramico_roccantica-2-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\/roccantica\/punto-panoramico-roccantica\/\" class=\"fc-post-link\">Punto panoramico Roccantica<\/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 Romana, 1, 02040 Roccantica RI, Italia","location":{"lat":"42.3205846","city":"Roccantica","state":"Lazio","country":"Italia","lng":"12.6920696","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/roccantica\/punto-panoramico-roccantica\/","zoom":18,"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]Se vuoi godere di uno dei panorami pi\u00f9 affascinanti della Sabina, il punto panoramico di Roccantica \u00e8 una meta imperdibile. Da qui, \u00e8 possibile ammirare il <strong>Pontificio Seminario Romano Maggiore<\/strong>, un'imponente costruzione con mura merlate che ricordano la forma di un castello.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"15082\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\"][vc_empty_space height=\"25px\"][\/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%2BRomana%2C%2B1-25%2C%2B02040%2BRoccantica%2BRI%2F%4042.3207057%2C12.6912243%2C19z%2Fdata%3D!3m1!4b1!4m15!1m8!3m7!1s0x132f05f256e6ad8d%3A0x701a14b861f2c40e!2s02040%2BRoccantica%2BRI!3b1!8m2!3d42.3202664!4d12.6951684!16s%252Fg%252F119vnds2_!3m5!1s0x132f05f2e74007e5%3A0x32cd21077b1fbae3!8m2!3d42.3207047!4d12.691868!16s%252Fg%252F11c664lgym%3Fentry%3Dttu%26g_ep%3DEgoyMDI0MDkyMy4wIKXMDSoASAFQAw%253D%253D|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>Punto panoramico <strong>Roccantica<\/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_1727348629261{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Romana, 1-25,\r\n<strong>02041 Casperia RI<\/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\/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_1716452714894{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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]\r\n<div class=\"flex-shrink-0 flex flex-col relative items-end\">\r\n<div>\r\n<div class=\"pt-0\">\r\n<div class=\"gizmo-bot-avatar flex h-8 w-8 items-center justify-center overflow-hidden rounded-full\">\r\n<div class=\"relative p-1 rounded-sm flex items-center justify-center bg-token-main-surface-primary text-token-text-primary h-8 w-8\">Se vuoi godere di uno dei panorami pi\u00f9 affascinanti della Sabina, il punto panoramico di Roccantica \u00e8 una meta imperdibile.<\/div>\r\n<div class=\"relative p-1 rounded-sm flex items-center justify-center bg-token-main-surface-primary text-token-text-primary h-8 w-8\">Da qui, \u00e8 possibile ammirare il <strong>Pontificio Seminario Romano Maggiore<\/strong>, un'imponente costruzione con mura merlate che ricordano la forma di un castello.<\/div>\r\n<div><\/div>\r\n<div class=\"relative p-1 rounded-sm flex items-center justify-center bg-token-main-surface-primary text-token-text-primary h-8 w-8\">Spostando lo sguardo a sinistra, ti troverai di fronte a uno spettacolo naturale unico: il<strong> Rev\u00f2tano<\/strong>, una gigantesca <strong>cavit\u00e0 nella montagna<\/strong>. Considerato per secoli il cratere di un <strong>vulcano spento<\/strong>, \u00e8 in realt\u00e0 una delle pi\u00f9 grandi <strong>doline carsiche<\/strong> del Centro Italia, formatasi dal crollo del terreno per effetto della dissoluzione del carbonato di calcio ad opera delle acque sotterranee.<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<div class=\"group\/conversation-turn relative flex w-full min-w-0 flex-col agent-turn\">\r\n<div class=\"flex-col gap-1 md:gap-3\">\r\n<div class=\"flex max-w-full flex-col flex-grow\">\r\n<div class=\"min-h-8 text-message flex w-full flex-col items-end gap-2 whitespace-normal break-words [.text-message+&amp;]:mt-5\" dir=\"auto\" data-message-author-role=\"assistant\" data-message-id=\"6e495393-8bb8-4887-a3b6-0d91f3f4b9e4\">\r\n<div class=\"flex w-full flex-col gap-1 empty:hidden first:pt-[3px]\">\r\n<div class=\"markdown prose w-full break-words dark:prose-invert dark\">\r\n\r\nCon una vista cos\u00ec ricca di <strong>storia e meraviglie naturali<\/strong>, il punto panoramico di Roccantica \u00e8 il luogo ideale per chi cerca un\u2019esperienza che unisce paesaggi mozzafiato e un tuffo nella geologia e nella cultura locale. Una visita qui non solo regala uno scorcio di bellezza ineguagliabile, ma invita anche a riflettere sulla complessa armonia tra natura e storia che caratterizza questo angolo della<strong> Sabina.<\/strong>\r\n\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n[\/vc_column_text][vc_empty_space height=\"30px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"1\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"15876\"][vc_empty_space height=\"35px\"][\/vc_column][\/vc_row]","post_title":"Punto panoramico Roccantica","post_link":"https:\/\/geosabina.it\/roccantica\/punto-panoramico-roccantica\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Punto panoramico Roccantica\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/10\/punto_panoramico_roccantica-2-300x169.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1727348629261{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1716452714894{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 Romana, 1, 02040 Roccantica RI, Italia","%_wpgmp_location_city%":"Roccantica","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.3205846","%_wpgmp_metabox_longitude%":"12.6920696","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:4:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"19\";i:3;s:2:\"36\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"11\";}","%_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","%_yoast_wpseo_focuskw%":"Punto panoramico Roccantica","%_yoast_wpseo_metadesc%":"Se vuoi godere di uno dei panorami pi\u00f9 affascinanti della Sabina, il punto panoramico di Roccantica \u00e8 una meta imperdibile. Da qui, \u00e8 possibile ammirare il Pontificio Seminario Romano Maggiore, un'imponente costruzione con mura merlate che ricordano la forma di un castello.","%_yoast_wpseo_linkdex%":"70","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_dp_original%":"15283","%_edit_lock%":"1727957906:4","%_edit_last%":"6","%_thumbnail_id%":"15874","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png"},"id":15475,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png","name":"Punti Panoramici \/ Viewpoints","id":"11","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Casa Vacanze Capital House","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Casa Vacanze Capital House\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/capital_house_poggio_mirtetocopertina-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\/casa-vacanze-capital-house\/\" class=\"fc-post-link\">Casa Vacanze Capital House<\/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, 51, 02047 Poggio Mirteto RI, Italia","location":{"lat":"42.2647278","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6841453","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/casa-vacanze-capital-house\/","zoom":18,"extra_fields":{"post_excerpt":"","post_content":"[vc_row full_width=\"stretch_row\" css=\".vc_custom_1727782169274{padding-top: 30px !important;padding-bottom: 40px !important;background-image: url(https:\/\/geosabina.it\/wp-content\/uploads\/2024\/10\/Testata_capital_house_geo.jpg?id=15855) !important;background-position: center !important;background-repeat: no-repeat !important;background-size: cover !important;}\" el_class=\"primo-box\"][vc_column offset=\"vc_hidden-xs\"][vc_row_inner][vc_column_inner width=\"4\/5\"][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1727442788920{padding-left: 8px !important;}\"]\r\n<h2 style=\"font-size: 30px;\">Casa Vacanze <strong>Capital House<\/strong><\/h2>\r\n[\/vc_column_text][vc_column_text css=\".vc_custom_1727445488516{margin-top: -15px !important;padding-left: 8px !important;}\"]\r\n<h4>Comfort e relax nella piazza centrale di <strong>Poggio Mirteto<\/strong><\/h4>\r\n[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/5\"][vc_empty_space height=\"40px\"][vc_btn title=\"PRENOTA\" style=\"flat\" shape=\"round\" color=\"black\" size=\"lg\" align=\"right\" link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fit%2Fcapital-house-casa-vacanze-in-sabina.it.html|target:_blank\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row\" css=\".vc_custom_1727369230940{background-position: center !important;background-repeat: no-repeat !important;background-size: cover !important;}\" el_class=\"primo-box\"][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm\" css=\".vc_custom_1727445989972{margin-top: -40px !important;}\"][vc_row_inner][vc_column_inner width=\"4\/5\"][vc_column_text css=\".vc_custom_1727445341569{padding-left: 8px !important;}\"]\r\n<h2 style=\"font-size: 30px;\">Casa Vacanze <strong>Capital House<\/strong><\/h2>\r\n[\/vc_column_text][vc_column_text css=\".vc_custom_1727445495954{margin-top: -15px !important;padding-left: 8px !important;}\"]\r\n<h4>Comfort e relax nella piazza centrale di <strong>Poggio Mirteto<\/strong><\/h4>\r\n[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/5\"][vc_empty_space height=\"40px\"][vc_btn title=\"PRENOTA\" style=\"flat\" shape=\"round\" color=\"black\" size=\"lg\" align=\"center\" button_block=\"true\" link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fit%2Fcapital-house-casa-vacanze-in-sabina.it.html|target:_blank\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row\" gap=\"35\" content_placement=\"top\"][vc_column css_animation=\"fadeIn\" width=\"2\/3\"][vc_column_text css=\".vc_custom_1727780314820{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\">Per il tuo <strong>soggiorno<\/strong> in Sabina<\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text]<strong>L'appartamento di 85 metri quadri <\/strong>si trova nel cuore di Poggio Mirteto, nella piazza centrale, proprio di fronte alla suggestiva cattedrale Santa Maria Assunta. La posizione \u00e8 ideale per chi cerca comodit\u00e0 e tranquillit\u00e0, con facile accesso a tutti i servizi e attrazioni del borgo.\r\n\r\nSituata in un <strong>edificio storico<\/strong>, Capial House combina il fascino del passato con tutti i <strong>comfort moderni<\/strong>. L\u2019appartamento, spazioso e ben arredato, dispone di due camere da letto, un bagno completo, una cucina completamente attrezzata e un\u2019ampia zona pranzo, perfetta per trascorrere momenti di relax. Il <strong>balcone<\/strong> con vista sulla piazza ed un affaccio della casa su una tranquilla strada alle spalle della piazza, offrono un angolo di pace e riservatezza.\r\n\r\nGli ospiti possono usufruire di WiFi gratuito e di un moderno televisore a schermo piatto con servizi di streaming. La struttura \u00e8 inoltre dotata di un <strong>parcheggio privato e di una stazione di ricarica<\/strong> per <strong>veicoli elettrici<\/strong>, un\u2019ottima opzione per chi viaggia in modo sostenibile.\r\n\r\nCapial House \u00e8 la soluzione ideale per chi vuole esplorare la bellezza della Sabina, soggiornando in un luogo confortevole e autentico in uno dei borghi pi\u00f9 affascinanti della regione.\r\n<h3 style=\"font-size: 20px;\">Poggio Mirteto<\/h3>\r\nPoggio Mirteto \u00e8 un luogo affascinante per coloro che cercano una pausa dalla vita urbana, desiderano esplorare la bellezza naturale e la cultura autentica della <strong>Sabina<\/strong> e godere della calorosa ospitalit\u00e0 italiana.[\/vc_column_text][vc_empty_space height=\"30px\"][vc_row_inner][vc_column_inner][vc_column_text css=\".vc_custom_1727446314725{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\">I <strong>contatti<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"30px\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner][vc_column_inner width=\"1\/4\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_elegant\" fe_icon=\"icon_pin\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Piazza Martiri della Libert\u00e0, 51 - 02047 Poggio Mirteto\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\" custom_class=\"contatti\"][\/vc_column_inner][vc_column_inner width=\"1\/4\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_elegant\" fe_icon=\"icon_phone\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"+39 0765 1891705\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\" custom_class=\"contatti\"][\/vc_column_inner][vc_column_inner width=\"1\/4\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_elegant\" fe_icon=\"icon_mail\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" target=\"_blank\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\" title=\"case.vacanze@capital-group.it\" link=\"mailto:case.vacanze@capital-group.it\" custom_class=\"contatti\"][\/vc_column_inner][vc_column_inner width=\"1\/4\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_elegant\" fe_icon=\"icon_search-2\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" target=\"_blank\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\" title=\"Ottieni indicazioni stradali\" link=\"https:\/\/www.google.com\/maps\/dir\/\/Piazza+Martiri+della+Libert%C3%A0,+51,+02047+Poggio+Mirteto+RI\/@42.2647278,12.681565,713m\/data=!3m1!1e3!4m8!4m7!1m0!1m5!1m1!1s0x132f0eef4f30b319:0x5dbb00f4727c9948!2m2!1d12.6841453!2d42.2647278?entry=ttu&amp;g_ep=EgoyMDI0MDkyOS4wIKXMDSoASAFQAw%3D%3D\" custom_class=\"contatti\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"1\/3\"][vc_row_inner][vc_column_inner css=\".vc_custom_1721319383162{margin-top: 0px !important;border-top-width: 0px !important;padding-top: 0px !important;}\"][vc_column_text css=\".vc_custom_1727784465856{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\"><strong>Servizi<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-car\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Parcheggio pubblico disponibile in loco senza prenotazione al costo di \u20ac 0,30 all'ora.\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17px\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-wifi\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Wi-Fi\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-coffee\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Cucina attrezzata\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-play\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Servizio streaming (es. Netflix)\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-street-view\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Balcone\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-heart\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Animali Ammessi\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-thermometer-three-quarters\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Aria Condizionata\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-bell\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Rilevatore di monossido di carbonio\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner][vc_column_text css=\".vc_custom_1721465473552{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\">Tipologia di <strong>letti<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-bed\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"1 Camera con letto matrimoniale\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-bed\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"1 Camera con 2 letti singoli o letto matrimoniale\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row][vc_row][vc_column][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row\" css=\".vc_custom_1721466916126{background-color: #f2f2f2 !important;}\"][vc_column][vc_row_inner][vc_column_inner][vc_column_text css=\".vc_custom_1727715199738{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\">L'<strong>appartamento<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\" css=\".vc_custom_1721467120737{background-color: #f2f2f2 !important;}\"][vc_column css=\".vc_custom_1721314837052{margin-top: 0px !important;border-top-width: 0px !important;padding-top: 0px !important;}\"][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=\"no\" images=\"15844,15842,15848,15846,15828,15838,15830,15840,15834,15836,15832\" image_size=\"full\"][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row\" css=\".vc_custom_1721467089515{background-color: #f2f2f2 !important;}\"][vc_column][vc_row_inner][vc_column_inner][vc_column_text css=\".vc_custom_1727445571662{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\">Prenota <strong>Capital House<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner css=\".vc_custom_1721412364262{margin-top: 3px !important;margin-right: 3px !important;margin-bottom: 3px !important;margin-left: 3px !important;border-top-width: 1px !important;border-right-width: 1px !important;border-bottom-width: 1px !important;border-left-width: 1px !important;padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 20px !important;padding-left: 10px !important;border-left-color: #adadad !important;border-left-style: dashed !important;border-right-color: #adadad !important;border-right-style: dashed !important;border-top-color: #adadad !important;border-top-style: dashed !important;border-bottom-color: #adadad !important;border-bottom-style: dashed !important;}\"][vc_column_inner css=\".vc_custom_1721408978153{margin-top: 0px !important;border-top-width: 0px !important;padding-top: 0px !important;}\"][vc_column_text]<span style=\"font-size: 13px; line-height: 20px;\"><strong>Questo spazioso appartamento \u00e8 composto da<\/strong> <strong>1 soggiorno, 2 camere da letto separate e 1 bagno<\/strong> con vasca o doccia e accappatoi. L'angolo cottura ben attrezzato, dotato di frigorifero, forno e microonde. L'appartamento <strong>completamente climatizzato<\/strong> comprende una zona pranzo, una TV a schermo piatto con servizi di streaming, una macchina per t\u00e8 e caff\u00e8 e un balcone.<\/span>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"20px\"][vc_btn title=\"CLICCA QUI PER PRENOTARE L'APPARTAMENTO SU BOOKING.COM\" style=\"flat\" shape=\"square\" color=\"inverse\" align=\"left\" link=\"url:https%3A%2F%2Fwww.booking.com%2Fhotel%2Fit%2Fcapital-house-casa-vacanze-in-sabina.it.html|target:_blank\"][vc_empty_space height=\"20px\"][\/vc_column][\/vc_row][vc_row row_content_width=\"grid\"][vc_column offset=\"vc_hidden-xs\"][vc_empty_space height=\"50px\"][vc_column_text css=\".vc_custom_1727784578680{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\">La <strong>Mappa<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"50px\"][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\" el_id=\"mappavisibile\"][vc_column][\/vc_column][\/vc_row]","post_title":"Casa Vacanze Capital House","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/casa-vacanze-capital-house\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Casa Vacanze Capital House\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/capital_house_poggio_mirtetocopertina-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1727782169274{padding-top: 30px !important;padding-bottom: 40px !important;background-image: url(https:\/\/geosabina.it\/wp-content\/uploads\/2024\/10\/Testata_capital_house_geo.jpg?id=15855) !important;background-position: center !important;background-repeat: no-repeat !important;background-size: cover !important;}.vc_custom_1727369230940{background-position: center !important;background-repeat: no-repeat !important;background-size: cover !important;}.vc_custom_1721466916126{background-color: #f2f2f2 !important;}.vc_custom_1721467120737{background-color: #f2f2f2 !important;}.vc_custom_1721467089515{background-color: #f2f2f2 !important;}.vc_custom_1727442788920{padding-left: 8px !important;}.vc_custom_1727445488516{margin-top: -15px !important;padding-left: 8px !important;}.vc_custom_1727445989972{margin-top: -40px !important;}.vc_custom_1727445341569{padding-left: 8px !important;}.vc_custom_1727445495954{margin-top: -15px !important;padding-left: 8px !important;}.vc_custom_1727780314820{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1727446314725{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1721319383162{margin-top: 0px !important;border-top-width: 0px !important;padding-top: 0px !important;}.vc_custom_1727784465856{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721465473552{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1727715199738{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1721314837052{margin-top: 0px !important;border-top-width: 0px !important;padding-top: 0px !important;}.vc_custom_1721412364262{margin-top: 3px !important;margin-right: 3px !important;margin-bottom: 3px !important;margin-left: 3px !important;border-top-width: 1px !important;border-right-width: 1px !important;border-bottom-width: 1px !important;border-left-width: 1px !important;padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 20px !important;padding-left: 10px !important;border-left-color: #adadad !important;border-left-style: dashed !important;border-right-color: #adadad !important;border-right-style: dashed !important;border-top-color: #adadad !important;border-top-style: dashed !important;border-bottom-color: #adadad !important;border-bottom-style: dashed !important;}.vc_custom_1727445571662{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1721408978153{margin-top: 0px !important;border-top-width: 0px !important;padding-top: 0px !important;}.vc_custom_1727784578680{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":364,\"to_translate\":{\"en\":364}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Piazza Martiri della Libert\u00e0, 51, 02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2647278","%_wpgmp_metabox_longitude%":"12.6841453","%_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:\"37\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_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","%_yoast_wpseo_focuskw%":"soggiorno Poggio Mirteto","%_yoast_wpseo_metadesc%":"Vivi il meglio della Sabina in uno degli Alloggi Turistici selezionati per te. Scegli il tuo appartamento e prenota il tuo soggiorno nel cuore diPoggio Mirteto","%_yoast_wpseo_linkdex%":"52","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_bf8995e873e8b21775ffd9d64a809268%":"<iframe title=\"Il Borgo di Montasola\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/AjiMFDVTfL4?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_bf8995e873e8b21775ffd9d64a809268%":"1716481824","%_wpb_post_custom_css%":".social {\r\n    display: flex !important;\r\n    padding-top: 20px !important;\r\n    justify-content: center !important;\r\n}\r\n.soc {text-align:left; padding-right:5px;}\r\n\r\n.vc_tta-tab>a {\r\n    background-color:#ffe500 !important;\r\n    color:#212121 !important;\r\n    border-color: #ffe500 !important;\r\n    font-weight:600;\r\n    line-height: 18px;\r\n    font-size:13px;\r\n}\r\n\r\n.vc_tta-color-sandy-brown.vc_tta-style-classic .vc_tta-tab.vc_active>a {\r\n    background-color:#f4f4f4 !important;\r\n    color:#212121 !important;\r\n    border-color: #f4f4f4 !important;\r\n}\r\n\r\n.vc_tta-color-sandy-brown.vc_tta-style-classic.vc_tta-tabs .vc_tta-panels .vc_tta-panel-body {\r\n        border-color: #f4f4f4 !important;\r\n        background-color: #f4f4f4 !important;\r\n        padding:20px;\r\n    }\r\n    \r\n\r\n.loghetto {\r\n    width:100%;\r\n    max-width:180px;\r\n}\r\n\r\n.loghetto-due {\r\n    width:100%;\r\n    max-width:540px;\r\n}\r\n\r\n.contatti h6 {\r\n    font-size: 12px;\r\n    font-weight: 500;\r\n}\r\n\r\n.primo-box {\r\n    box-shadow: white 0px -25px 40px 1em inset; \r\n}","%_dp_original%":"14194","%_edit_lock%":"1727868745:2","%_edit_last%":"2","%_thumbnail_id%":"15787","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dove-dormire_sito.png"},"id":15735,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dove-dormire_sito.png","name":"Dove Dormire \/ Where to stay","id":"6","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Dolina del Revotano","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Dolina del Revotano\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/10\/Immagine-2024-10-02-092722-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\/roccantica\/dolina-del-revotano\/\" class=\"fc-post-link\">Dolina del Revotano<\/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":"02040 Roccantica RI, Italia","location":{"lat":"42.31107610000001","city":"Roccantica","state":"Lazio","country":"Italia","lng":"12.695003","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/roccantica\/dolina-del-revotano\/","zoom":18,"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 Rev\u00f2tano a Roccantica \u00e8 una delle pi\u00f9 imponenti doline carsiche del centro Italia. Per secoli si pens\u00f2 fosse il cratere di un vulcano estinto, ma in realt\u00e0 si tratta di una dolina di crollo, formatasi a seguito della dissoluzione del carbonato di calcio provocata dalle acque sotterranee.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"15434\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/roccantica\/\"][\/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:http%3A%2F%2FRev%C3%B2tano%20is%20one%20of%20the%20most%20impressive%20karst%20sinkholes%20in%20central%20Italy.%20For%20centuries%20it%20was%20thought%20to%20be%20the%20crater%20of%20an%20extinct%20volcano%2C%20but%20it%20is%20actually%20a%20collapse%20doline%2C%20formed%20as%20a%20result%20of%20the%20dissolution%20of%20calcium%20carbonate.|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<h1>Dolina del <strong>Revotano<\/strong><\/h1>\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_1727854834266{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Dolina del Revotano,\r\nRoccantica, 02040, 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_1727854851408{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_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Il Rev\u00f2tano \u00e8 una delle <strong>pi\u00f9 imponenti doline carsiche del centro Italia<\/strong>. Per secoli si pens\u00f2 fosse il cratere di un vulcano estinto, ma in realt\u00e0 <strong>si tratta di una dolina di crollo<\/strong>, formatasi a seguito della dissoluzione del carbonato di calcio provocata dalle acque sotterranee. Questo processo ha creato nel tempo numerose cavit\u00e0 nel sottosuolo, che sono poi collassate sotto il loro stesso peso.\r\n\r\n<strong>Secondo la leggenda,<\/strong> il borgo primitivo di Roccantica si trovava proprio in questa zona. Tuttavia, a causa della malvagit\u00e0 e della scarsa fede degli abitanti, il villaggio sarebbe sprofondato per volere divino. Solo una donna e il suo bambino si salvarono, poich\u00e9 erano scesi al torrente sottostante, lo Scifulente, per lavare i panni. Una voce misteriosa li avvert\u00ec del pericolo imminente con la frase: \u201c<strong>Corri bionda, che la terra si sprofonda!<\/strong>\u201d. Grazie a questo avvertimento, riuscirono a mettersi in salvo fuggendo sul colle dove oggi sorge l'attuale Roccantica, dando cos\u00ec origine al nuovo insediamento.\r\n\r\nUn'<strong>altra leggenda, forse pi\u00f9 vicina alla realt\u00e0<\/strong>, attribuisce la fondazione del paese a un uomo chiamato Anticho, da cui deriverebbe il nome \"fundum Antiquum\" o \"rocha de Anticho\".\r\n\r\nIl Rev\u00f2tano, con la sua affascinante storia e le sue leggende, rimane uno dei luoghi pi\u00f9 suggestivi e misteriosi del territorio, attirando curiosi e appassionati di <strong>geologia e folklore.<\/strong>[\/vc_column_text][vc_empty_space height=\"30px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"1\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"15910\"][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Dolina del Revotano","post_link":"https:\/\/geosabina.it\/roccantica\/dolina-del-revotano\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Dolina del Revotano\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/10\/Immagine-2024-10-02-092722-1-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1727854834266{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1727854851408{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;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":378,\"to_translate\":{\"en\":378}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"02040 Roccantica RI, Italia","%_wpgmp_location_city%":"Roccantica","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.31107610000001","%_wpgmp_metabox_longitude%":"12.695003","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"36\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_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","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Dolina del Revotano","%_yoast_wpseo_metadesc%":"Il Rev\u00f2tano \u00e8 una delle pi\u00f9 imponenti doline carsiche del centro Italia. Per secoli si pens\u00f2 fosse il cratere di un vulcano estinto, ma in realt\u00e0 si tratta di una dolina di crollo, formatasi a seguito della dissoluzione del carbonato di calcio.","%_yoast_wpseo_linkdex%":"63","%_thumbnail_id%":"15908","%_dp_original%":"15881","%_edit_lock%":"1727957739:4","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/bellezze-naturali_sito.png"},"id":15904,"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"}}]},{"source":"post","title":"Alloggio Turistico San Valentino 5.8","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Alloggio Turistico San Valentino 5.8\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/alloggio_turistico_san-valentino.5.8-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\/alloggio-turistico-san-valentino\/\" class=\"fc-post-link\">Alloggio Turistico San Valentino 5.8<\/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 Trieste, 5, 02047 San Valentino RI, Italia","location":{"lat":"42.2727685","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6969659","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/alloggio-turistico-san-valentino\/","zoom":18,"extra_fields":{"post_excerpt":"","post_content":"[vc_row full_width=\"stretch_row\" css=\".vc_custom_1727428835134{padding-top: 30px !important;padding-bottom: 40px !important;background-image: url(https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/banner_alloggio_san_valentino58.jpg?id=15688) !important;background-position: center !important;background-repeat: no-repeat !important;background-size: cover !important;}\" el_class=\"primo-box\"][vc_column offset=\"vc_hidden-xs\"][vc_row_inner][vc_column_inner width=\"1\/5\"][vc_single_image image=\"15543\" img_size=\"full\" alignment=\"center\"][\/vc_column_inner][vc_column_inner width=\"3\/5\"][vc_empty_space height=\"40px\"][vc_column_text css=\".vc_custom_1727427252380{padding-left: 8px !important;}\"]\r\n<h2 style=\"font-size: 30px;\">Alloggio Turistico <strong>San Valentino 5.8<\/strong><\/h2>\r\n[\/vc_column_text][vc_column_text css=\".vc_custom_1727427273938{margin-top: -15px !important;padding-left: 8px !important;}\"]\r\n<h4>Il tuo Soggiorno a <strong>Poggio Mirteto <\/strong>nel cuore della Sabina<\/h4>\r\n[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/5\"][vc_empty_space height=\"40px\"][vc_empty_space height=\"40px\"][vc_btn title=\"PRENOTA\" style=\"flat\" shape=\"round\" color=\"black\" size=\"lg\" align=\"right\" link=\"url:https%3A%2F%2Falloggituristici58.it%2Fprenota-il-tuo-soggiorno-a-poggio-mirteto%2F|target:_blank\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row\" css=\".vc_custom_1727369230940{background-position: center !important;background-repeat: no-repeat !important;background-size: cover !important;}\" el_class=\"primo-box\"][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm\" css=\".vc_custom_1727369269554{margin-top: -10px !important;}\"][vc_row_inner][vc_column_inner width=\"1\/5\"][vc_single_image image=\"15543\" img_size=\"full\" alignment=\"center\"][\/vc_column_inner][vc_column_inner width=\"3\/5\"][vc_empty_space height=\"40px\"][vc_column_text css=\".vc_custom_1727427296220{padding-left: 8px !important;}\"]\r\n<h2 style=\"font-size: 30px;\">Alloggio Turistico <strong>San Valentino 5.8<\/strong><\/h2>\r\n[\/vc_column_text][vc_column_text css=\".vc_custom_1727369179786{margin-top: -15px !important;padding-left: 8px !important;}\"]\r\n<h4>Il tuo Soggiorno a <strong>Poggio Mirteto <\/strong>nel cuore della Sabina<\/h4>\r\n[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/5\"][vc_empty_space height=\"40px\"][vc_btn title=\"PRENOTA\" style=\"flat\" shape=\"round\" color=\"black\" size=\"lg\" align=\"center\" button_block=\"true\" link=\"url:https%3A%2F%2Falloggituristici58.it%2Fprenota-il-tuo-soggiorno-a-poggio-mirteto%2F|target:_blank\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row\" gap=\"35\" content_placement=\"top\"][vc_column css_animation=\"fadeIn\" width=\"2\/3\"][vc_column_text css=\".vc_custom_1727427395396{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\">Un <strong>cuore<\/strong> di casa<\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text]Benvenuti nel nostro accogliente rifugio, situato nel cuore di San Valentino a\u00a0<strong>Poggio Mirteto<\/strong>. Questo incantevole alloggio, completamente ristrutturato e dotato di ogni comfort, vi accoglier\u00e0 in uno spazio intimo e moderno di\u00a0<strong>45 metri quadrati.<\/strong>\r\n\r\nProgettato con un\u2019attenzione particolare all\u2019ambiente, il nostro appartamento \u00e8 totalmente elettrico, offrendo un soggiorno green e sostenibile.\r\n\r\nLa posizione centrale nella piazza principale di San Valentino permette di vivere appieno il fascino del borgo, con tutti i servizi a portata di mano. A soli\u00a0<strong>1,3 km dal centro, di Poggio Mirteto,<\/strong>\u00a0la nostra casa \u00e8 facilmente raggiungibile<strong>\u00a0in auto a 5 minuti<\/strong>\u00a0dal centro o con la\u00a0<strong>navetta bus c<\/strong>he ferma proprio nella piazzetta antistante l\u2019alloggio, garantendovi una connessione comoda e veloce.\r\n\r\nAbbiamo chiamato questo gioiello \u201c<strong>un cuore di casa<\/strong>\u201d per la sua atmosfera calda e accogliente, perfetta per una fuga romantica o una tranquilla vacanza. Prenotate ora e vivete un\u2019esperienza indimenticabile, dove comfort, sostenibilit\u00e0 e charme si incontrano nel cuore di Poggio Mirteto.\r\n\r\nL\u2018alloggio segue le linee guida della Citt\u00e0 di Poggio Mirteto entrata a far parte dei\u00a0<strong>Comuni Sostenibili d\u2019Italia.<\/strong>\r\n<h3 style=\"font-size: 20px;\">Poggio Mirteto<\/h3>\r\nPoggio Mirteto \u00e8 un luogo affascinante per coloro che cercano una pausa dalla vita urbana, desiderano esplorare la bellezza naturale e la cultura autentica della <strong>Sabina<\/strong> e godere della calorosa ospitalit\u00e0 italiana.[\/vc_column_text][vc_empty_space height=\"30px\"][vc_row_inner][vc_column_inner][vc_column_text css=\".vc_custom_1727457849788{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\"><strong>Contatti<\/strong> &amp; Recapiti<\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"30px\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner][vc_column_inner width=\"1\/4\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_elegant\" fe_icon=\"icon_pin\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Piazza Trieste, 5, 02047 Poggio Mirteto\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\" custom_class=\"contatti\"][\/vc_column_inner][vc_column_inner width=\"1\/4\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_elegant\" fe_icon=\"icon_phone\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"+39 0765 546507\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\" custom_class=\"contatti\"][\/vc_column_inner][vc_column_inner width=\"1\/4\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_elegant\" fe_icon=\"icon_link\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" target=\"_blank\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\" title=\"alloggituristici58.it\" link=\"https:\/\/alloggituristici58.it\/alloggio-turistico-riosole\/\" custom_class=\"contatti\"][\/vc_column_inner][vc_column_inner width=\"1\/4\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_elegant\" fe_icon=\"icon_search-2\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" target=\"_blank\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\" title=\"Ottieni indicazioni stradali\" link=\"https:\/\/www.google.com\/maps\/dir\/\/Alloggio+Turistico+San+Valentino+5.8+Piazza+Trieste,+5+02047+Poggio+Mirteto+RI\/@42.2727571,12.6969727,12z\/data=!4m5!4m4!1m0!1m2!1m1!1s0x132f0f28215cd757:0x8c4e944c636f1bb0\" custom_class=\"contatti\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"1\/3\"][vc_row_inner][vc_column_inner css=\".vc_custom_1721319383162{margin-top: 0px !important;border-top-width: 0px !important;padding-top: 0px !important;}\"][vc_column_text css=\".vc_custom_1727457816976{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\"><strong>Servizi<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-car\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Parcheggio pubblico gratuito\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17px\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-wifi\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Wi-Fi\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-coffee\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Cucina attrezzata\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-thermometer-three-quarters\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Aria Condizionata\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-coffee\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Macchina caff\u00e8 con cialde\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-clock-o\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Lavatrice con detersivo\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner][vc_column_text css=\".vc_custom_1721465473552{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\">Tipologia di <strong>letti<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-bed\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"1 Camera con letto matrimoniale\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-bed\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" target=\"_blank\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\" title=\"1 letto aggiuntivo zona living\" link=\"https:\/\/alloggituristici58.it\/alloggio-turistico-riosole\/\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-bed\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" target=\"_blank\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\" title=\"Servizio culla\" link=\"https:\/\/alloggituristici58.it\/alloggio-turistico-riosole\/\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row][vc_row][vc_column][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row\" css=\".vc_custom_1721466916126{background-color: #f2f2f2 !important;}\"][vc_column][vc_row_inner][vc_column_inner][vc_column_text css=\".vc_custom_1727457860244{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\">L'<strong>appartamento<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"30px\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\" css=\".vc_custom_1721467120737{background-color: #f2f2f2 !important;}\"][vc_column css=\".vc_custom_1721314837052{margin-top: 0px !important;border-top-width: 0px !important;padding-top: 0px !important;}\"][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=\"no\" images=\"15696,15694,15704,15700,15706,15698,15712,15710\" image_size=\"full\"][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row\" css=\".vc_custom_1721467089515{background-color: #f2f2f2 !important;}\"][vc_column][vc_row_inner][vc_column_inner][vc_column_text css=\".vc_custom_1727429964738{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\">Prenota <b>San Valentino 5.8<\/b><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner css=\".vc_custom_1721412364262{margin-top: 3px !important;margin-right: 3px !important;margin-bottom: 3px !important;margin-left: 3px !important;border-top-width: 1px !important;border-right-width: 1px !important;border-bottom-width: 1px !important;border-left-width: 1px !important;padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 20px !important;padding-left: 10px !important;border-left-color: #adadad !important;border-left-style: dashed !important;border-right-color: #adadad !important;border-right-style: dashed !important;border-top-color: #adadad !important;border-top-style: dashed !important;border-bottom-color: #adadad !important;border-bottom-style: dashed !important;}\"][vc_column_inner css=\".vc_custom_1721408978153{margin-top: 0px !important;border-top-width: 0px !important;padding-top: 0px !important;}\"][vc_column_text]<span style=\"font-size: 11px; line-height: 20px;\"><strong>Tutti i nostri alloggi sono corredati dei seguenti servizi:<\/strong>\r\nTV a schermo piatto led, prese elettriche multiple vicino al letto, ferro e asse da stiro, bollitore elettrico, tostapane, frullatore tipo minipimer, asciugacapelli professionale, pavimenti in marmo o piastrelle, prodotti per le pulizie.<\/span>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"20px\"][vc_btn title=\"CLICCA QUI PER PRENOTARE L'APPARTAMENTO\" style=\"flat\" shape=\"square\" color=\"inverse\" align=\"left\" link=\"url:https%3A%2F%2Falloggituristici58.it%2Fprenota-il-tuo-soggiorno-a-poggio-mirteto%2F|target:_blank\"][vc_empty_space height=\"20px\"][\/vc_column][\/vc_row][vc_row row_content_width=\"grid\"][vc_column offset=\"vc_hidden-xs\"][vc_empty_space height=\"50px\"][vc_column_text css=\".vc_custom_1727786109561{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\">La <b>Mappa<\/b><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"50px\"][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row]","post_title":"Alloggio Turistico San Valentino 5.8","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/alloggio-turistico-san-valentino\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Alloggio Turistico San Valentino 5.8\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/alloggio_turistico_san-valentino.5.8-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1727428835134{padding-top: 30px !important;padding-bottom: 40px !important;background-image: url(https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/banner_alloggio_san_valentino58.jpg?id=15688) !important;background-position: center !important;background-repeat: no-repeat !important;background-size: cover !important;}.vc_custom_1727369230940{background-position: center !important;background-repeat: no-repeat !important;background-size: cover !important;}.vc_custom_1721466916126{background-color: #f2f2f2 !important;}.vc_custom_1721467120737{background-color: #f2f2f2 !important;}.vc_custom_1721467089515{background-color: #f2f2f2 !important;}.vc_custom_1727427252380{padding-left: 8px !important;}.vc_custom_1727427273938{margin-top: -15px !important;padding-left: 8px !important;}.vc_custom_1727369269554{margin-top: -10px !important;}.vc_custom_1727427296220{padding-left: 8px !important;}.vc_custom_1727369179786{margin-top: -15px !important;padding-left: 8px !important;}.vc_custom_1727427395396{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1727457849788{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1721319383162{margin-top: 0px !important;border-top-width: 0px !important;padding-top: 0px !important;}.vc_custom_1727457816976{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721465473552{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1727457860244{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1721314837052{margin-top: 0px !important;border-top-width: 0px !important;padding-top: 0px !important;}.vc_custom_1721412364262{margin-top: 3px !important;margin-right: 3px !important;margin-bottom: 3px !important;margin-left: 3px !important;border-top-width: 1px !important;border-right-width: 1px !important;border-bottom-width: 1px !important;border-left-width: 1px !important;padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 20px !important;padding-left: 10px !important;border-left-color: #adadad !important;border-left-style: dashed !important;border-right-color: #adadad !important;border-right-style: dashed !important;border-top-color: #adadad !important;border-top-style: dashed !important;border-bottom-color: #adadad !important;border-bottom-style: dashed !important;}.vc_custom_1727429964738{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1721408978153{margin-top: 0px !important;border-top-width: 0px !important;padding-top: 0px !important;}.vc_custom_1727786109561{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":330,\"to_translate\":{\"en\":330}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Piazza Trieste, 5, 02047 San Valentino RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2727685","%_wpgmp_metabox_longitude%":"12.6969659","%_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:\"37\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_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","%_yoast_wpseo_focuskw%":"alloggi turistici Poggio Mirteto","%_yoast_wpseo_metadesc%":"Vivi il meglio della Sabina in uno degli Alloggi Turistici selezionati per te. Scegli il tuo appartamento e prenota il tuo soggiorno a Poggio Mirteto","%_yoast_wpseo_linkdex%":"50","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"7","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_bf8995e873e8b21775ffd9d64a809268%":"<iframe title=\"Il Borgo di Montasola\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/AjiMFDVTfL4?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_bf8995e873e8b21775ffd9d64a809268%":"1716481824","%_wpb_post_custom_css%":".social {\r\n    display: flex !important;\r\n    padding-top: 20px !important;\r\n    justify-content: center !important;\r\n}\r\n.soc {text-align:left; padding-right:5px;}\r\n\r\n.vc_tta-tab>a {\r\n    background-color:#ffe500 !important;\r\n    color:#212121 !important;\r\n    border-color: #ffe500 !important;\r\n    font-weight:600;\r\n    line-height: 18px;\r\n    font-size:13px;\r\n}\r\n\r\n.vc_tta-color-sandy-brown.vc_tta-style-classic .vc_tta-tab.vc_active>a {\r\n    background-color:#f4f4f4 !important;\r\n    color:#212121 !important;\r\n    border-color: #f4f4f4 !important;\r\n}\r\n\r\n.vc_tta-color-sandy-brown.vc_tta-style-classic.vc_tta-tabs .vc_tta-panels .vc_tta-panel-body {\r\n        border-color: #f4f4f4 !important;\r\n        background-color: #f4f4f4 !important;\r\n        padding:20px;\r\n    }\r\n    \r\n\r\n.loghetto {\r\n    width:100%;\r\n    max-width:180px;\r\n}\r\n\r\n.loghetto-due {\r\n    width:100%;\r\n    max-width:540px;\r\n}\r\n\r\n.contatti h6 {\r\n    font-size: 12px;\r\n    font-weight: 500;\r\n}\r\n\r\n.primo-box {\r\n    box-shadow: white 0px -25px 40px 1em inset; \r\n}","%_thumbnail_id%":"15679","%_dp_original%":"14194","%_edit_lock%":"1727786121:4","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dove-dormire_sito.png"},"id":15673,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dove-dormire_sito.png","name":"Dove Dormire \/ Where to stay","id":"6","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Il Borgo di Roccantica","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Il Borgo di Roccantica\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/Copertina_borgo_roccantica-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\/roccantica\/il-borgo-di-roccantica\/\" class=\"fc-post-link\">Il Borgo di Roccantica<\/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 dei Fienili, 1, 02040 Roccantica RI, Italia","location":{"lat":"42.32088458202123","city":"Roccantica","state":"Lazio","country":"Italia","lng":"12.693291141139218","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/roccantica\/il-borgo-di-roccantica\/","zoom":18,"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 borgo fortificato, eretto nel 1576 dalla famiglia Orsini, sostitu\u00ec il vecchio castello ormai trasformato in convento monacale. Progettato secondo i principi rinascimentali del \"borgo-fortezza\", era pensato per essere completamente autosufficiente in caso di assedio.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"15434\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/roccantica\/\"][\/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%2F02040%2BRoccantica%2BRI%2F%4042.3208129%2C12.6925081%2C18z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132f05f256e6ad8d%3A0x701a14b861f2c40e!8m2!3d42.3202664!4d12.6951684!16s%252Fg%252F119vnds2_%3Fentry%3Dttu%26g_ep%3DEgoyMDI0MDkyMy4wIKXMDSoASAFQAw%253D%253D|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<h1>Il Borgo di <strong>Roccantica<\/strong><\/h1>\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_1727337884372{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via del Campanile, 18\r\nRoccantica, 02040, 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_1727362693203{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_row_inner][vc_empty_space height=\"40px\"][vc_column_text]\r\n<div class=\"flex-shrink-0 flex flex-col relative items-end\">\r\n<div>\r\n<div class=\"pt-0\">\r\n<div class=\"gizmo-bot-avatar flex h-8 w-8 items-center justify-center overflow-hidden rounded-full\">\r\n<div class=\"relative p-1 rounded-sm flex items-center justify-center bg-token-main-surface-primary text-token-text-primary h-8 w-8\">Il <strong>borgo fortificato<\/strong>, eretto nel 1576 dalla famiglia <strong>Orsini<\/strong>, sostitu\u00ec il vecchio <strong>castello<\/strong> ormai trasformato in<strong> convento monacale<\/strong>. Progettato secondo i principi rinascimentali del <strong>\"borgo-fortezza\"<\/strong>, era pensato per essere completamente autosufficiente in caso di assedio. Al suo interno si trovavano cantine per lo stoccaggio di vino, olio e grano, una macina, un frantoio, tinaie, legnaie e piccoli orti protetti dalla cinta muraria. Questa cinta si estendeva oltre il nucleo principale del borgo e comprendeva case-torri, che fungevano sia da abitazioni che da punti di difesa. Gli abitanti, infatti, <strong>difendevano direttamente la propria casa e famiglia<\/strong>, non una struttura istituzionale astratta.<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<div class=\"group\/conversation-turn relative flex w-full min-w-0 flex-col agent-turn\">\r\n<div class=\"flex-col gap-1 md:gap-3\">\r\n<div class=\"flex max-w-full flex-col flex-grow\">\r\n<div class=\"min-h-8 text-message flex w-full flex-col items-end gap-2 whitespace-normal break-words [.text-message+&amp;]:mt-5\" dir=\"auto\" data-message-author-role=\"assistant\" data-message-id=\"d0936063-54db-4205-821d-f80e338a3a97\">\r\n<div class=\"flex w-full flex-col gap-1 empty:hidden first:pt-[3px]\">\r\n<div class=\"markdown prose w-full break-words dark:prose-invert dark\">\r\n\r\nAlcuni degli elementi difensivi di questa fortificazione<strong> sono ancora visibili<\/strong>, come le <strong>case-torri<\/strong> con contrafforti in pietra, che si trovano lungo la Piazza San Valentino e via Romana fino a via Nuova. La <strong>cinta muraria del borgo<\/strong>, delimitata dalle vie San Giuseppe, Pacigno, Arcoscuro e Valentini, originariamente includeva la Porta Romana, demolita nel Settecento e sostituita dall\u2019accesso oggi conosciuto come <strong>\"le colonne\".<\/strong>\r\nLa costruzione della prima cinta muraria, con <strong>Porta Nuova<\/strong>, risale all'846, dopo la tentata invasione dei Saraceni. La<strong> Porta Reatina<\/strong>, invece, fa parte della seconda cinta muraria eretta dagli Orsini, orientata verso il Monte Tancia e Rieti, contestualmente alla fondazione del borgo fortificato.\r\nCon l\u2019ampliamento della parte bassa del paese nel 1576, gli Orsini costruirono un nuovo palazzo nobiliare e rafforzarono il borgo con nuove case-torri, che garantivano<strong> non solo la difesa<\/strong>, ma anche l'autosufficienza del borgo grazie agli orti interni e alle fonti idriche. Questo sistema difensivo coinvolgeva tutta la popolazione, poich\u00e9 ogni abitante proteggeva la propria casa all\u2019interno della struttura fortificata.\r\n\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][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=\"no\" slider_pagination=\"no\" images=\"15526,15524,15521,15519\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"20px\"][vc_column_text]Nei secoli successivi, la struttura del borgo-fortezza fu modificata dai Vincentini, che aggiunsero un piccolo teatro, trasformarono il cammino di ronda e costruirono una torre di guardia di fronte al <strong>campanile della chiesa di San Valentino<\/strong>. Inoltre, fu realizzato un giardino interno sul lato sud con un gazebo.\r\nNel XX secolo, la famiglia Vincentini fu assorbita dalla casata dei Potenziani, e il complesso del borgo-fortezza cambi\u00f2 pi\u00f9 volte proprietario. Infine, con una serie di vendite frazionate, il borgo venne trasformato in una sorta di \"condominio\", rendendo il complesso storico inaccessibile nella sua totalit\u00e0.\r\nNonostante queste trasformazioni, il borgo fortificato conserva ancora tracce della sua straordinaria storia, rappresentando un raro esempio di architettura difensiva rinascimentale, dove la comunit\u00e0 trovava protezione e autosufficienza all\u2019interno di mura secolari.[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Il Borgo di Roccantica","post_link":"https:\/\/geosabina.it\/roccantica\/il-borgo-di-roccantica\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Il Borgo di Roccantica\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/Copertina_borgo_roccantica-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1727337884372{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1727362693203{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;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":502,\"to_translate\":{\"en\":502}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via dei Fienili, 1, 02040 Roccantica RI, Italia","%_wpgmp_location_city%":"Roccantica","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.32088458202123","%_wpgmp_metabox_longitude%":"12.693291141139218","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"36\";}","%_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","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Il Borgo di Roccantica","%_yoast_wpseo_metadesc%":"Il borgo fortificato, eretto nel 1576 dalla famiglia Orsini, sostitu\u00ec il vecchio castello ormai trasformato in convento monacale. Progettato secondo i principi rinascimentali del \"borgo-fortezza\", era pensato per essere completamente autosufficiente in caso di assedio.","%_yoast_wpseo_linkdex%":"63","%_thumbnail_id%":"15496","%_dp_original%":"15447","%_edit_lock%":"1727957685:4","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png"},"id":15489,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png","name":"Borghi e Centri Storici \/ Villages and Historical Centers","id":"2","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"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=\"Chiesa di San Valentino\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/campanile-roccantica-S.V-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\/roccantica\/chiesa-di-san-valentino\/\" class=\"fc-post-link\">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 del Campanile, 18, 02040 Roccantica RI, Italia","location":{"lat":"42.320127","city":"Roccantica","state":"Lazio","country":"Italia","lng":"12.6930712","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/roccantica\/chiesa-di-san-valentino\/","zoom":18,"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 di San Valentino,<strong> patrono di Roccantica<\/strong>, ha origini antiche che risalgono all'Alto Medioevo. Il primo riferimento documentato risale al 792, quando Palombo, figlio di Rattone, fece una donazione <strong>\"pro remedio animae\"<\/strong> (per la salvezza dell'anima) all'Abbazia di Farfa, includendo terre, abitazioni, persone e una porzione della chiesa stessa.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"15434\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/roccantica\/\"][\/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%2FCampanile%2Bpiazza%2BSan%2BValentino%2F%4042.3199707%2C12.6935161%2C19.7z%2Fdata%3D!4m6!3m5!1s0x132f05f3017bedd5%3A0x759c7301ecc0055b!8m2!3d42.320127!4d12.6930712!16s%252Fg%252F11dxhgpp2c%3Fentry%3Dttu%26g_ep%3DEgoyMDI0MDkyMy4wIKXMDSoASAFQAw%253D%253D|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<h1>Chiesa di <strong>San Valentino<\/strong><\/h1>\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_1727337884372{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via del Campanile, 18\r\nRoccantica, 02040, 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_1727338336579{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Visibile solo esternamente[\/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_row_inner][vc_empty_space height=\"40px\"][vc_column_text]La Chiesa di San Valentino,<strong> patrono di Roccantica<\/strong>, ha origini antiche che risalgono all'Alto Medioevo. Il primo riferimento documentato risale al 792, quando Palombo, figlio di Rattone, fece una donazione <strong>\"pro remedio animae\"<\/strong> (per la salvezza dell'anima) all'Abbazia di Farfa, includendo terre, abitazioni, persone e una porzione della chiesa stessa. Questo indica che la chiesa fu edificata prima di tale data, su un terreno noto come <strong>\"Fondo Antico\"<\/strong>. Nei pressi della chiesa si svilupp\u00f2 il primo insediamento signorile di Palombo e Rattone, che nel corso dei secoli si espanse fino a dare vita all'attuale abitato di Roccantica.\r\n\r\n<strong>La Chiesa di San Valentino<\/strong> divenne in seguito la <strong>parrocchia del borgo<\/strong>, con annessa la residenza dell'arciprete e dei chierici. Accanto alla chiesa, sulla destra, sorgeva il cimitero, come indicato nelle mappe del Catasto Gregoriano del 1820, situato nella zona sottostante l'attuale piazza.\r\n\r\nNel 1300 la chiesa sub\u00ec un'importante<strong> ristrutturazione<\/strong>, se non una completa ricostruzione, come riportato nello Statuto di Roccantica del 1326, dove si fa riferimento alla <strong>\"ecclesia Sancti Valentini de novo facta\"<\/strong>. Una descrizione dettagliata della chiesa, tra il XVIII e il XIX secolo, emerge dalla Visita Pastorale Corsini: la struttura trecentesca era in stile gotico-romanico, con un porticato frontale sostenuto da quattro pilastri e una finestra a oculo che illuminava l'interno. L'abside era arricchita da tre bifore (una delle quali \u00e8 ancora visibile), mentre sotto il porticato si trovavano affreschi di un artista umbro del XV secolo. All'interno vi erano cinque cappelle decorate con affreschi e, sull'altare maggiore, era collocata una tempera su tavola di Bartolomeo Torresani, attualmente conservata nella chiesa di <strong>Santa Maria Assunta.<\/strong>\r\n\r\nPurtroppo, <strong>oggi la chiesa non esiste pi\u00f9<\/strong>, <strong>ad eccezione dell'abside e della torre campanaria.<\/strong> Intorno al 1932, la chiesa, in stato di degrado, fu in parte demolita e in parte interrata. Al suo posto fu creato il Parco della Rimembranza, in memoria dei caduti in guerra, situato a un livello inferiore rispetto all'attuale piazza. Negli anni '50, il parco fu interrato e la piazza assunse la sua forma attuale. Oggi, ci\u00f2 che resta della Chiesa di San Valentino \u00e8 stato consacrato come <strong>Monumento ai Caduti<\/strong> delle due guerre mondiali.\r\n\r\nPer chi visita Roccantica, le vestigia della Chiesa di San Valentino rappresentano un importante sito storico, collegato alle tradizioni e alla memoria del paese.[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Chiesa di San Valentino","post_link":"https:\/\/geosabina.it\/roccantica\/chiesa-di-san-valentino\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chiesa di San Valentino\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/campanile-roccantica-S.V-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1727337884372{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1727338336579{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;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":509,\"to_translate\":{\"en\":509}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via del Campanile, 18, 02040 Roccantica RI, Italia","%_wpgmp_location_city%":"Roccantica","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.320127","%_wpgmp_metabox_longitude%":"12.6930712","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"36\";}","%_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","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Chiesa di San Valentino","%_yoast_wpseo_metadesc%":"La Chiesa di San Valentino, patrono di Roccantica, ha origini antiche che risalgono all'Alto Medioevo. Il primo riferimento documentato risale al 792, quando Palombo, fece una donazione \"pro remedio animae\"","%_yoast_wpseo_linkdex%":"69","%_thumbnail_id%":"15451","%_dp_original%":"13798","%_edit_lock%":"1727957248:4","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png"},"id":15447,"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":"Punto panoramico Casperia","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Punto panoramico Casperia\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/punto-panoramico-casperia-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\/altri-comuni\/punto-panoramico-casperia\/\" class=\"fc-post-link\">Punto panoramico Casperia<\/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 XII Ottobre, 4, 02034 Montopoli di Sabina RI, Italia","location":{"lat":"42.3376593","city":"Montopoli di Sabina","state":"Lazio","country":"Italia","lng":"12.66965692","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/punto-panoramico-casperia\/","zoom":18,"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]Se stai cercando un luogo <strong>incantevole<\/strong> per ammirare la bellezza della <strong>Sabina<\/strong>, il punto panoramico di <strong>Casperia<\/strong> \u00e8 una tappa obbligata. Situato nel cuore di questo affascinante <strong>borgo medievale<\/strong>, offre una vista mozzafiato sulla campagna circostante, con i suoi dolci colli e i vigneti che si estendono a perdita d'occhio.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"15082\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\"][vc_empty_space height=\"25px\"][\/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%2F42%25C2%25B020'15.6%2522N%2B12%25C2%25B040'10.8%2522E%2F%4042.3375091%2C12.6696202%2C21z%2Fdata%3D!4m4!3m3!8m2!3d42.3376667!4d12.6696667%3Fentry%3Dttu%26g_ep%3DEgoyMDI0MDkxOC4xIKXMDSoASAFQAw%253D%253D|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>Punto panoramico <strong>Casperia<\/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_1727081737106{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Rivellini, 19-49,\r\n<strong>02041 Casperia RI<\/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\/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_1716452714894{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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Se stai cercando un luogo <strong>incantevole<\/strong> per ammirare la bellezza della <strong>Sabina<\/strong>, il punto panoramico di <strong>Casperia<\/strong> \u00e8 una tappa obbligata. Situato nel cuore di questo affascinante <strong>borgo medievale<\/strong>, offre una vista mozzafiato sulla campagna circostante, con i suoi dolci colli e i vigneti che si estendono a perdita d'occhio.\r\nInoltre \u00e8 possibile vedere il Monte Soratte e, nelle giornate piu' limpide, si puo' ammirare Roma con la Cupola di San Pietro\r\n\r\nIl punto panoramico \u00e8 facilmente raggiungibile a piedi dal centro del paese, quindi preparati a essere sorpreso dalla vista che ti attende. Che tu sia in cerca di un'escursione romantica, una gita con amici o un momento di tranquillit\u00e0, Casperia ha tanto da offrire. Pianifica la tua visita e scopri perch\u00e9 questo angolo della Sabina \u00e8 considerato uno dei segreti meglio custoditi della regione.\r\n\r\nIl punto panoramico di Casperia non \u00e8 solo una finestra aperta sul mondo naturale, ma anche un luogo di riflessione e serenit\u00e0, dove lasciarsi affascinare dal fascino senza tempo del paesaggio sabino. Perfetto per gli appassionati di fotografia o per chi semplicemente desidera una pausa dalla vita quotidiana.[\/vc_column_text][vc_empty_space height=\"30px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"1\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"15299\"][vc_empty_space height=\"35px\"][\/vc_column][\/vc_row]","post_title":"Punto panoramico Casperia","post_link":"https:\/\/geosabina.it\/altri-comuni\/punto-panoramico-casperia\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Punto panoramico Casperia\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/punto-panoramico-casperia-300x169.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1727081737106{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1716452714894{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\":338,\"to_translate\":{\"en\":338}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via XII Ottobre, 4, 02034 Montopoli di Sabina RI, Italia","%_wpgmp_location_city%":"Montopoli di Sabina","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.3376593","%_wpgmp_metabox_longitude%":"12.66965692","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"8\";i:3;s:2:\"19\";i:4;s:2:\"35\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"11\";}","%_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","%_yoast_wpseo_focuskw%":"Punto panoramico Casperia","%_yoast_wpseo_metadesc%":"Se stai cercando un luogo incantevole per ammirare la bellezza della Sabina, il punto panoramico di Casperia \u00e8 una tappa obbligata. Situato nel cuore di questo affascinante borgo medievale, offre una vista mozzafiato sulla campagna circostante, con i suoi dolci colli e i vigneti che si estendono a perdita d'occhio.","%_yoast_wpseo_linkdex%":"72","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"15299","%_dp_original%":"13368","%_edit_lock%":"1727089018:6","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png"},"id":15283,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png","name":"Punti Panoramici \/ Viewpoints","id":"11","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Il Borgo di Casperia","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Il Borgo di Casperia\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/Immagine-2024-09-20-171331-300x169.webp\" 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\/casperia\/il-borgo-di-casperia\/\" class=\"fc-post-link\">Il Borgo di Casperia<\/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 Mazzini, 35, 02041 Casperia RI, Italia","location":{"lat":"42.33875687095004","city":"Casperia","state":"Lazio","country":"Italia","lng":"12.669907894442769","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/casperia\/il-borgo-di-casperia\/","zoom":18,"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]Le origini di <strong>Casperia<\/strong> affondano le radici nell'antichit\u00e0. Citata nell'<strong>Eneide di Virgilio<\/strong> e descritta dall'illustre storico tedesco<strong> Ferdinand Gregorovius<\/strong> nel 1861, Casperia <strong>ha cambiato nome nel 1947<\/strong>: fino a quell'anno era conosciuta come<strong> Aspra<\/strong> <strong>Sabina.<\/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 gap=\"20\" 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=\"15082\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/casperia\/\"][\/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%2FP.za%2Bdel%2BMunicipio%2C%2B02041%2BCasperia%2BRI%2F%4042.3386997%2C12.6690388%2C19z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132f05a0e791d035%3A0x806f950f97a733b3!8m2!3d42.3386997!4d12.6696825!16s%252Fg%252F11qyw0fp9q%3Fentry%3Dttu%26g_ep%3DEgoyMDI0MDkxNi4wIKXMDSoASAFQAw%253D%253D|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>Il Borgo di <strong>Casperia<\/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_1726843515397{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]P.za del Municipio,\r\n02041 Casperia 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_1726843445285{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<b>Sempre aperto<\/b>[\/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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_btn title=\"Vai al sito web della Chiesa\" color=\"chino\" size=\"xs\" align=\"left\" i_icon_fontawesome=\"fas fa-share-square\" add_icon=\"true\" link=\"url:http%3A%2F%2Fwww.parrocchiacasperia.org%2Fla-parrocchia%2Fchiesa-della-ss-annunziata%2F|target:_blank\" css=\".vc_custom_1725965006131{margin-top: 12px !important;}\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Le origini di <strong>Casperia<\/strong> affondano le radici nell'antichit\u00e0. Citata nell'<strong>Eneide di Virgilio<\/strong> e descritta dall'illustre storico tedesco<strong> Ferdinand Gregorovius<\/strong> nel 1861, Casperia <strong>ha cambiato nome nel 1947<\/strong>: fino a quell'anno era conosciuta come<strong> Aspra<\/strong> <strong>Sabina<\/strong>, probabilmente in riferimento alla conformazione aspra e impervia del territorio,<strong> caratterizzato dal Monte Aspra su cui si erge.<\/strong>\r\n\r\nCamminare per le stradine di Casperia significa immergersi in un borgo medievale rimasto intatto nei secoli. Il centro storico, a forma di \"bulbo di cipolla\", \u00e8 un labirinto di vicoli concentrici che si restringono man mano che ci si avvicina alla sommit\u00e0, dove domina la suggestiva <strong>Piazza San Giovanni Battista<\/strong>, affiancata dall'omonima <strong>chiesa parrocchiale.<\/strong>\r\n\r\nUna delle caratteristiche pi\u00f9 apprezzate di Casperia \u00e8 la totale pedonalizzazione del borgo: le auto sono bandite dal centro, permettendo ai visitatori di godere appieno <strong>dell'atmosfera senza tempo<\/strong> del luogo. La pulizia impeccabile delle strade e degli angoli contribuisce ulteriormente al fascino di questo antico borgo.\r\n\r\n[\/vc_column_text][vc_empty_space height=\"30px\"][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=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"15332,15339,15345,15337\"][vc_empty_space height=\"30px\"][vc_column_text]L'ingresso al borgo avviene attraverso due porte principali: <strong>Porta S. Maria a nord-est e Porta Romana a ovest.<\/strong> Queste aperture nelle mura medievali testimoniano l'importanza storica e difensiva di Casperia fin dai tempi dell'XI secolo, quando venne eretta la prima <strong>cinta muraria<\/strong>. Gli abitanti, chiamati<strong> \"Aspresi\"<\/strong>, erano cos\u00ec legati alla cura delle mura che gli statuti del 1397 prevedevano addirittura <strong>la pena di morte<\/strong> per chi avesse aperto varchi sufficienti <strong>al passaggio di una persona.<\/strong>\r\n\r\nDa via Garibaldi, passando sotto <strong>l'Arco di Mezzo e l'Arco Vecchio<\/strong>, \u00e8 possibile percorrere un itinerario che regala una vista mozzafiato sulla valle del Tevere, sul <strong>Monte Soratte e sui Monti Sabini.<\/strong>\r\n\r\nIl punto pi\u00f9 alto del borgo ospita la Chiesa di <strong>San Giovanni Battista<\/strong>, ampliata nel Cinquecento e ristrutturata nel Settecento in stile barocco. La chiesa conserva affreschi del Trecento e una pala d\u2019altare del <strong>1524 di Giacomo Santoro<\/strong>. Da non perdere anche il monumentale presepe, opera di Giannicola Mariani.\r\n\r\nTra gli altri edifici di interesse,\u00a0il <strong>Palazzo Forani<\/strong>, anch'esso del XVII secolo, che arricchiscono ulteriormente il patrimonio architettonico e storico del borgo. La parte pi\u00f9 storica, ricca di affreschi e decorazioni del XVIII e XIX secolo, \u00e8 aperta ai visitatori del Palazzo. Qui \u00e8 possibile esplorare oltre trenta stanze, ciascuna arredata con mobili e dettagli che riflettono i vari stili storici, dal classico stile impero fino all'eleganza del dec\u00f2.[\/vc_column_text][vc_empty_space height=\"30px\"][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=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"15343,15341,15332,15330\"][vc_empty_space height=\"30px\"][\/vc_column][\/vc_row]","post_title":"Il Borgo di Casperia","post_link":"https:\/\/geosabina.it\/casperia\/il-borgo-di-casperia\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Il Borgo di Casperia\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/Immagine-2024-09-20-171331-300x169.webp\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1726843515397{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1726843445285{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_1725965006131{margin-top: 12px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":502,\"to_translate\":{\"en\":502}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Mazzini, 35, 02041 Casperia RI, Italia","%_wpgmp_location_city%":"Casperia","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.33875687095004","%_wpgmp_metabox_longitude%":"12.669907894442769","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"35\";}","%_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","%_yoast_wpseo_focuskw%":"Il Borgo di Casperia","%_yoast_wpseo_metadesc%":"Le origini di Casperia affondano le radici nell'antichit\u00e0. Citata nell'Eneide di Virgilio e descritta dall'illustre storico tedesco Ferdinand Gregorovius nel 1861.","%_yoast_wpseo_linkdex%":"65","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"15445","%_yoast_wpseo_title%":"%%title%% Casperia %%page%% %%sep%% %%sitename%%","%_dp_original%":"15111","%_edit_lock%":"1727263720:2","%_edit_last%":"2","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png"},"id":15320,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png","name":"Borghi e Centri Storici \/ Villages and Historical Centers","id":"2","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Punto panoramico Castelnuovo di Farfa","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Punto panoramico Castelnuovo di Farfa\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/SAVE_20240916_134629-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\/altri-comuni\/punto-panoramico-per-castelnuovo-di-farfa\/\" class=\"fc-post-link\">Punto panoramico Castelnuovo di Farfa<\/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 del Popolo, 2, 02032 Fara In Sabina RI, Italia","location":{"lat":"42.220417","city":"Fara in Sabina","state":"Lazio","country":"Italia","lng":"12.723000","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/punto-panoramico-per-castelnuovo-di-farfa\/","zoom":18,"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]Immerso nel cuore della Sabina questo punto panoramico situato a circa 400 m dall'Abbazia di Farfa, offre numerosi panorami e un incantevole vista su <strong>Castelnuovo di Farfa<\/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 gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\"][vc_empty_space height=\"25px\"][\/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%2Fdir%2F%2F6PCF%252B566%2C%2B02032%2BFara%2BIn%2BSabina%2BRI%2F%4042.2204164%2C12.7204407%2C17z%2Fdata%3D!4m9!4m8!1m0!1m5!1m1!1s0x132f0b93eba216f7%3A0x64d80a801d5bc950!2m2!1d12.7230156!2d42.2204125!3e0%3Fentry%3Dttu%26g_ep%3DEgoyMDI0MDkxMS4wIKXMDSoASAFQAw%253D%253D|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>Punto panoramico <strong>Castelnuovo di Farfa<\/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_1726592691160{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]400m dall'Abbazia di Farfa\r\n02032 <strong>Fara Sabina<\/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_1716452714894{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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Immerso nel cuore della Sabina questo punto panoramico situato a circa 400 m dall'<a href=\"https:\/\/geosabina.it\/altri-comuni\/abbazia-di-farfa\/\">Abbazia di Farfa<\/a>, offre numerosi panorami e un incantevole vista su <strong>Castelnuovo di Farfa, <\/strong>un borgo, ricco di storia e tradizione e punto di partenza ideale per esplorare un territorio dove la natura si esprime in tutta la sua bellezza.\r\n\r\nDal punto raggiungibile tramite le \"indicazioni stradali\" fornite e proseguendo a piedi lungo la strada, lo sguardo si perde tra distese di verde che, a seconda delle stagioni, mutano colore creando uno spettacolo naturale sempre diverso. I tramonti, con le loro sfumature calde, tingono il paesaggio di oro e arancio, offrendo momenti perfetti per foto indimenticabili o semplicemente per fermarsi e respirare.\r\n\r\nGuardando verso l'orizzonte, le colline si trasformano gradualmente nei <strong>Monti Sabini<\/strong>, che fanno da cornice naturale al paese. Qui, il connubio tra terra e cielo diventa magico, trasmettendo una sensazione di pace e connessione con la natura.[\/vc_column_text][vc_empty_space height=\"30px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"2\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"15219,15223\"][vc_column_text]Le foto della gallery sono state realizzate in collaborazione con il\u00a0<a href=\"https:\/\/www.facebook.com\/groups\/45975827398\" target=\"_blank\" rel=\"noopener\">gruppo Facebook \u201cFoto della Sabina\u201d<\/a>\u00a0a cura di\u00a0<a href=\"https:\/\/www.facebook.com\/FabrizioMei72\/\" target=\"_blank\" rel=\"noopener\">Fabrizio Mei.<\/a>[\/vc_column_text][vc_empty_space height=\"35px\"][vc_row_inner][vc_column_inner css=\".vc_custom_1716459725229{margin-top: 4px !important;margin-bottom: 2px !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;}\"][vc_text_separator title=\"Cosa vedrai\" i_icon_fontawesome=\"fas fa-camera-retro\" 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\" css=\".vc_custom_1718294263156{margin-top: -18px !important;}\"][vc_column_text]<span style=\"color: #868686; font-size: 15px;\">Tramite il punto indicato sulla mappa, \u00e8 possibile scattare meravigliose <\/span><strong style=\"color: #868686; font-size: 15px;\">foto<\/strong><span style=\"color: #868686; font-size: 15px;\"> e godere dei <\/span><strong style=\"color: #868686; font-size: 15px;\">bellissimi panorami<\/strong><span style=\"color: #868686; font-size: 15px;\"> che questo posto ha da offrire. <\/span><span style=\"color: #868686; font-size: 15px;\">Da questo punto panoramico possiamo ammirare i Monti Sabini e i paesi vicino orientandosi anche grazie alla splendida foto scattata da Fabrizio Mei e riportata in basso:<\/span>[\/vc_column_text][vc_empty_space height=\"20px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"1\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"15221\"][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row]","post_title":"Punto panoramico Castelnuovo di Farfa","post_link":"https:\/\/geosabina.it\/altri-comuni\/punto-panoramico-per-castelnuovo-di-farfa\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Punto panoramico Castelnuovo di Farfa\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/SAVE_20240916_134629-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1726592691160{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1716452714894{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1716459725229{margin-top: 4px !important;margin-bottom: 2px !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;}.vc_custom_1718294263156{margin-top: -18px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":322,\"to_translate\":{\"en\":322}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via del Popolo, 2, 02032 Fara In Sabina RI, Italia","%_wpgmp_location_city%":"Fara in Sabina","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.220417","%_wpgmp_metabox_longitude%":"12.723000","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:4:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"19\";i:3;s:2:\"24\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"11\";}","%_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","%_yoast_wpseo_focuskw%":"Punto panoramico Castel Nuovo di Farfa","%_yoast_wpseo_metadesc%":"Immerso nel cuore della Sabina questo punto panoramico situato a circa 400 m dall'Abbazia di Farfa, offre numerosi panorami e un incantevole vista su Castelnuovo di Farfa.","%_yoast_wpseo_linkdex%":"65","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"15221","%_dp_original%":"13137","%_edit_lock%":"1726593847:4","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png"},"id":15216,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png","name":"Punti Panoramici \/ Viewpoints","id":"11","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Chiesa di San Giovanni Battista di Casperia","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 di Casperia\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/Chiesa-di-San-Giovanni-Battista-di-Casperia-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\/casperia\/chiesa-di-san-giovanni-battista-di-casperia\/\" class=\"fc-post-link\">Chiesa di San Giovanni Battista di Casperia<\/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":"Vicolo dell' Oratorio, 6, 02041 Casperia RI, Italia","location":{"lat":"42.33861589366132","city":"Casperia","state":"Lazio","country":"Italia","lng":"12.669803893254107","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/casperia\/chiesa-di-san-giovanni-battista-di-casperia\/","zoom":18,"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 Giovanni Battista<\/strong> di Casperia \u00e8 una delle principali attrazioni del borgo medievale. Situata sulla sommit\u00e0 del colle, questa chiesa cinquecentesca domina l'intero paesaggio del paese. Un aspetto caratteristico \u00e8 la <strong>torre campanaria romanica<\/strong> del XIII secolo.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"15082\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/casperia\/\"][\/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%2Fplace%2FChiesa%2Bdi%2BSan%2BGiovanni%2BBattista%2F%4042.3385944%2C12.6698046%2C713m%2Fdata%3D!3m2!1e3!4b1!4m6!3m5!1s0x132f05a0dd761eb1%3A0x815c4e7bad53dba2!8m2!3d42.3385944!4d12.6698046!16s%252Fg%252F11b90d9__8%3Fentry%3Dttu%26g_ep%3DEgoyMDI0MDkwNC4wIKXMDSoASAFQAw%253D%253D\" 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 Giovanni Battista\u00a0<\/strong>di Casperia<\/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_1725983762122{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]02041 Casperia 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_1726842049137{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Attualmente chiuso per restauro[\/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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_btn title=\"Vai al sito web della Chiesa\" color=\"chino\" size=\"xs\" align=\"left\" i_icon_fontawesome=\"fas fa-share-square\" add_icon=\"true\" link=\"url:http%3A%2F%2Fwww.parrocchiacasperia.org%2Fla-parrocchia%2Fchiesa-di-s-giovanni-battista%2F|target:_blank\" css=\".vc_custom_1725982349637{margin-top: 12px !important;}\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]La <strong>Chiesa di San Giovanni Battista<\/strong> di Casperia \u00e8 una delle principali attrazioni del borgo medievale. Situata sulla sommit\u00e0 del borgo antico, questa chiesa cinquecentesca domina l'intero paesaggio del paese. Un aspetto caratteristico \u00e8 la <strong>torre campanaria romanica<\/strong> del XIII secolo, facilmente riconoscibile per la sua struttura e decorazioni, come le bifore e gli affreschi risalenti al XIV secolo. Nel 1934, l'ultima loggia della torre \u00e8 stata modificata per includere un serbatoio dell'acquedotto, un elemento funzionale inserito nel contesto storico.\r\n\r\nL\u2019edificio ha subito numerosi restauri nel corso dei secoli. Il primo grande intervento risale al 1515, mentre la ristrutturazione del 1791 ha introdotto elementi in stile barocco che si possono ammirare ancora oggi.[\/vc_column_text][vc_empty_space height=\"30px\"][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=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"15317\"][vc_empty_space height=\"30px\"][vc_column_text]<strong>All'interno<\/strong>, la chiesa ha una pianta a tre navate. Sull'altare maggiore spicca una pala del 1524, opera di Giacomo Santoro, noto come Jacopo Siculo, che raffigura il Battesimo di Ges\u00f9. Sotto il dipinto principale si trovano le immagini di Ges\u00f9 e degli Apostoli.\r\n\r\nNella navata sinistra \u00e8 conservato un affresco del XVI secolo che rappresenta la Madonna col Bambino, insieme a Sant'Antonio Abate e San Giuseppe. Nella navata destra, una tela che raffigura San Martino fa da cornice a un'edicola che custodisce una statua lignea di San Sebastiano, realizzata e dipinta nel XVII secolo.\r\n\r\nInfine, all'interno della chiesa si trova un <strong>imponente organo<\/strong>, acquistato dalla comunit\u00e0 nel 1600 in occasione del giubileo.[\/vc_column_text][vc_empty_space][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_1726841757423{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>IL PRESEPE MONUMENTALE<\/b><\/h4>\r\nNei locali della sacrestia \u00e8 conservato un presepe monumentale, realizzato a mano da <strong>Giannicola Mariani<\/strong>, raffigurante una \u201c<strong>Casperia in miniatura<\/strong>\u201d.\r\n\r\nIl presepe, realizzato in 10 anni di lavoro che copre circa <strong>60 mq <\/strong>in scala 1:1, con 80 statuine e 10 scorci di Casperia, <strong>ha ottenuto il riconoscimento di \u201cMeraviglia Italiana\u201d.<\/strong>[\/vc_column_text][vc_empty_space height=\"30px\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"Chiesa di San Giovanni Battista di Casperia","post_link":"https:\/\/geosabina.it\/casperia\/chiesa-di-san-giovanni-battista-di-casperia\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chiesa di San Giovanni Battista di Casperia\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/Chiesa-di-San-Giovanni-Battista-di-Casperia-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1725983762122{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1726842049137{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_1725982349637{margin-top: 12px !important;}.vc_custom_1726841757423{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\":401,\"to_translate\":{\"en\":401}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Vicolo dell' Oratorio, 6, 02041 Casperia RI, Italia","%_wpgmp_location_city%":"Casperia","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.33861589366132","%_wpgmp_metabox_longitude%":"12.669803893254107","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"35\";}","%_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","%_yoast_wpseo_focuskw%":"Chiesa della Santissima Annunziata","%_yoast_wpseo_metadesc%":"La Chiesa di San Giovanni Battista a Casperia \u00e8 situata sulla sommit\u00e0 del borgo antico, questa chiesa cinquecentesca domina l'intero paesaggio del paese.","%_yoast_wpseo_linkdex%":"47","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"15315","%_dp_original%":"15111","%_edit_lock%":"1726844500:4","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png"},"id":15154,"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 della Santissima Annunziata","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 della Santissima Annunziata\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/casperia-chiesa-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\/casperia\/chiesa-della-santissima-annunziata\/\" class=\"fc-post-link\">Chiesa della Santissima Annunziata<\/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":"P.za Oddo Valeriani, 2, 02041 Casperia RI, Italia","location":{"lat":"42.3369249","city":"Casperia","state":"Lazio","country":"Italia","lng":"12.6701332","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/casperia\/chiesa-della-santissima-annunziata\/","zoom":18,"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 della Santissima Annunziata di Casperia, rappresenta uno degli edifici religiosi pi\u00f9 importanti e antichi del paese, ricca di storia e arte. La chiesa fu fondata nel XIII secolo e sub\u00ec diverse modifiche e ristrutturazioni nel corso dei secoli, in particolare durante il XVI e XVII secolo. Le trasformazioni rispecchiano le evoluzioni stilistiche dell'epoca[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"15082\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/casperia\/\"][\/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%2Fplace%2FChiesa%2Bdella%2BSantissima%2BAnnunziata%2F%4042.3369315%2C12.6698424%2C118m%2Fdata%3D!3m1!1e3!4m15!1m8!3m7!1s0x132f05a6b918245d%3A0x982d52f1937e6f4a!2s02041%2BCasperia%2BRI!3b1!8m2!3d42.3371379!4d12.6700926!16zL20vMGdtNTE3!3m5!1s0x132f05a04e58b42d%3A0x963348110a5cb7e0!8m2!3d42.3367661!4d12.6698837!16s%252Fg%252F11j1fhkf2n%3Fauthuser%3D0%26entry%3Dttu%26g_ep%3DEgoyMDI0MDkwNC4wIKXMDSoASAFQAw%253D%253D|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>Chiesa della <strong>Santissima Annunziata<\/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_1725964326852{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]P.za Oddo Valeriani, 2\r\n02041 Casperia 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_1725964287506{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Dal Luned\u00ec al Sabato:<\/strong>\r\nore 18.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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_btn title=\"Vai al sito web della Chiesa\" color=\"chino\" size=\"xs\" align=\"left\" i_icon_fontawesome=\"fas fa-share-square\" add_icon=\"true\" link=\"url:http%3A%2F%2Fwww.parrocchiacasperia.org%2Fla-parrocchia%2Fchiesa-della-ss-annunziata%2F|target:_blank\" css=\".vc_custom_1725965006131{margin-top: 12px !important;}\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]La <strong>Chiesa della Santissima Annunziata<\/strong> di Casperia (ancora oggi chiamata dagli Aspresi \u201c<strong>chiesa nuova<\/strong>\u201c), rappresenta uno degli edifici religiosi pi\u00f9 importanti e antichi del paese, ricca di storia e arte.\r\n\r\nLa chiesa fu fondata nel XIII secolo e sub\u00ec diverse modifiche e ristrutturazioni nel corso dei secoli, in particolare durante il XVI e XVII secolo. Le trasformazioni rispecchiano le evoluzioni stilistiche dell'epoca, con influenze gotiche, rinascimentali e barocche.\r\n\r\nLa struttura architettonica della Chiesa della Santissima Annunziata presenta elementi tipici dello stile medievale, ma le successive ristrutturazioni l'hanno arricchita di dettagli barocchi. La facciata \u00e8 sobria, con un portale principale e una semplice finestra centrale che illuminava l'interno. L'interno della chiesa, in stile barocco, \u00e8 caratterizzato da decorazioni in stucco e altari laterali riccamente ornati.[\/vc_column_text][vc_empty_space height=\"30px\"][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=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"15098,15122,15124,15126,15128\"][vc_empty_space height=\"30px\"][vc_column_text]All'interno della chiesa, si possono ammirare alcune importanti opere d'arte. Vi sono affreschi e dipinti che raffigurano scene religiose, tra cui l'Annunciazione, tema principale della chiesa, oltre a immagini di santi venerati localmente. Alcune di queste opere risalgono al Rinascimento e sono attribuite a scuole artistiche locali.\r\n\r\nNel corso della sua storia, la chiesa \u00e8 stata un punto di riferimento spirituale e sociale per la comunit\u00e0 di Casperia. Ancora oggi, la Santissima Annunziata \u00e8 utilizzata per funzioni religiose e celebrazioni, come le processioni in onore della Vergine Maria. \u00c8 anche un luogo di attrazione per i turisti che visitano Casperia, attratti dal fascino storico e artistico del borgo e della chiesa stessa.[\/vc_column_text][vc_empty_space height=\"45px\"][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\" css=\".vc_custom_1726845957747{margin-left: 16px !important;}\"][vc_row_inner css=\".vc_custom_1726845289163{border-right-width: 1px !important;border-bottom-width: 1px !important;border-left-width: 1px !important;}\"][vc_column_inner css=\".vc_custom_1726845896409{margin-top: -20px !important;margin-right: 16px !important;margin-left: 16px !important;border-right-width: 2px !important;border-bottom-width: 2px !important;border-left-width: 2px !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-bottom-color: #81d742 !important;border-bottom-style: solid !important;}\"][vc_column_text css=\".vc_custom_1726845718979{border-top-width: 0px !important;border-right-width: 2px !important;border-bottom-width: 2px !important;border-left-width: 2px !important;padding-top: 0px !important;border-left-color: #81d742 !important;border-right-color: #81d742 !important;border-top-color: #81d742 !important;border-bottom-color: #81d742 !important;}\"]\r\n<h4><b>LA TELA DELL\u2019ANNUNCIAZIONE<\/b><\/h4>\r\nLa Chiesa della Ss. Annunziata ospita sul proprio altare maggiore <strong>l\u2019\u00abAnnunciazione\u00bb di Giovan Battista Salvi<\/strong> detto <strong>il Sassoferrato<\/strong>, pittore marchigiano nato nel 1609 e morto a Roma nel 1685. Il dipinto su tela, esemplificativo della raffinata e antichizzante maniera dell\u2019artista \u00e8 stata completamente ristrutturata nel corso del 2020.[\/vc_column_text][vc_empty_space height=\"30px\"][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=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"15353,15351,15122,15355\"][vc_empty_space height=\"30px\"][\/vc_column_inner][vc_column_inner][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"Chiesa della Santissima Annunziata","post_link":"https:\/\/geosabina.it\/casperia\/chiesa-della-santissima-annunziata\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chiesa della Santissima Annunziata\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/casperia-chiesa-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1726845957747{margin-left: 16px !important;}.vc_custom_1726845289163{border-right-width: 1px !important;border-bottom-width: 1px !important;border-left-width: 1px !important;}.vc_custom_1725964326852{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1725964287506{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_1725965006131{margin-top: 12px !important;}.vc_custom_1726845896409{margin-top: -20px !important;margin-right: 16px !important;margin-left: 16px !important;border-right-width: 2px !important;border-bottom-width: 2px !important;border-left-width: 2px !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-bottom-color: #81d742 !important;border-bottom-style: solid !important;}.vc_custom_1726845718979{border-top-width: 0px !important;border-right-width: 2px !important;border-bottom-width: 2px !important;border-left-width: 2px !important;padding-top: 0px !important;border-left-color: #81d742 !important;border-right-color: #81d742 !important;border-top-color: #81d742 !important;border-bottom-color: #81d742 !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":425,\"to_translate\":{\"en\":425}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"P.za Oddo Valeriani, 2, 02041 Casperia RI, Italia","%_wpgmp_location_city%":"Casperia","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.3369249","%_wpgmp_metabox_longitude%":"12.6701332","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"35\";}","%_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","%_yoast_wpseo_focuskw%":"Chiesa della Santissima Annunziata","%_yoast_wpseo_metadesc%":"La Chiesa della Santissima Annunziata di Casperia, rappresenta uno degli edifici religiosi pi\u00f9 importanti e antichi del paese, ricca di storia e arte.","%_yoast_wpseo_linkdex%":"70","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"15115","%_dp_original%":"6982","%_edit_lock%":"1727262701:2","%_edit_last%":"2","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Casperia","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png"},"id":15111,"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":"Birrificio Sabino","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Birrificio Sabino\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/birrificio_sabino-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\/sostenitori\/birrificio-sabino\/\" class=\"fc-post-link\">Birrificio Sabino<\/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 Fonte Cupido, 3, 02047 Misericordia RI, Italia","location":{"lat":"42.25816859792545","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.67449307777099","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/sostenitori\/birrificio-sabino\/","zoom":18,"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\u00a0<strong>Birrificio Sabino<\/strong>\u00a0non \u00e8 solo un luogo di produzione di\u00a0<strong>birra artigianale di qualit\u00e0<\/strong>; \u00e8 un progetto che cresce con l\u2019ambizione di rivalutare e promuovere la regione della\u00a0<strong>Sabina<\/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 gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner][vc_empty_space height=\"40px\"][vc_single_image image=\"14854\" img_size=\"full\" alignment=\"center\" onclick=\"custom_link\" css_animation=\"none\" el_class=\"birrificio\"][vc_empty_space height=\"25px\"][\/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%2FBirrificio%2BSabino%2F%4042.2581141%2C12.6719004%2C820m%2Fdata%3D!3m2!1e3!4b1!4m6!3m5!1s0x132f0ef1eeae84df%3A0x2990df29e7a66b88!8m2!3d42.2581102!4d12.6744753!16s%252Fg%252F11g88hdh86%3Fentry%3Dttu%26g_ep%3DEgoyMDI0MDgyOC4wIKXMDSoASAFQAw%253D%253D|target:_blank\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner][vc_column_inner][vc_empty_space height=\"40px\"][vc_single_image image=\"14964\" img_size=\"full\" alignment=\"center\" onclick=\"custom_link\" css_animation=\"none\" el_class=\"birrificio\"][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><strong>Birrificio Sabino<\/strong><\/h2>\r\n[\/vc_column_text][vc_column_text css=\".vc_custom_1725380308310{margin-top: -10px !important;}\"]\r\n<h4>Passione, Tradizione e Innovazione nella Sabina<\/h4>\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_1725379488571{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Fonte Cupido, Lotto n.3\r\nLoc. Misericordia\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\/info-1.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Info e Contatti<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1725379268060{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Tel.<\/strong> 339.2305030\r\n<strong>Mail<\/strong> birrificio.sabino@gmail.com\r\n<strong>Web<\/strong> <a href=\"https:\/\/www.birrificiosabino.com\/\" target=\"_blank\" rel=\"noopener\">birrificiosabino.com<\/a>[\/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 Beer Garden<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1725379289701{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Gioved\u00ec<\/strong> 19:00\/02:00\r\n<strong>Venerd\u00ec<\/strong> 19:00\/02:00\r\n<strong>Sabato<\/strong> 19:00\/02:00\r\n<strong>Domenica<\/strong> 19:00\/02:00[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Nato nel <strong>2016<\/strong> dalla <strong>passione per la birra artigianale<\/strong> e dal desiderio di indipendenza di due giovani amici, il <strong>Birrificio Sabino<\/strong> \u00e8 l'espressione della creativit\u00e0 e dell'amore per il proprio territorio. Iniziando con semplici attrezzature da homebrewing, i fondatori hanno rapidamente trasformato la loro curiosit\u00e0 in un'arte raffinata, spinti da una cura ossessiva dei dettagli e da un incessante desiderio di sperimentazione.\r\n\r\nIl <strong>Birrificio Sabino<\/strong> non \u00e8 solo un luogo di produzione di <strong>birra artigianale di qualit\u00e0<\/strong>; \u00e8 un progetto che cresce con l'ambizione di rivalutare e promuovere la regione della <strong>Sabina<\/strong>, un territorio ricco di storia e cultura, da cui il birrificio prende il nome. L'obiettivo \u00e8 chiaro: \"diffondere il verbo\" della birra di qualit\u00e0, facendo conoscere e apprezzare i loro prodotti unici a un pubblico sempre pi\u00f9 vasto.[\/vc_column_text][vc_empty_space height=\"30px\"][vc_empty_space height=\"30px\"][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=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"14897,14899,14901,14911\"][vc_empty_space height=\"35px\"][vc_column_text]La filosofia di produzione del Birrificio Sabino \u00e8 stata ben delineata sin dall'inizio. Gi\u00e0 dalle prime birre prodotte come homebrewing, si \u00e8 sempre ricercato l'equilibrio, la semplicit\u00e0 e la grande bevibilit\u00e0. Col tempo, le conoscenze e soprattutto gli strumenti sono cambiati e migliorati, portando alla produzione di birre nuove e stravaganti, ma sempre legate a quei saldi principi iniziali.\r\n<h3>Linee di Birra<\/h3>\r\n[\/vc_column_text][vc_empty_space height=\"15px\"][vc_row_inner][vc_column_inner css=\".vc_custom_1725381782779{margin-top: 0px !important;margin-bottom: 2px !important;border-top-width: 0px !important;border-right-width: 0px !important;border-bottom-width: 0px !important;border-left-width: 4px !important;padding-top: 0px !important;padding-right: 16px !important;padding-bottom: 16px !important;padding-left: 16px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;border-right-color: #ffe500 !important;border-right-style: solid !important;border-top-color: #ffe500 !important;border-top-style: solid !important;border-bottom-color: #ffe500 !important;border-bottom-style: solid !important;}\"][vc_column_text]<strong>LE CLASSICHE:<\/strong>\u00a0sono quelle birre sempre disponibili, in produzione fissa tutti i mesi dell\u2019anno.\r\n\r\n<strong>LE STAGIONALI:<\/strong>\u00a0come suggerisce il nome, sono birre che vengono prodotte una volta o pi\u00f9 all\u2019anno, ma sempre all\u2019interno della stessa stagione.\r\n\r\n<strong>LA cantina:<\/strong>\u00a0nata nei primi mesi del 2018, \u00e8 il luogo pi\u00f9 mistico del birrificio, dove si sperimenta con lieviti selvaggi, batteri lattici, e fermentazioni spontanee.\r\n\r\n<strong>Belgian style:<\/strong>\u00a0racchiude lo sconfinato amore per il Belgio dei fondatori del birrificio e la sua tradizione brassicola, caratterizzate dalla linea grafica del piccolo principe.\r\n\r\n<strong>LE GOSE:<\/strong>\u00a0il progetto pi\u00f9 anticonvenzionale, con l\u2019idea di produrre Gose con la frutta, andando a legare la parte sapida e lattica di quest\u2019ultime con la freschezza e la dolcezza della frutta.[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"20px\"][vc_column_text]Parallelamente, nel <strong>2020<\/strong> nasce l'idea di \"<strong>Sabino Distillati<\/strong>\", un progetto ambizioso che ha preso forma nella stessa sede del birrificio, evolvendosi da una passione amatoriale per la distillazione insieme agli amici del Birrificio Maccardi. Con una solida esperienza nel campo delle fermentazioni e una profonda conoscenza degli spiriti, il team di Sabino ha iniziato a produrre distillati di alta qualit\u00e0, esplorando oltre i confini della birra artigianale.\r\n\r\nOggi, il <strong>Birrificio Sabino<\/strong> e la distilleria rappresentano un fulcro di innovazione e qualit\u00e0, dove la libert\u00e0 creativa incontra la tradizione del buon bere. Con una filosofia che abbraccia la sperimentazione senza limiti, il team continua a esplorare nuove possibilit\u00e0, sempre con l'obiettivo di valorizzare il territorio Sabino.\r\n<h4><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"30px\"][vc_row_inner][vc_column_inner css=\".vc_custom_1716459725229{margin-top: 4px !important;margin-bottom: 2px !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;}\"][vc_text_separator title=\"SABINO BEER GARDEN\" i_icon_fontawesome=\"fas fa-beer\" 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\" css=\".vc_custom_1725379374643{margin-top: -18px !important;}\"][vc_empty_space height=\"20px\"][vc_column_text]Il <strong>Sabino Beer Garden<\/strong> \u00e8 uno spazio all'esterno del birrificio dove vengono servite direttamente tutte le <strong>birre prodotte<\/strong>. Le sei vie del Garden sono attive a seconda delle disponibilit\u00e0, permettendo agli ospiti di assaggiare in anteprima tutte le <strong>uscite stagionali<\/strong>. Per il comparto <strong>food<\/strong>, \u00e8 possibile gustare ottime <strong>pizze cotte in forno a legna<\/strong>, con impasti e condimenti realizzati in loco utilizzando prodotti a <strong>chilometro zero<\/strong>.[\/vc_column_text][vc_empty_space height=\"20px\"][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=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"14907,14903,14905,14909\"][vc_empty_space height=\"20px\"][vc_column_text]Durante la degustazione delle birre, gli ospiti possono rilassarsi ascoltando <strong>buona musica live<\/strong> o, per i pi\u00f9 goliardici, facendo un bagno nella <strong>vasca idromassaggio riscaldata<\/strong>.\r\n\r\nIl Sabino Beer Garden accoglie visitatori tutto l\u2019anno.[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"35px\"][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"Birrificio Sabino","post_link":"https:\/\/geosabina.it\/sostenitori\/birrificio-sabino\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Birrificio Sabino\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/birrificio_sabino-1-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1725380308310{margin-top: -10px !important;}.vc_custom_1725379488571{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1725379268060{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1725379289701{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1725381782779{margin-top: 0px !important;margin-bottom: 2px !important;border-top-width: 0px !important;border-right-width: 0px !important;border-bottom-width: 0px !important;border-left-width: 4px !important;padding-top: 0px !important;padding-right: 16px !important;padding-bottom: 16px !important;padding-left: 16px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;border-right-color: #ffe500 !important;border-right-style: solid !important;border-top-color: #ffe500 !important;border-top-style: solid !important;border-bottom-color: #ffe500 !important;border-bottom-style: solid !important;}.vc_custom_1716459725229{margin-top: 4px !important;margin-bottom: 2px !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;}.vc_custom_1725379374643{margin-top: -18px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":659,\"to_translate\":{\"en\":659}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Fonte Cupido, 3, 02047 Misericordia RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.25816859792545","%_wpgmp_metabox_longitude%":"12.67449307777099","%_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:\"10\";}","%_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","%_yoast_wpseo_focuskw%":"Farfa","%_yoast_wpseo_metadesc%":"Il Birrificio Sabino non \u00e8 solo un luogo di produzione di birra artigianale di qualit\u00e0; \u00e8 un progetto che cresce con l\u2019ambizione di rivalutare e promuovere la regione della Sabina","%_yoast_wpseo_linkdex%":"51","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"14914","%_dp_original%":"12618","%_edit_lock%":"1725451787:4","%_edit_last%":"4","%_wpb_post_custom_css%":".birrificio {\r\n    width:100%;\r\n    max-width:280px;\r\n    margin:auto;\r\n    text-align:center;\r\n}","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/produzione-tipica_sito.png"},"id":14860,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/produzione-tipica_sito.png","name":"Produzione Locale \/ Local Production","id":"10","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Punto panoramico Poggio Catino","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Punto panoramico Poggio Catino\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/08\/poggio_catino-4-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\/altri-comuni\/punto-panoramico-poggio-catino\/\" class=\"fc-post-link\">Punto panoramico Poggio Catino<\/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 Roma, 15, 02040 Poggio Catino RI, Italia","location":{"lat":"42.29455703529942","city":"Poggio Catino","state":"Lazio","country":"Italia","lng":"12.690631087696822","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/punto-panoramico-poggio-catino\/","zoom":18,"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]Da Poggio Catino, un piccolo borgo incastonato tra le colline della Sabina, potrete godere di una vista mozzafiato che abbraccia l'intera valle del Tevere, con i suoi paesaggi pittoreschi, i campi verdi e i boschi rigogliosi che si estendono a perdita d'occhio.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"6151\" img_size=\"full\" alignment=\"center\" css_animation=\"none\"][\/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%2Fplace%2F42%25C2%25B017'41.0%2522N%2B12%25C2%25B041'26.6%2522E%2F%4042.2947395%2C12.6905942%2C19.7z%2Fdata%3D!4m4!3m3!8m2!3d42.2947222!4d12.6907222%3Fentry%3Dttu|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>Punto panoramico <strong>Poggio Catino<\/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_1722660690840{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Roma, 15\r\n02040 Poggio Catino (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_1716452714894{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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Da <strong>Poggio Catino<\/strong>, un piccolo borgo incastonato tra le colline della <strong>Sabina<\/strong>, potrete godere di una vista mozzafiato che abbraccia l'intera <strong>valle del Tevere<\/strong>, con i suoi paesaggi pittoreschi, i campi verdi e i boschi rigogliosi che si estendono a perdita d'occhio.\r\n\r\nIl panorama che si apre davanti ai vostri occhi \u00e8 un vero e proprio <strong>quadro naturale<\/strong>. In lontananza, \u00e8 possibile scorgere il profilo maestoso del <strong>Monte Soratte <\/strong>e nelle giornate limpide, la vista pu\u00f2 spaziare fino alla <strong>Citt\u00e0 di Roma. <\/strong>\u00a0Durante il tramonto, i colori caldi del sole che cala dietro le colline creano uno spettacolo di luci e ombre che vi lascer\u00e0 senza fiato.[\/vc_column_text][vc_empty_space height=\"30px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"3\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"14603,14607,14609\"][vc_column_text]Le foto della gallery sono state realizzate in collaborazione con il\u00a0<a href=\"https:\/\/www.facebook.com\/groups\/45975827398\" target=\"_blank\" rel=\"noopener\">gruppo Facebook \u201cFoto della Sabina\u201d<\/a>\u00a0a cura di\u00a0<a href=\"https:\/\/www.facebook.com\/FabrizioMei72\/\" target=\"_blank\" rel=\"noopener\">Fabrizio Mei.<\/a>[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Punto panoramico Poggio Catino","post_link":"https:\/\/geosabina.it\/altri-comuni\/punto-panoramico-poggio-catino\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Punto panoramico Poggio Catino\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/08\/poggio_catino-4-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1722660690840{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1716452714894{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\":269,\"to_translate\":{\"en\":269}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Roma, 15, 02040 Poggio Catino RI, Italia","%_wpgmp_location_city%":"Poggio Catino","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.29455703529942","%_wpgmp_metabox_longitude%":"12.690631087696822","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:4:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"19\";i:3;s:2:\"34\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"11\";}","%_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","%_yoast_wpseo_focuskw%":"Punto panoramico Poggio Catino","%_yoast_wpseo_metadesc%":"Da Poggio Catino, un piccolo borgo incastonato tra le colline della Sabina, potrete godere di una vista mozzafiato che abbraccia l'intera valle del Tevere, con i suoi paesaggi pittoreschi, i campi verdi e i boschi rigogliosi che si estendono a perdita d'occhio.","%_yoast_wpseo_linkdex%":"64","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"14605","%_dp_original%":"13004","%_edit_lock%":"1723111758:4","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png"},"id":14601,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png","name":"Punti Panoramici \/ Viewpoints","id":"11","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Castello Orsini-Cesi","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Castello Orsini-Cesi\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/castello_orsini_cesi-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\/altri-comuni\/castello-orsini-cesi\/\" class=\"fc-post-link\">Castello Orsini-Cesi<\/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 delle Torri, 32, 00010 Sant'Angelo Romano RM, Italia","location":{"lat":"42.035245","city":"Sant'Angelo Romano","state":"Lazio","country":"Italia","lng":"12.7126033","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/castello-orsini-cesi\/","zoom":18,"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 Castello Orsini-Cesi di<strong> Sant'Angelo Romano<\/strong> \u00e8 un importante esempio di architettura fortificata, a circa 30 chilometri da Roma. Risalente al IX secolo e costruito dai <strong>Longobardi<\/strong>, il castello ha subito ampliamenti e modifiche nel corso dei secoli da parte di varie famiglie nobiliari che lo hanno posseduto.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner][vc_empty_space height=\"40px\"][vc_single_image image=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/comuni-in-rete\/\"][\/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%2FCastello%2BOrsini-Cesi-Borghese%2F%4042.0352639%2C12.7126298%2C17z%2Fdata%3D!4m14!1m7!3m6!1s0x132f70d4cbcc0093%3A0x1aa71a0afbcf4ab1!2sCastello%2BOrsini-Cesi-Borghese!8m2!3d42.035245!4d12.7126033!16s%252Fg%252F120sdj5t!3m5!1s0x132f70d4cbcc0093%3A0x1aa71a0afbcf4ab1!8m2!3d42.035245!4d12.7126033!16s%252Fg%252F120sdj5t%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<h1>Castello <strong>Orsini-Cesi<\/strong><\/h1>\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_1722144282579{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via delle Torri, 00010,\r\nS.Angelo Romano, RM[\/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_1722144306644{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Aperto durante eventi e visite[\/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_row_inner][vc_empty_space height=\"40px\"][vc_column_text]\r\n<div class=\"flex flex-grow flex-col max-w-full\">\r\n<div class=\"min-h-[20px] text-message flex w-full flex-col items-end gap-2 whitespace-pre-wrap break-words [.text-message+&amp;]:mt-5 overflow-x-auto\" dir=\"auto\" data-message-author-role=\"assistant\" data-message-id=\"560bd41f-4739-4407-816c-2e764b5488bb\">\r\n<div class=\"flex w-full flex-col gap-1 empty:hidden first:pt-[3px]\">\r\n<div class=\"markdown prose w-full break-words dark:prose-invert light\">\r\n\r\nIl Castello Orsini-Cesi di<strong> Sant'Angelo Romano<\/strong> \u00e8 un importante esempio di architettura fortificata, a circa 30 chilometri da Roma. Risalente al IX secolo e costruito dai <strong>Longobardi<\/strong>, il castello ha subito ampliamenti e modifiche nel corso dei secoli da parte di varie famiglie nobiliari che lo hanno posseduto. Tra queste, le famiglie<strong> Orsini e Cesi<\/strong> hanno avuto un ruolo predominante nella sua storia.\r\n\r\nL'edificio presenta una struttura imponente, tipica dei <strong>castelli medievali<\/strong>, con mura massicce, torri di avvistamento e un mastio centrale. Progettato sia come <strong>residenza nobiliare<\/strong> sia come <strong>fortezza difensiva<\/strong>, il castello unisce elementi di <strong>eleganza e funzionalit\u00e0 militare<\/strong>. Nel XV secolo, il castello pass\u00f2 sotto il controllo della famiglia <strong>Orsini<\/strong>, una delle pi\u00f9 influenti dinastie dell'epoca, che ne rafforz\u00f2 le difese e lo ampli\u00f2 ulteriormente. Nel XVII secolo, la propriet\u00e0 pass\u00f2 alla famiglia <strong>Cesi<\/strong>, che apport\u00f2 ulteriori modifiche, trasformando il castello in una <strong>residenza pi\u00f9 confortevole<\/strong> e arricchendolo con <strong>elementi rinascimentali.<\/strong>\r\n\r\nGli interni del castello sono ricchi di storia e arte. Al suo interno, si trovano <strong>affreschi, arredi d'epoca e vari reperti storici<\/strong> che raccontano la vita delle famiglie nobiliari che vi hanno abitato. Le sale sono spaziose e adornate con <strong>decorazioni<\/strong> che riflettono il gusto e lo stile <strong>dei vari periodi storici<\/strong> in cui il castello \u00e8 stato abitato.\r\n\r\n<strong>Oggi<\/strong>, il Castello Orsini-Cesi \u00e8 un importante <strong>centro culturale e turistico<\/strong>. Viene utilizzato per <strong>eventi, mostre, visite guidate e attivit\u00e0 culturali<\/strong> che mirano a promuovere la storia e il patrimonio locale. Il castello ospita anche un <strong>museo<\/strong> che conserva <strong>reperti archeologici<\/strong> e testimonianze storiche della regione. Aperto al pubblico, il castello rappresenta una meta imperdibile per chi visita Sant'Angelo Romano, offrendo un'immersione nella storia medievale e rinascimentale e la possibilit\u00e0 di godere di viste panoramiche mozzafiato sulla campagna circostante.\r\n\r\nIl Castello Orsini-Cesi di Sant'Angelo Romano \u00e8 un luogo di grande fascino storico e culturale, che continua a testimoniare la ricca eredit\u00e0 delle famiglie nobiliari del Lazio e la storia del territorio.\r\n\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":"Castello Orsini-Cesi","post_link":"https:\/\/geosabina.it\/altri-comuni\/castello-orsini-cesi\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Castello Orsini-Cesi\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/castello_orsini_cesi-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1722144282579{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1722144306644{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;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":444,\"to_translate\":{\"en\":444}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via delle Torri, 32, 00010 Sant'Angelo Romano RM, Italia","%_wpgmp_location_city%":"Sant'Angelo Romano","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.035245","%_wpgmp_metabox_longitude%":"12.7126033","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"18\";i:3;s:2:\"20\";i:4;s:2:\"33\";}","%_wpgmp_metabox_marker_id%":"a:3:{i:0;s:1:\"5\";i:1;s:2:\"13\";i:2;s:2:\"23\";}","%_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","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Castello Orsini-Cesi","%_yoast_wpseo_metadesc%":"Il Castello Orsini-Cesi di Sant'Angelo Romano \u00e8 un importante esempio di architettura fortificata, a circa 30 chilometri da Roma. Risalente al IX secolo e costruito dai Longobardi.","%_yoast_wpseo_linkdex%":"71","%_thumbnail_id%":"14539","%_dp_original%":"13899","%_edit_lock%":"1722145711:6","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dimore-storiche_sito.png"},"id":14535,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dimore-storiche_sito.png","name":"Dimore Storiche \/ Historic Residences","id":"5","type":"category","extension_fields":{"cat_order":"1"}},{"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"}},{"icon":"https:\/\/geosabina.it\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Punto Panoramico Belvedere Aldo Nardi S. Angelo Romano.","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Punto Panoramico Belvedere Aldo Nardi S. Angelo Romano.\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/DJI_20240724181554_0119_D-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\/altri-comuni\/punto-panoramico-belvedere-aldo-nardi-s-angelo-romano\/\" class=\"fc-post-link\">Punto Panoramico Belvedere Aldo Nardi S. Angelo Romano.<\/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":"Belvedere Aldo Nardi, 00010 Sant'Angelo Romano RM, Italia","location":{"lat":"42.0332791","city":"Sant'Angelo Romano","state":"Lazio","country":"Italia","lng":"12.7132245","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/punto-panoramico-belvedere-aldo-nardi-s-angelo-romano\/","zoom":18,"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]Situato a soli 30 chilometri da Roma, il Belvedere di Sant'Angelo Romano offre una vista mozzafiato che abbraccia le verdi colline della Sabina fino all'orizzonte, dove lo sguardo si perde tra le lontane catene montuose.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\"][vc_empty_space height=\"25px\"][\/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%2Fplace%2FBelvedere%2F%4042.0332831%2C12.7106496%2C17z%2Fdata%3D!4m14!1m7!3m6!1s0x132f70d353c61be3%3A0x8c52c062f8f13a82!2sBelvedere!8m2!3d42.0332791!4d12.7132245!16s%252Fg%252F11f3r47bv9!3m5!1s0x132f70d353c61be3%3A0x8c52c062f8f13a82!8m2!3d42.0332791!4d12.7132245!16s%252Fg%252F11f3r47bv9%3Fentry%3Dttu|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>Punto Panoramico <strong>Belvedere Aldo Nardi S. Angelo Romano<\/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_1722095582489{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Belvedere Aldo Nardi,\r\n00010 Sant'Angelo Romano, RM[\/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_1716452714894{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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]\r\n<div class=\"flex flex-grow flex-col max-w-full\">\r\n<div class=\"min-h-[20px] text-message flex w-full flex-col items-end gap-2 whitespace-pre-wrap break-words [.text-message+&amp;]:mt-5 overflow-x-auto\" dir=\"auto\" data-message-author-role=\"assistant\" data-message-id=\"906e20fa-b9d6-4660-aa33-7596a0ce3516\">\r\n<div class=\"flex w-full flex-col gap-1 empty:hidden first:pt-[3px]\">\r\n<div class=\"markdown prose w-full break-words dark:prose-invert light\">\r\n\r\nSituato a soli 30 chilometri da Roma, il Belvedere di Sant'Angelo Romano offre una vista mozzafiato che abbraccia le verdi colline della Sabina fino all'orizzonte, dove lo sguardo si perde tra le lontane catene montuose. Questo affascinante punto panoramico \u00e8 il luogo ideale per chi desidera immergersi nella bellezza naturale e nella tranquillit\u00e0 della campagna laziale. Dal Belvedere, \u00e8 possibile ammirare i pittoreschi borghi di Sant'Angelo Romano e dintorni, circondati da boschi lussureggianti e campi coltivati. La vista spazia dalla Riserva Naturale della Marcigliana fino ai Monti Lucretili, offrendo una prospettiva unica e incantevole che cambia con il succedersi delle stagioni.\r\n\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<div class=\"mt-1 flex gap-3 empty:hidden -ml-2\">\r\n<div class=\"items-center justify-start rounded-xl p-1 flex\">\r\n<div class=\"flex items-center\">\r\n<div class=\"flex\"><\/div>\r\n<div class=\"flex items-center pb-0\">\r\n<div class=\"[&amp;_svg]:h-full [&amp;_svg]:w-full icon-md h-4 w-4\"><\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n[\/vc_column_text][vc_empty_space height=\"30px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"3\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"14525,14527,14529\"][vc_empty_space height=\"35px\"][vc_row_inner][vc_column_inner css=\".vc_custom_1716459725229{margin-top: 4px !important;margin-bottom: 2px !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;}\"][vc_text_separator title=\"Curiosit\u00e0\" i_icon_fontawesome=\"fas fa-camera-retro\" 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\" css=\".vc_custom_1718899563198{margin-top: -18px !important;}\"][vc_column_text]Sant'Angelo Romano non \u00e8 solo natura, ma anche storia e cultura. Il paese vanta un ricco patrimonio storico, con l'imponente Castello Orsini-Cesi che domina il paesaggio circostante. Le antiche strade del borgo, ricche di angoli suggestivi, raccontano storie di un passato lontano ma ancora vivo.\r\n<h3><\/h3>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"1\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"14531\"][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row]","post_title":"Punto Panoramico Belvedere Aldo Nardi S. Angelo Romano.","post_link":"https:\/\/geosabina.it\/altri-comuni\/punto-panoramico-belvedere-aldo-nardi-s-angelo-romano\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Punto Panoramico Belvedere Aldo Nardi S. Angelo Romano.\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/DJI_20240724181554_0119_D-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1722095582489{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1716452714894{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1716459725229{margin-top: 4px !important;margin-bottom: 2px !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;}.vc_custom_1718899563198{margin-top: -18px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":279,\"to_translate\":{\"en\":279}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Belvedere Aldo Nardi, 00010 Sant'Angelo Romano RM, Italia","%_wpgmp_location_city%":"Sant'Angelo Romano","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.0332791","%_wpgmp_metabox_longitude%":"12.7132245","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"8\";i:3;s:2:\"19\";i:4;s:2:\"20\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"11\";}","%_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","%_yoast_wpseo_focuskw%":"Punto Panoramico Belvedere Aldo Nardi S. Angelo Romano.","%_yoast_wpseo_metadesc%":"Situato a soli 30 chilometri da Roma, il Belvedere di Sant'Angelo Romano offre una vista mozzafiato che abbraccia le verdi colline della Sabina fino all'orizzonte, dove lo sguardo si perde tra le lontane catene montuose.","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"14531","%_dp_original%":"13368","%_edit_lock%":"1722163452:6","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png"},"id":14498,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png","name":"Punti Panoramici \/ Viewpoints","id":"11","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Alloggio Turistico Riosole 5.8","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Alloggio Turistico Riosole 5.8\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/alloggio_turistico_5.8-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\/alloggio-turistico-riosole\/\" class=\"fc-post-link\">Alloggio Turistico Riosole 5.8<\/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":"V. Riosole, 58, 02047 Poggio Mirteto RI, Italia","location":{"lat":"42.2641053","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6861036","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/poggio-mirteto\/alloggio-turistico-riosole\/","zoom":18,"extra_fields":{"post_excerpt":"","post_content":"[vc_row full_width=\"stretch_row\" css=\".vc_custom_1727366456602{padding-top: 30px !important;padding-bottom: 40px !important;background-image: url(https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/banner3.jpg?id=14458) !important;background-position: center !important;background-repeat: no-repeat !important;background-size: cover !important;}\" el_class=\"primo-box\"][vc_column offset=\"vc_hidden-xs\"][vc_row_inner][vc_column_inner width=\"1\/5\"][vc_single_image image=\"15543\" img_size=\"full\" alignment=\"center\"][\/vc_column_inner][vc_column_inner width=\"3\/5\"][vc_empty_space height=\"40px\"][vc_column_text css=\".vc_custom_1727369158096{padding-left: 8px !important;}\"]\r\n<h2 style=\"font-size: 30px;\">Alloggio Turistico <strong>Riosole 5.8<\/strong><\/h2>\r\n[\/vc_column_text][vc_column_text css=\".vc_custom_1727430226030{margin-top: -15px !important;padding-left: 8px !important;}\"]\r\n<h4>Il tuo soggiorno speciale nel cuore di <strong>Poggio Mirteto\u00a0<\/strong><\/h4>\r\n[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/5\"][vc_empty_space height=\"40px\"][vc_empty_space height=\"40px\"][vc_btn title=\"PRENOTA\" style=\"flat\" shape=\"round\" color=\"black\" size=\"lg\" align=\"right\" link=\"url:https%3A%2F%2Falloggituristici58.it%2Fprenota-il-tuo-soggiorno-a-poggio-mirteto%2F|target:_blank\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row\" css=\".vc_custom_1727369230940{background-position: center !important;background-repeat: no-repeat !important;background-size: cover !important;}\" el_class=\"primo-box\"][vc_column offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm\" css=\".vc_custom_1727369269554{margin-top: -10px !important;}\"][vc_row_inner][vc_column_inner width=\"1\/5\"][vc_single_image image=\"15543\" img_size=\"full\" alignment=\"center\"][\/vc_column_inner][vc_column_inner width=\"3\/5\"][vc_empty_space height=\"40px\"][vc_column_text css=\".vc_custom_1727369158096{padding-left: 8px !important;}\"]\r\n<h2 style=\"font-size: 30px;\">Alloggio Turistico <strong>Riosole 5.8<\/strong><\/h2>\r\n[\/vc_column_text][vc_column_text css=\".vc_custom_1727430232802{margin-top: -15px !important;padding-left: 8px !important;}\"]\r\n<h4>Il tuo soggiorno speciale nel cuore di <strong>Poggio Mirteto\u00a0<\/strong><\/h4>\r\n[\/vc_column_text][\/vc_column_inner][vc_column_inner width=\"1\/5\"][vc_empty_space height=\"40px\"][vc_btn title=\"PRENOTA\" style=\"flat\" shape=\"round\" color=\"black\" size=\"lg\" align=\"center\" button_block=\"true\" link=\"url:https%3A%2F%2Falloggituristici58.it%2Fprenota-il-tuo-soggiorno-a-poggio-mirteto%2F|target:_blank\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row\" gap=\"35\" content_placement=\"top\"][vc_column css_animation=\"fadeIn\" width=\"2\/3\"][vc_column_text css=\".vc_custom_1721410634739{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\">La casa di <strong>cartone<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text]L\u2019alloggio di <strong>90 metri quadri<\/strong> \u00e8 ideale per una vacanza perfetta. Dispone di due ampie camere da letto, due bagni, un luminoso salone, una cucina completamente attrezzata e due balconi per rilassarsi all\u2019aperto. Inoltre, offriamo due posti auto riservati per la massima comodit\u00e0 e un rimessaggio per le biciclette.\r\n\r\n<strong>Situato a soli 5 minuti a piedi dalla piazza centrale del Paese<\/strong> e dal centro storico, l\u2019alloggio dista un\u2019ora da Roma e a 10 minuti di auto dalla stazione ferroviaria di Poggio Mirteto Scalo collegata direttamente all\u2019aeroporto di Fiumicino (Leonardo da Vinci). A poca distanza troverete supermercati e negozi, farmacie, banche, posta e fermata bus per eventuali spostamenti.\r\n<h3 style=\"font-size: 20px;\">Perch\u00e9 il cartone<\/h3>\r\nAbbiamo realizzato i dettagli in cartone per creare un\u2019attrazione unica per i turisti. L\u2019originalit\u00e0 della struttura vuole attirare l\u2019attenzione e creare un\u2019esperienza memorabile per gli ospiti. L\u2018alloggio segue le linee guida della Citt\u00e0 di Poggio Mirteto entrata a far parte dei <strong>Comuni Sostenibili d\u2019Italia<\/strong>.\r\n<h3 style=\"font-size: 20px;\">Poggio Mirteto<\/h3>\r\nPoggio Mirteto \u00e8 un luogo affascinante per coloro che cercano una pausa dalla vita urbana, desiderano esplorare la bellezza naturale e la cultura autentica della <strong>Sabina<\/strong> e godere della calorosa ospitalit\u00e0 italiana.[\/vc_column_text][vc_empty_space height=\"30px\"][vc_row_inner][vc_column_inner][vc_column_text css=\".vc_custom_1727457530449{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\"><strong>Contatti <\/strong>&amp; Recapiti<\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"30px\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner][vc_column_inner width=\"1\/4\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_elegant\" fe_icon=\"icon_pin\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Via Riosole 58, 02047 - Poggio Mirteto\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\" custom_class=\"contatti\"][\/vc_column_inner][vc_column_inner width=\"1\/4\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_elegant\" fe_icon=\"icon_phone\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"+39 0765 546507\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\" custom_class=\"contatti\"][\/vc_column_inner][vc_column_inner width=\"1\/4\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_elegant\" fe_icon=\"icon_link\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" target=\"_blank\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\" title=\"alloggituristici58.it\" link=\"https:\/\/alloggituristici58.it\/alloggio-turistico-riosole\/\" custom_class=\"contatti\"][\/vc_column_inner][vc_column_inner width=\"1\/4\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_elegant\" fe_icon=\"icon_search-2\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" target=\"_blank\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\" title=\"Ottieni indicazioni stradali\" link=\"https:\/\/www.google.com\/maps\/place\/Alloggio+Turistico+Riosole+5.8\/@42.264105,12.686104,20172m\/data=!3m1!1e3!4m9!3m8!1s0x132f0fa70a5fcd93:0xad6d048ad58e2a39!5m2!4m1!1i2!8m2!3d42.2641053!4d12.6861036!16s%2Fg%2F11vb2pn3l8?hl=it-IT&amp;entry=ttu&amp;g_ep=EgoyMDI0MDkyMy4wIKXMDSoASAFQAw%3D%3D\" custom_class=\"contatti\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"1\/3\"][vc_row_inner][vc_column_inner css=\".vc_custom_1721319383162{margin-top: 0px !important;border-top-width: 0px !important;padding-top: 0px !important;}\"][vc_column_text css=\".vc_custom_1727456808704{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\"><strong>Servizi<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-car\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Parcheggio gratuito\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17px\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-wifi\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Wi-Fi\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-coffee\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Cucina attrezzata\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-street-view\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Terrazzo attrezzato\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-bicycle\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Rimessa per bici al chiuso\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-thermometer-three-quarters\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Aria Condizionata\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-coffee\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Macchina caff\u00e8 con cialde\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-clock-o\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"Lavatrice con detersivo\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner][vc_column_text css=\".vc_custom_1721465473552{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\">Tipologia di <strong>letti<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-bed\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"1 Camera con letto matrimoniale\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-bed\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" title=\"1 Camera con 2 letti singoli o letto matrimoniale\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-bed\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" target=\"_blank\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\" title=\"1 letto aggiuntivo zona living\" link=\"https:\/\/alloggituristici58.it\/alloggio-turistico-riosole\/\"][vc_separator color=\"custom\" align=\"align_left\" css=\".vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}\" accent_color=\"#dddddd\"][qodef_icon_with_text type=\"icon-left\" icon_pack=\"font_awesome\" fa_icon=\"fa-bed\" icon_size=\"qodef-icon-tiny\" title_tag=\"h6\" target=\"_blank\" icon_color=\"#1e1e1e\" icon_hover_color=\"#212121\" custom_icon_size=\"17\" title_top_margin=\"5\" title=\"Servizio culla\" link=\"https:\/\/alloggituristici58.it\/alloggio-turistico-riosole\/\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row][vc_row][vc_column][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row\" css=\".vc_custom_1721466916126{background-color: #f2f2f2 !important;}\"][vc_column][vc_row_inner][vc_column_inner][vc_column_text css=\".vc_custom_1727456847594{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\">L'<strong>appartamento<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\" css=\".vc_custom_1721467120737{background-color: #f2f2f2 !important;}\"][vc_column css=\".vc_custom_1721314837052{margin-top: 0px !important;border-top-width: 0px !important;padding-top: 0px !important;}\"][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=\"no\" images=\"14281,14283,14285,14287,14289,14291,14293,14295\" image_size=\"full\"][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row\" css=\".vc_custom_1721467089515{background-color: #f2f2f2 !important;}\"][vc_column][vc_row_inner][vc_column_inner][vc_column_text css=\".vc_custom_1721467231811{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\">Prenota <b>Riosole 5.8<\/b><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner css=\".vc_custom_1721412364262{margin-top: 3px !important;margin-right: 3px !important;margin-bottom: 3px !important;margin-left: 3px !important;border-top-width: 1px !important;border-right-width: 1px !important;border-bottom-width: 1px !important;border-left-width: 1px !important;padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 20px !important;padding-left: 10px !important;border-left-color: #adadad !important;border-left-style: dashed !important;border-right-color: #adadad !important;border-right-style: dashed !important;border-top-color: #adadad !important;border-top-style: dashed !important;border-bottom-color: #adadad !important;border-bottom-style: dashed !important;}\"][vc_column_inner css=\".vc_custom_1721408978153{margin-top: 0px !important;border-top-width: 0px !important;padding-top: 0px !important;}\"][vc_column_text]<span style=\"font-size: 11px; line-height: 20px;\"><strong>Tutti i nostri alloggi sono corredati dei seguenti servizi:<\/strong>\r\nTV a schermo piatto led, prese elettriche multiple vicino al letto, ferro e asse da stiro, bollitore elettrico, tostapane, frullatore tipo minipimer, asciugacapelli professionale, pavimenti in marmo o piastrelle, prodotti per le pulizie.<\/span>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"20px\"][vc_btn title=\"CLICCA QUI PER PRENOTARE L'APPARTAMENTO\" style=\"flat\" shape=\"square\" color=\"inverse\" align=\"left\" link=\"url:https%3A%2F%2Falloggituristici58.it%2Fprenota-il-tuo-soggiorno-a-poggio-mirteto%2F|target:_blank\"][vc_empty_space height=\"20px\"][\/vc_column][\/vc_row][vc_row row_content_width=\"grid\"][vc_column][vc_empty_space height=\"50px\"][vc_column_text css=\".vc_custom_1728036827264{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\"><strong>Recensioni\u00a0<\/strong><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"50px\"][vc_raw_html]JTNDc2NyaXB0JTIwc3JjJTNEJTIyaHR0cHMlM0ElMkYlMkZzdGF0aWMuZWxmc2lnaHQuY29tJTJGcGxhdGZvcm0lMkZwbGF0Zm9ybS5qcyUyMiUyMGFzeW5jJTNFJTNDJTJGc2NyaXB0JTNFJTBBJTNDZGl2JTIwY2xhc3MlM0QlMjJlbGZzaWdodC1hcHAtMWVjMzk2N2YtMTI2OS00MDdlLWE0NzAtNWY4YzlhYmEzMDk1JTIyJTIwZGF0YS1lbGZzaWdodC1hcHAtbGF6eSUzRSUzQyUyRmRpdiUzRQ==[\/vc_raw_html][\/vc_column][\/vc_row][vc_row row_content_width=\"grid\"][vc_column][vc_empty_space height=\"50px\"][vc_column_text css=\".vc_custom_1727784597793{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}\"]\r\n<h2 style=\"font-size: 30px;\">La <b>Mappa<\/b><\/h2>\r\n[\/vc_column_text][vc_empty_space height=\"50px\"][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\" el_id=\"mappavisibile\"][vc_column][\/vc_column][\/vc_row]","post_title":"Alloggio Turistico Riosole 5.8","post_link":"https:\/\/geosabina.it\/poggio-mirteto\/alloggio-turistico-riosole\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Alloggio Turistico Riosole 5.8\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/09\/alloggio_turistico_5.8-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1727366456602{padding-top: 30px !important;padding-bottom: 40px !important;background-image: url(https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/banner3.jpg?id=14458) !important;background-position: center !important;background-repeat: no-repeat !important;background-size: cover !important;}.vc_custom_1727369230940{background-position: center !important;background-repeat: no-repeat !important;background-size: cover !important;}.vc_custom_1721466916126{background-color: #f2f2f2 !important;}.vc_custom_1721467120737{background-color: #f2f2f2 !important;}.vc_custom_1721467089515{background-color: #f2f2f2 !important;}.vc_custom_1727369158096{padding-left: 8px !important;}.vc_custom_1727430226030{margin-top: -15px !important;padding-left: 8px !important;}.vc_custom_1727369269554{margin-top: -10px !important;}.vc_custom_1727369158096{padding-left: 8px !important;}.vc_custom_1727430232802{margin-top: -15px !important;padding-left: 8px !important;}.vc_custom_1721410634739{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1727457530449{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1721319383162{margin-top: 0px !important;border-top-width: 0px !important;padding-top: 0px !important;}.vc_custom_1727456808704{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721465473552{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1721317379290{margin-top: 8px !important;margin-bottom: 5px !important;}.vc_custom_1727456847594{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1721314837052{margin-top: 0px !important;border-top-width: 0px !important;padding-top: 0px !important;}.vc_custom_1721412364262{margin-top: 3px !important;margin-right: 3px !important;margin-bottom: 3px !important;margin-left: 3px !important;border-top-width: 1px !important;border-right-width: 1px !important;border-bottom-width: 1px !important;border-left-width: 1px !important;padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 20px !important;padding-left: 10px !important;border-left-color: #adadad !important;border-left-style: dashed !important;border-right-color: #adadad !important;border-right-style: dashed !important;border-top-color: #adadad !important;border-top-style: dashed !important;border-bottom-color: #adadad !important;border-bottom-style: dashed !important;}.vc_custom_1721467231811{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1721408978153{margin-top: 0px !important;border-top-width: 0px !important;padding-top: 0px !important;}.vc_custom_1728036827264{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}.vc_custom_1727784597793{border-left-width: 4px !important;padding-left: 8px !important;border-left-color: #ffe500 !important;border-left-style: solid !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":309,\"to_translate\":{\"en\":309}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"V. Riosole, 58, 02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2641053","%_wpgmp_metabox_longitude%":"12.6861036","%_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:\"37\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_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","%_yoast_wpseo_focuskw%":"alloggi turistici Poggio Mirteto","%_yoast_wpseo_metadesc%":"Vivi il meglio della Sabina in uno degli Alloggi Turistici selezionati per te. Scegli il tuo appartamento e prenota il tuo soggiorno a Poggio Mirteto","%_yoast_wpseo_linkdex%":"50","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_bf8995e873e8b21775ffd9d64a809268%":"<iframe title=\"Il Borgo di Montasola\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/AjiMFDVTfL4?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_bf8995e873e8b21775ffd9d64a809268%":"1716481824","%_wpb_post_custom_css%":".social {\r\n    display: flex !important;\r\n    padding-top: 20px !important;\r\n    justify-content: center !important;\r\n}\r\n.soc {text-align:left; padding-right:5px;}\r\n\r\n.vc_tta-tab>a {\r\n    background-color:#ffe500 !important;\r\n    color:#212121 !important;\r\n    border-color: #ffe500 !important;\r\n    font-weight:600;\r\n    line-height: 18px;\r\n    font-size:13px;\r\n}\r\n\r\n.vc_tta-color-sandy-brown.vc_tta-style-classic .vc_tta-tab.vc_active>a {\r\n    background-color:#f4f4f4 !important;\r\n    color:#212121 !important;\r\n    border-color: #f4f4f4 !important;\r\n}\r\n\r\n.vc_tta-color-sandy-brown.vc_tta-style-classic.vc_tta-tabs .vc_tta-panels .vc_tta-panel-body {\r\n        border-color: #f4f4f4 !important;\r\n        background-color: #f4f4f4 !important;\r\n        padding:20px;\r\n    }\r\n    \r\n\r\n.loghetto {\r\n    width:100%;\r\n    max-width:180px;\r\n}\r\n\r\n.loghetto-due {\r\n    width:100%;\r\n    max-width:540px;\r\n}\r\n\r\n.contatti h6 {\r\n    font-size: 12px;\r\n    font-weight: 500;\r\n}\r\n\r\n.primo-box {\r\n    box-shadow: white 0px -25px 40px 1em inset; \r\n}","%_dp_original%":"12694","%_edit_lock%":"1728037794:4","%_edit_last%":"4","%_thumbnail_id%":"15637","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dove-dormire_sito.png"},"id":14194,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dove-dormire_sito.png","name":"Dove Dormire \/ Where to stay","id":"6","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Sorgenti di Santa Susanna","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sorgenti di Santa Susanna\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/santa_susanna-12-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\/altri-comuni\/sorgenti-di-santa-susanna\/\" class=\"fc-post-link\">Sorgenti di Santa Susanna<\/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":"Santa Susanna, 02010 Piedicolle RI, Italia","location":{"lat":"42.501865","city":"Rivodutri","state":"Lazio","country":"Italia","lng":"12.85264","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/sorgenti-di-santa-susanna\/","zoom":18,"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]<strong>Santa Susanna<\/strong>, situata a Rieti, \u00e8 una delle aree naturali pi\u00f9 suggestive e interessanti del Lazio. Questa sorgente \u00e8 famosa non solo per la sua <strong>bellezza paesaggistica<\/strong>, ma anche per il suo <strong>valore storico.<\/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 gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner][vc_empty_space height=\"40px\"][vc_single_image image=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/comuni-in-rete\/\"][\/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%2Fplace%2FSorgenti%2BSanta%2BSusanna%2F%4042.502105%2C12.8501838%2C17z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132e55a94d762055%3A0xee7562f4e74d3acb!8m2!3d42.502105!4d12.8527641!16s%252Fg%252F11c5wkzdk6%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>Sorgenti di<strong> Santa Susanna <\/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_1720693113127{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via S. Susanna,\r\n02010, Rivodutri, 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_1720093019621{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\"][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-150x150.png\" \/>\r\n<h4 style=\"padding-top: 5px;\"><strong>Info<\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text css=\".vc_custom_1720693966662{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Luogo sempre aperto,\r\nRaggiungibile in auto, con comodo parcheggio[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]<strong>Santa Susanna<\/strong>, situata a Rieti, \u00e8 una delle aree naturali pi\u00f9 suggestive e interessanti del Lazio. Questa sorgente \u00e8 famosa non solo per la sua <strong>bellezza paesaggistica<\/strong>, ma anche per il suo <strong>valore storico<\/strong>, culturale e ambientale, tanto da essere posta all\u2019interno dell\u2019Area Protetta, tutelata dalla ZSC e dichiarata <strong>monumento naturale nel 1977<\/strong>.\r\n\r\nLa riserva si estende per circa 3.000 ettari e comprende una variet\u00e0 di habitat naturali che vanno dai boschi di querce e castagni ai prati e ai corsi d'acqua. La flora \u00e8 particolarmente ricca e varia, con numerose specie di <strong>piante rare<\/strong> ed endemiche che trovano in quest'area il loro habitat ideale. Anche la fauna \u00e8 molto diversificata: possiamo trovare diversi tipi di uccelli, sia migratori che stanziali, come il <strong>cormorano e la nitticora<\/strong>, ma anche volpi, tassi e cervi.\r\n\r\nIl parco \u00e8 attrezzato con <strong>aree picnic<\/strong> e spazi per lo svago dei pi\u00f9 piccoli. Durante le festivit\u00e0 natalizie, nelle acque delle sorgenti viene allestito un <strong>presepe subacqueo<\/strong> illuminato, che aggiunge un tocco di magia alla riserva. Questo luogo ha anche un importante valore storico e culturale infatti all'interno dei suoi confini si trovano diversi <strong>siti archeologici<\/strong> che testimoniano la presenza umana fin dall'<strong>et\u00e0 del bronzo<\/strong>. Di particolare interesse sono i resti di antichi insediamenti e le tracce di <strong>vecchie strade romane<\/strong>.[\/vc_column_text][vc_empty_space height=\"30px\"][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=\"no\" slider_pagination=\"no\" images=\"13992,13990,13988,13986\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Sorgenti di Santa Susanna","post_link":"https:\/\/geosabina.it\/altri-comuni\/sorgenti-di-santa-susanna\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sorgenti di Santa Susanna\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/santa_susanna-12-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1720693113127{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1720093019621{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_1720693966662{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\":329,\"to_translate\":{\"en\":329}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Santa Susanna, 02010 Piedicolle RI, Italia","%_wpgmp_location_city%":"Rivodutri","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.501865","%_wpgmp_metabox_longitude%":"12.85264","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"18\";i:3;s:2:\"20\";i:4;s:2:\"32\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"23\";}","%_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","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Sorgenti di Santa Susanna","%_yoast_wpseo_metadesc%":"Santa Susanna, situata a Rieti, \u00e8 una delle aree naturali pi\u00f9 suggestive e interessanti del Lazio. Questa sorgente \u00e8 famosa non solo per la sua bellezza paesaggistica, ma anche per il suo valore storico.","%_yoast_wpseo_linkdex%":"64","%_thumbnail_id%":"13965","%_dp_original%":"13798","%_edit_lock%":"1726150852:4","%_edit_last%":"4","%_oembed_70e16a6284770e7d733d25e60bcf8eea%":"<iframe title=\"Le Sorgenti di Santa Susanna!\" width=\"568\" height=\"320\" src=\"https:\/\/www.youtube.com\/embed\/cnkjj6tqqQ8?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_70e16a6284770e7d733d25e60bcf8eea%":"1726135357","%_oembed_fb2ce78f28688e32bcc49771ca14f6fd%":"<iframe title=\"Le Sorgenti di Santa Susanna!\" width=\"1100\" height=\"619\" src=\"https:\/\/www.youtube.com\/embed\/cnkjj6tqqQ8?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_fb2ce78f28688e32bcc49771ca14f6fd%":"1726135454","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/bellezze-naturali_sito.png"},"id":13950,"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\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Colle Di Tora","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Colle Di Tora\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/colle-di-tora-maps-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\/altri-comuni\/colle-di-tora\/\" class=\"fc-post-link\">Colle Di Tora<\/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":"02020 Colle di Tora RI, Italia","location":{"lat":"42.20806959999999","city":"Colle di Tora","state":"Lazio","country":"Italia","lng":"12.9471296","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/colle-di-tora\/","zoom":18,"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]<strong>Colle di Tora<\/strong> \u00e8 un incantevole borgo dalle case bianche, arroccato su una penisola che si estende nelle acque del <strong>lago del Turano<\/strong>. Questo paese si trova in un\u2019affascinante <strong>cornice naturale<\/strong> che esalta le sue bellezze e testimonia una storia ricca e antica.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner][vc_empty_space height=\"40px\"][vc_single_image image=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/comuni-in-rete\/\"][\/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%2F02020%2BColle%2Bdi%2BTora%2BRI%2F%4042.2099025%2C12.9429829%2C16z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132fa4816cdb56ab%3A0x14ff07609abd334a!8m2!3d42.2080696!4d12.9471296!16zL20vMGdtNTdu%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<h1>Colle Di <strong>Tora<\/strong><\/h1>\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_1720430184607{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Colle di Tora\r\n02020, 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_1720093019621{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_row_inner][vc_empty_space height=\"40px\"][vc_column_text]<strong>Colle di Tora<\/strong> \u00e8 un incantevole borgo dalle case bianche, arroccato su una penisola che si estende nelle acque del <strong>lago del Turano<\/strong>. Questo paese si trova in un\u2019affascinante <strong>cornice naturale<\/strong> che esalta le sue bellezze e testimonia una storia ricca e antica. Infatti, il nome <strong>Tora<\/strong> \u00e8 citato da vari autori illustri dell\u2019antichit\u00e0, primo tra tutti <strong>Dionigi di Alicarnasso<\/strong>, che menziona un oracolo presente in questo luogo.\r\n\r\nL\u2019esatta ubicazione di questa antica citt\u00e0 \u00e8 stata oggetto di dibattito: dai documenti medievali relativi alla chiesa di <strong>Sant\u2019Anatolia<\/strong> si deduce che Tora si trovava nel centro della Sabina, non lontano dall\u2019attuale <strong>Colle di Tora<\/strong>. Durante l\u2019epoca romana, come tutta la zona del Turano, Colle di Tora faceva parte della regione <strong>Valeria<\/strong> e, in epoca longobarda, del<strong> gastaldato di Turano<\/strong>. Fino al 1864, il paese era conosciuto come <strong>\u201cCollepiccolo\u201d<\/strong> e faceva parte della cosiddetta<strong> Massa Turana<\/strong>, sotto la giurisdizione dell\u2019importante <strong>abbazia di Farfa<\/strong> a partire dal IX secolo.\r\n\r\nLe frequenti incursioni di Saraceni e Ungari, una tragica costante del nono e decimo secolo, portarono probabilmente alla creazione di un nucleo abitato fortificato, che \u00e8 alla base del paese come lo conosciamo oggi. Nel XIII secolo, Collepiccolo entr\u00f2 a far parte dei possedimenti dei <strong>Brancaleoni<\/strong>, una potente famiglia della Romagna, che con il ramo degli Andal\u00f2 arriv\u00f2 a dominare Bologna.\r\n\r\nAll'inizio del XV secolo, il controllo di Collepiccolo pass\u00f2 agli <strong>Orsini<\/strong> del ramo di Castel Sant\u2019Angelo, che governarono il paese fino al 1634, quando Maharbale Orsini, l\u2019ultimo signore, vendette il feudo ai principi Borghese. Collepiccolo non divent\u00f2 mai un grande centro e durante un censimento del 1713 rilev\u00f2 la presenza di 60 famiglie, per un totale di 350 abitanti. Era una piccola comunit\u00e0 dove <strong>due sacerdoti<\/strong> e <strong>un chierico<\/strong> garantivano l\u2019assistenza spirituale, mentre le visite sporadiche di <strong>un chirurgo<\/strong> provvedevano a quella <strong>sanitaria.<\/strong>\r\n\r\nCostruito su uno <strong>sperone roccioso<\/strong> che si protende nel lago del Turano, Colle di Tora \u00e8 senza dubbio <strong>il paese pi\u00f9 legato al grande bacino artificiale.<\/strong> Nel 1731 fu inaugurata la nuova chiesa dedicata a San Lorenzo, la cui prima pietra era stata posata qualche anno prima grazie al contributo del principe Borghese. Con la nascita della Repubblica Romana, dopo i tumultuosi eventi della Rivoluzione Francese, Collepiccolo, come tutta la Sabina, fu incluso nel dipartimento del Clitunno, con capitale Spoleto, uno degli otto dipartimenti nei quali era stato suddiviso lo Stato Pontificio.[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Colle Di Tora","post_link":"https:\/\/geosabina.it\/altri-comuni\/colle-di-tora\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Colle Di Tora\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/colle-di-tora-maps-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1720430184607{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1720093019621{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;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":505,\"to_translate\":{\"en\":505}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"02020 Colle di Tora RI, Italia","%_wpgmp_location_city%":"Colle di Tora","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.20806959999999","%_wpgmp_metabox_longitude%":"12.9471296","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"18\";i:3;s:2:\"20\";i:4;s:2:\"31\";}","%_wpgmp_metabox_marker_id%":"a:3:{i:0;s:1:\"5\";i:1;s:2:\"13\";i:2;s:2:\"23\";}","%_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","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Colle Di Tora","%_yoast_wpseo_metadesc%":"Colle di Tora \u00e8 un incantevole borgo dalle case bianche, arroccato su una penisola che si estende nelle acque del lago del Turano. Questo paese si trova in un\u2019affascinante cornice naturale che esalta le sue bellezze e testimonia una storia ricca e antica.","%_yoast_wpseo_linkdex%":"69","%_thumbnail_id%":"13903","%_dp_original%":"13798","%_edit_lock%":"1720451488:6","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dimore-storiche_sito.png"},"id":13899,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dimore-storiche_sito.png","name":"Dimore Storiche \/ Historic Residences","id":"5","type":"category","extension_fields":{"cat_order":"1"}},{"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"}},{"icon":"https:\/\/geosabina.it\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Lago del Salto","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lago del Salto\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/Lago-del-Salto-Maps-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\/altri-comuni\/lago-del-salto\/\" class=\"fc-post-link\">Lago del Salto<\/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":"Lago del Salto, Provincia di Rieti, Italia","location":{"lat":"42.2603567","state":"Lazio","country":"Italia","lng":"13.0601805","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/lago-del-salto\/","zoom":18,"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]<strong>Il Lago del Salto<\/strong> \u00e8 una delle gemme naturali pi\u00f9 affascinanti del centro Italia. Creato negli anni '40 del XX secolo grazie alla costruzione di una diga sul fiume Salto, il lago \u00e8 nato con l'obiettivo di generare <strong>energia idroelettrica<\/strong> e regolare il flusso delle acque.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/intorno-a-te\/punti-da-non-perdere\/\"][vc_empty_space height=\"25px\"][\/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%2FLago%2Bdel%2BSalto%2F%4042.257643%2C13.0552058%2C14z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132fba1b7c281aa1%3A0x4d7a38db73ac5c12!8m2!3d42.2603567!4d13.0601805!16s%252Fm%252F05pb214%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>Lago del <strong>Salto<\/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_1720175847690{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]\r\n<div class=\"gm-style-iw gm-style-iw-c\" tabindex=\"-1\" role=\"dialog\">\r\n<div class=\"gm-style-iw-d\">\r\n<div class=\"gm-iw\">Lago del Salto<\/div>\r\n<div class=\"gm-iw\">02100, Rieti<\/div>\r\n<\/div>\r\n&nbsp;\r\n\r\n<\/div>\r\n[\/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_1702570858261{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]sempre aperto\r\n\r\n[\/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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]<strong>Il Lago del Salto<\/strong> \u00e8 una delle gemme naturali pi\u00f9 affascinanti del centro Italia. Creato negli anni '40 del XX secolo grazie alla costruzione di una diga sul fiume Salto, il lago \u00e8 nato con l'obiettivo di generare <strong>energia idroelettrica<\/strong> e regolare il flusso delle acque. Con il passare del tempo, il Lago del Salto \u00e8 diventato una <strong>meta turistica rinomata<\/strong>, amata per la sua bellezza paesaggistica e le numerose opportunit\u00e0 di svago che offre.\r\n\r\nEstendendosi su una superficie di circa 10 chilometri quadrati, il Lago del Salto \u00e8 il pi\u00f9 grande <strong>lago artificiale del Lazio<\/strong>. Le sue acque cristalline, incorniciate da una rigogliosa vegetazione di querce, faggi e castagni, creano un ambiente sereno e accogliente. La forma irregolare del lago, caratterizzata da numerose insenature e piccole baie, rende il paesaggio ancora pi\u00f9 affascinante e invita a esplorare ogni angolo nascosto.\r\n\r\nLa <strong>flora e la fauna<\/strong> che popolano il Lago del Salto <strong>sono estremamente varie<\/strong>. Le rive del lago ospitano una ricca biodiversit\u00e0 vegetale, mentre le sue acque sono popolate da specie ittiche come <strong>carpe, trote e lucci, ideali per la pesca sportiva.<\/strong> Gli amanti del <strong>birdwatching<\/strong> possono ammirare <strong>aironi, anatre selvatiche e falchi<\/strong> che abitano l'area, mentre nei boschi circostanti si possono incontrare <strong>cinghiali, caprioli e volpi.<\/strong>\r\n\r\nPer chi cerca attivit\u00e0 ricreative, il Lago del Salto \u00e8 una destinazione perfetta. Gli <strong>sport acquatici<\/strong> come la <strong>vela, il canottaggio e il kayak<\/strong> sono particolarmente popolari grazie alle acque calme del lago. Gli appassionati di <strong>pesca sportiva<\/strong> troveranno numerosi punti ideali per catturare le prede locali. Inoltre,<strong> i sentieri escursionistici<\/strong> intorno al lago offrono percorsi mozzafiato per esplorare il paesaggio circostante, permettendo di immergersi nella natura e di godere di viste panoramiche spettacolari.\r\n\r\nIl Lago del Salto \u00e8 anche il luogo ideale per chi desidera rilassarsi in un ambiente naturale incontaminato. Le sue rive offrono spazi perfetti per <strong>pic-nic<\/strong>, giornate all'aria aperta e <strong>momenti di relax in famiglia o con amici.<\/strong> Il paesaggio tranquillo e la presenza di boschi e prati fanno del lago una meta perfetta per chi cerca una pausa rigenerante dalla vita quotidiana.\r\n\r\nIn sintesi, il Lago del Salto \u00e8 una destinazione imperdibile per chiunque. Che siate appassionati di sport acquatici, escursionisti, amanti della pesca o semplicemente in cerca di un luogo dove rilassarvi e godere della natura, il Lago del Salto offre tutto questo e molto di pi\u00f9.[\/vc_column_text][vc_empty_space height=\"25px\"][\/vc_column][\/vc_row]","post_title":"Lago del Salto","post_link":"https:\/\/geosabina.it\/altri-comuni\/lago-del-salto\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lago del Salto\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/Lago-del-Salto-Maps-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1720175847690{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1702570858261{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;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":519,\"to_translate\":{\"en\":519}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Lago del Salto, Provincia di Rieti, Italia","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2603567","%_wpgmp_metabox_longitude%":"13.0601805","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"18\";i:3;s:2:\"20\";i:4;s:2:\"30\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"23\";}","%_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","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Lago del Salto","%_yoast_wpseo_metadesc%":"Il Lago del Salto \u00e8 una delle gemme naturali pi\u00f9 affascinanti del centro Italia. Creato negli anni '40 del XX secolo grazie alla costruzione di una diga sul fiume Salto, il lago \u00e8 nato con l'obiettivo di generare energia idroelettrica e regolare il flusso delle acque.","%_yoast_wpseo_linkdex%":"72","%_oembed_1eb08ede5fcfd3a110467a2c63748b96%":"{{unknown}}","%_oembed_36cedc6b2f240b2eb3df757c5e017720%":"{{unknown}}","%_dp_original%":"10821","%_edit_lock%":"1720201313:4","%_edit_last%":"4","%_thumbnail_id%":"13828","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/bellezze-naturali_sito.png"},"id":13823,"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\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Lago del Turano","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lago del Turano\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/Lago-del-Turano-52-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\/altri-comuni\/lago-del-turano\/\" class=\"fc-post-link\">Lago del Turano<\/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":"Lago del Turano, Provincia di Rieti, Italia","location":{"lat":"42.21819259999999","state":"Lazio","country":"Italia","lng":"12.9521888","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/lago-del-turano\/","zoom":18,"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]<strong>Il Lago del Turano<\/strong> \u00e8 un affascinante bacino <strong>artificiale<\/strong>\u00a0 circondato dai suggestivi monti Sabini. Questo lago, nato negli anni '30 del XX secolo in seguito alla costruzione di una diga sul <strong>fiume Turano.<\/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 gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/intorno-a-te\/punti-da-non-perdere\/\"][vc_empty_space height=\"25px\"][\/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%2FLago%2Bdel%2BTurano%2F%4042.2082954%2C12.9755892%2C17z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132fa4af56115357%3A0xed74ff97dd33b034!8m2!3d42.2080738!4d12.978278!16s%252Fg%252F119x2l8qp%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>Lago del <strong>Turano<\/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_1720170010056{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]\r\n<div class=\"gm-style-iw gm-style-iw-c\" tabindex=\"-1\" role=\"dialog\">\r\n<div class=\"gm-style-iw-d\">\r\n<div class=\"gm-iw\">Lago del <strong>Turano<\/strong><\/div>\r\n<div class=\"gm-iw\">02020 Rieti, RI<\/div>\r\n<\/div>\r\n<\/div>\r\n[\/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_1702570858261{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]sempre aperto\r\n\r\n[\/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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]\r\n<div class=\"flex flex-grow flex-col max-w-full\">\r\n<div class=\"min-h-[20px] text-message flex flex-col items-start whitespace-pre-wrap break-words [.text-message+&amp;]:mt-5 juice:w-full juice:items-end overflow-x-auto gap-2\" dir=\"auto\" data-message-author-role=\"assistant\" data-message-id=\"86286270-44fe-4e14-a083-9f5a90b2ae20\">\r\n<div class=\"flex w-full flex-col gap-1 juice:empty:hidden juice:first:pt-[3px]\">\r\n<div class=\"markdown prose w-full break-words dark:prose-invert dark\">\r\n\r\n<strong>Il Lago del Turano<\/strong> \u00e8 un affascinante bacino <strong>artificiale<\/strong>\u00a0 circondato dai suggestivi monti Sabini. Questo lago, nato negli anni '30 del XX secolo in seguito alla costruzione di una diga sul <strong>fiume Turano<\/strong>, si estende per circa 10 chilometri quadrati e rappresenta una delle principali attrazioni naturali della provincia di Rieti.\r\n\r\nL'origine del Lago del Turano \u00e8 legata alla necessit\u00e0 di<strong> produrre energia<\/strong> <strong>idroelettrica<\/strong> e di regolare il flusso delle acque del fiume per evitare inondazioni nelle aree circostanti. Oggi, il lago non \u00e8 solo una risorsa energetica, ma anche un luogo di grande <strong>bellezza e interesse naturalistico<\/strong>, che attira visitatori da ogni parte d'Italia.\r\n\r\nLe acque del lago sono cristalline e riflettono i verdi monti che lo circondano, creando un paesaggio di rara suggestione. L'ambiente circostante <strong>\u00e8 ricco di flora e fauna<\/strong>, con boschi rigogliosi e una variet\u00e0 di specie animali che trovano qui il loro habitat naturale. \u00c8 possibile avvistare uccelli acquatici, come aironi e anatre selvatiche, che popolano le rive del lago, aggiungendo un tocco di vita alla serenit\u00e0 del luogo.\r\n\r\nLe attivit\u00e0 ricreative offerte dal Lago del Turano sono molteplici e adatte a ogni tipo di visitatore. Gli amanti della natura possono intraprendere percorsi di <strong>trekking<\/strong> che si snodano lungo le colline e le montagne circostanti, regalando viste panoramiche mozzafiato. Per chi preferisce l'acqua, il lago offre opportunit\u00e0 per la <strong>pesca sportiva<\/strong> e gli <strong>sport acquatici<\/strong>, come il <strong>kayak e la vela<\/strong>. Inoltre, durante i mesi estivi, le sue spiagge sono il luogo ideale per rilassarsi e prendere il sole.\r\n\r\n&nbsp;\r\n\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"3\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" images=\"13834,13836,13838\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"25px\"][vc_column_text]Il Lago del Turano \u00e8 circondato da piccoli borghi che conservano intatto il fascino del passato, come <strong><a href=\"https:\/\/geosabina.it\/altri-comuni\/castel-di-tora\/\">Castel di Tora<\/a> e Colle di Tora<\/strong>. Questi paesi offrono uno spaccato della vita rurale italiana, con le loro case in pietra, le strette stradine e le chiese antiche. Visitare questi luoghi significa fare un tuffo nella storia e nelle tradizioni locali, lontano dalle mete turistiche pi\u00f9 frequentate.\r\n\r\nUn aspetto interessante del Lago del Turano \u00e8 la sua <strong>rilevanza per la gastronomia locale<\/strong>. Le acque del lago sono ricche di <strong>pesci<\/strong>, che vengono utilizzati nella preparazione di piatti tradizionali. La cucina della zona \u00e8 semplice ma saporita, con ricette che esaltano i sapori autentici degli ingredienti locali. Tra i piatti tipici, si possono gustare le trote e i lucci del lago, preparati secondo ricette tradizionali tramandate di generazione in generazione.\r\n\r\nIl Lago del Turano \u00e8 anche un luogo di <strong>eventi e feste<\/strong> che animano la vita locale. Durante l'anno, si tengono diverse <strong>manifestazioni<\/strong> che celebrano le tradizioni popolari, la cucina e la cultura del territorio. Questi eventi sono occasioni perfette per scoprire l'anima autentica della regione e per godere della calorosa ospitalit\u00e0 degli abitanti.\r\n\r\nIn conclusione, il Lago del Turano rappresenta una destinazione perfetta per chi desidera immergersi in un ambiente naturale di straordinaria bellezza, arricchito da una storia e una cultura profonde. \u00c8 un luogo dove la tranquillit\u00e0 del paesaggio si unisce alla vivacit\u00e0 delle tradizioni locali, offrendo un'esperienza unica e indimenticabile.[\/vc_column_text][vc_empty_space height=\"25px\"][\/vc_column][\/vc_row]","post_title":"Lago del Turano","post_link":"https:\/\/geosabina.it\/altri-comuni\/lago-del-turano\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lago del Turano\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/Lago-del-Turano-52-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1720170010056{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1702570858261{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;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":616,\"to_translate\":{\"en\":616}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Lago del Turano, Provincia di Rieti, Italia","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.21819259999999","%_wpgmp_metabox_longitude%":"12.9521888","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"18\";i:3;s:2:\"20\";i:4;s:2:\"22\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"23\";}","%_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","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Lago del Turano","%_yoast_wpseo_metadesc%":"Il Lago del Turano \u00e8 un affascinante bacino artificiale\u00a0 circondato dai suggestivi monti Sabini. Questo lago, nato negli anni '30 del XX secolo in seguito alla costruzione di una diga sul fiume Turano, si estende per circa 10 chilometri quadrati e rappresenta una delle principali attrazioni naturali della provincia di Rieti.","%_yoast_wpseo_linkdex%":"76","%_oembed_1eb08ede5fcfd3a110467a2c63748b96%":"{{unknown}}","%_oembed_36cedc6b2f240b2eb3df757c5e017720%":"{{unknown}}","%_thumbnail_id%":"13813","%_dp_original%":"10942","%_edit_lock%":"1720195072:6","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/bellezze-naturali_sito.png"},"id":13808,"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\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Castel di Tora","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Castel di Tora\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/Castel-di-Tora-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\/altri-comuni\/castel-di-tora\/\" class=\"fc-post-link\">Castel di Tora<\/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":"02020 Castel di Tora RI, Italia","location":{"lat":"42.216346","city":"Castel di Tora","state":"Lazio","country":"Italia","lng":"12.9659756","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/castel-di-tora\/","zoom":18,"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]<strong>Castel di Tora<\/strong> \u00e8 un\u00a0 borgo\u00a0 immerso nella natura incontaminata della valle del Turano. Questo piccolo comune, che conta circa 300 abitanti, \u00e8 arroccato su una collina che si affaccia sul <strong>Lago del Turano<\/strong>, offrendo una vista mozzafiato e un'atmosfera di pace e tranquillit\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 gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner][vc_empty_space height=\"40px\"][vc_single_image image=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/comuni-in-rete\/\"][\/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%2F02020%2BCastel%2Bdi%2BTora%2BRI%2F%4042.2152587%2C12.9629551%2C18z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132fa4979a60139f%3A0xaa32cbe6e9f6e69b!8m2!3d42.216346!4d12.9659756!16s%252Fg%252F11bc5w7x71%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<h1>Castel di<strong> Tora<\/strong><\/h1>\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_1720093079479{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Castel di Tora\r\n02020, 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_1720093019621{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_row_inner][vc_empty_space height=\"40px\"][vc_column_text]\r\n<div class=\"flex flex-grow flex-col max-w-full\">\r\n<div class=\"min-h-[20px] text-message flex flex-col items-start whitespace-pre-wrap break-words [.text-message+&amp;]:mt-5 juice:w-full juice:items-end overflow-x-auto gap-2\" dir=\"auto\" data-message-author-role=\"assistant\" data-message-id=\"84876e6f-1d44-477c-a31a-1786dcb2b276\">\r\n<div class=\"flex w-full flex-col gap-1 juice:empty:hidden juice:first:pt-[3px]\">\r\n<div class=\"markdown prose w-full break-words dark:prose-invert dark\">\r\n\r\n<strong>Castel di Tora<\/strong> \u00e8 un\u00a0 borgo\u00a0 immerso nella natura incontaminata della valle del Turano. Questo piccolo comune, che conta circa 300 abitanti, \u00e8 arroccato su una collina che si affaccia sul <a href=\"https:\/\/geosabina.it\/altri-comuni\/lago-del-turano\/\"><strong>Lago del Turano<\/strong><\/a>, offrendo una vista mozzafiato e un'atmosfera di pace e tranquillit\u00e0.\r\n\r\nLe origini di Castel di Tora risalgono al periodo medievale, e il suo nome deriva dalla<strong> Torre dei Paladini<\/strong>, una struttura difensiva che faceva parte del sistema di fortificazioni a protezione del territorio. Il borgo ha mantenuto intatta la sua struttura originale, con strette viuzze, case in pietra e scorci caratteristici.\r\n\r\nUno dei punti di interesse principali del borgo \u00e8 il <strong>Castello<\/strong>, da cui il paese prende il nome. Sebbene oggi rimangano solo i ruderi della torre, il fascino del luogo \u00e8 immutato, e la sua posizione dominante offre una vista spettacolare sulla vallata e sul lago sottostante. Passeggiando per le vie del borgo, si possono ammirare edifici storici, <strong>chiese antiche<\/strong> e affascinanti piazzette che conservano l'atmosfera autentica del medioevo.\r\n\r\nLa Chiesa di <strong>San Giovanni Evangelista<\/strong>, risalente al XIII secolo, \u00e8 un altro luogo di grande interesse. Al suo interno, si trovano<strong> pregevoli opere d'arte<\/strong>, tra cui affreschi e sculture che testimoniano la ricchezza culturale e artistica di Castel di Tora. La chiesa \u00e8 il fulcro della vita religiosa del paese e un punto di ritrovo per la comunit\u00e0 locale.\r\n\r\nUn altro elemento distintivo del territorio di Castel di Tora \u00e8 sicuramente il<a href=\"https:\/\/geosabina.it\/altri-comuni\/lago-del-turano\/\"><strong> Lago del Turano<\/strong><\/a>. Le sue acque limpide e i paesaggi circostanti offrono numerose opportunit\u00e0 per attivit\u00e0 all'aria aperta, come il trekking, la pesca e gli sport acquatici. Il lago \u00e8 anche un luogo ideale per rilassarsi e godere della bellezza naturale della regione.\r\n\r\nCastel di Tora \u00e8 noto anche per le sue tradizioni <strong>culinarie<\/strong>. I piatti tipici della cucina locale riflettono la semplicit\u00e0 e la genuinit\u00e0 della tradizione contadina. Tra le specialit\u00e0 pi\u00f9 apprezzate ci sono i <strong>\u201cstrigliozzi\u201d<\/strong>, una pasta fatta a mano servita con sughi robusti, e le prelibatezze a base di pesce di lago. Le sagre e le feste locali, che si tengono durante l'anno, sono occasioni perfette per assaporare questi piatti e immergersi nella cultura del luogo.\r\n\r\nLa bellezza di Castel di Tora risiede non solo nel suo patrimonio storico e naturale, ma anche nella sua capacit\u00e0 di mantenere vive <strong>le tradizioni e la cultura locale<\/strong>. La comunit\u00e0 \u00e8 accogliente e orgogliosa del proprio passato, e i visitatori sono sempre i <strong>benvenuti<\/strong> a partecipare alle festivit\u00e0 e agli eventi che animano il borgo.\r\n\r\nIn conclusione, questo luogo \u00e8\u00a0 una destinazione ideale per chi cerca un luogo autentico e tranquillo, lontano dal trambusto della vita moderna, dove la bellezza del passato \u00e8 ancora viva e tangibile.\r\n\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":"Castel di Tora","post_link":"https:\/\/geosabina.it\/altri-comuni\/castel-di-tora\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Castel di Tora\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/Castel-di-Tora-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1720093079479{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1720093019621{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;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":566,\"to_translate\":{\"en\":566}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"02020 Castel di Tora RI, Italia","%_wpgmp_location_city%":"Castel di Tora","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.216346","%_wpgmp_metabox_longitude%":"12.9659756","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"18\";i:3;s:2:\"20\";i:4;s:2:\"22\";}","%_wpgmp_metabox_marker_id%":"a:3:{i:0;s:1:\"5\";i:1;s:2:\"13\";i:2;s:2:\"23\";}","%_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","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Castel di Tora","%_yoast_wpseo_metadesc%":"Castel di Tora \u00e8 un\u00a0 borgo\u00a0 immerso nella natura incontaminata della valle del Turano. Questo piccolo comune, che conta circa 300 abitanti, \u00e8 arroccato su una collina che si affaccia sul Lago del Turano, offrendo una vista mozzafiato e un'atmosfera di pace e tranquillit\u00e0.","%_yoast_wpseo_linkdex%":"69","%_dp_original%":"11077","%_edit_lock%":"1720424133:6","%_edit_last%":"4","%_thumbnail_id%":"13806","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dimore-storiche_sito.png"},"id":13798,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dimore-storiche_sito.png","name":"Dimore Storiche \/ Historic Residences","id":"5","type":"category","extension_fields":{"cat_order":"1"}},{"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"}},{"icon":"https:\/\/geosabina.it\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Punto Panoramico Lago del Turano","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Punto Panoramico Lago del Turano\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/05-1-Lago-del-Turano-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\/altri-comuni\/punto-panoramico-lago-del-turano\/\" class=\"fc-post-link\">Punto Panoramico Lago del Turano<\/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":"02020 Colle di Tora RI, Italia","location":{"lat":"42.2220915","city":"Colle di Tora","state":"Lazio","country":"Italia","lng":"12.9326483","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/punto-panoramico-lago-del-turano\/","zoom":18,"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 punto panoramico si trova nei pressi del borgo di Castel di Tora, uno dei comuni che si affacciano sul lago, e offre una vista mozzafiato sulle acque blu del lago, circondate da colline verdeggianti e montagne imponenti.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\"][vc_empty_space height=\"25px\"][\/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%2FBelvedere%2BPanoramico%2BAttrezzato%2F%4042.2218327%2C12.9316949%2C549m%2Fdata%3D!3m1!1e3!4m6!3m5!1s0x132fa5eb248fd3a3%3A0x2d3addb230de1312!8m2!3d42.2220915!4d12.9326483!16s%252Fg%252F11f731nfyj%3Fentry%3Dttu|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>Punto Panoramico <strong>Lago del Turano<\/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_1720091689967{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Belvedere Panoramico Attrezato\r\n02020, <strong>Colle di Tora,<\/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_1716452714894{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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Il punto panoramico si trova nei pressi del borgo di <strong>Castel di Tora<\/strong>, uno dei comuni che si affacciano sul lago, e offre una vista mozzafiato sulle acque <strong>blu del lago<\/strong>, circondate da colline verdeggianti e montagne imponenti. Da questo punto \u00e8 possibile ammirare il contrasto tra le<strong> acque tranquille<\/strong> del lago e il paesaggio circostante, che cambia colore con le stagioni, offrendo sempre nuove e affascinanti prospettive.\r\n\r\nLa vista dal punto panoramico comprende anche i pittoreschi borghi che si affacciano sul lago, come <strong><a href=\"https:\/\/geosabina.it\/altri-comuni\/castel-di-tora\/\">Castel di Tora<\/a> e <a href=\"https:\/\/geosabina.it\/altri-comuni\/colle-di-tora\/\">Colle di Tora<\/a><\/strong>, caratterizzati da antiche case in pietra e stretti vicoli che raccontano la storia e la cultura della regione. Questi borghi aggiungono un tocco di fascino e autenticit\u00e0 al paesaggio, rendendo il panorama ancora pi\u00f9 suggestivo.[\/vc_column_text][vc_empty_space height=\"30px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"3\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"13790,13780,13778\"][vc_column_text]Le foto della gallery sono state realizzate in collaborazione con il\u00a0<a href=\"https:\/\/www.facebook.com\/groups\/45975827398\" target=\"_blank\" rel=\"noopener\">gruppo Facebook \u201cFoto della Sabina\u201d<\/a>\u00a0a cura di\u00a0<a href=\"https:\/\/www.facebook.com\/FabrizioMei72\/\" target=\"_blank\" rel=\"noopener\">Fabrizio Mei.<\/a>[\/vc_column_text][vc_empty_space height=\"35px\"][vc_row_inner][vc_column_inner css=\".vc_custom_1716459725229{margin-top: 4px !important;margin-bottom: 2px !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;}\"][vc_text_separator title=\"Curiosit\u00e0\" i_icon_fontawesome=\"fas fa-camera-retro\" 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\" css=\".vc_custom_1718899563198{margin-top: -18px !important;}\"][vc_column_text]La vista offerta dal punto panoramico \u00e8 particolarmente suggestiva al tramonto, quando il cielo si tinge di colori caldi e le acque del lago riflettono le sfumature del crepuscolo. Questo momento della giornata \u00e8 ideale per scattare fotografie memorabili e per godersi la tranquillit\u00e0 e la bellezza del paesaggio in un'atmosfera serena e rilassante.[\/vc_column_text][vc_empty_space height=\"30px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"3\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"13786,13788,13774\"][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row]","post_title":"Punto Panoramico Lago del Turano","post_link":"https:\/\/geosabina.it\/altri-comuni\/punto-panoramico-lago-del-turano\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Punto Panoramico Lago del Turano\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/05-1-Lago-del-Turano-1024x576-1-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1720091689967{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1716452714894{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1716459725229{margin-top: 4px !important;margin-bottom: 2px !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;}.vc_custom_1718899563198{margin-top: -18px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":316,\"to_translate\":{\"en\":316}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"02020 Colle di Tora RI, Italia","%_wpgmp_location_city%":"Colle di Tora","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2220915","%_wpgmp_metabox_longitude%":"12.9326483","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"19\";i:3;s:2:\"20\";i:4;s:2:\"24\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"11\";}","%_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","%_yoast_wpseo_focuskw%":"Punto Panoramico Lago del Turano","%_yoast_wpseo_metadesc%":"Il punto panoramico si trova nei pressi del borgo di Castel di Tora, uno dei comuni che si affacciano sul lago, e offre una vista mozzafiato sulle acque blu del lago, circondate da colline verdeggianti e montagne imponenti.","%_yoast_wpseo_linkdex%":"71","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"13776","%_dp_original%":"13368","%_edit_lock%":"1720425404:6","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png"},"id":13764,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png","name":"Punti Panoramici \/ Viewpoints","id":"11","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Parco naturale Regionale dei Monti Lucretili","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Parco naturale Regionale dei Monti Lucretili\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/monti-lucretili-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\/parco-naturale-regionale-dei-monti-lucretili\/\" class=\"fc-post-link\">Parco naturale Regionale dei Monti Lucretili<\/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":"Unnamed Road,Citt\u00e0 Metropolitana di, 00012 Roma RM, Italia","location":{"lat":"42.07133719999999","city":"Roma","state":"Lazio","country":"Italia","lng":"12.7630474","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/parco-naturale-regionale-dei-monti-lucretili\/","zoom":18,"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 Riserva Naturale <strong>Monti Lucretili<\/strong>, copre una vasta area di circa <strong>18.000 ettari<\/strong> tra le province di <strong>Roma e Rieti<\/strong>. Istituita nel 1989, la riserva ha lo scopo di <strong>proteggere<\/strong> la <strong>ricchezza naturale e paesaggistica della zona<\/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 gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/intorno-a-te\/punti-da-non-perdere\/\"][vc_empty_space height=\"25px\"][\/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%2Fplace%2FParco%2Bregionale%2Bnaturale%2Bdei%2BMonti%2BLucretili%2F%4042.0711794%2C12.7618065%2C19z%2Fdata%3D!4m6!3m5!1s0x132f9e4e2e73c5e3%3A0x6bf6fd1ec9e54932!8m2!3d42.0713372!4d12.7630474!16s%252Fg%252F121xjv15%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>Parco naturale Regionale dei <strong>Monti Lucretili<\/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_1720074823757{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]\r\n<div class=\"gm-style-iw gm-style-iw-c\" tabindex=\"-1\" role=\"dialog\">\r\n<div class=\"gm-style-iw-d\">\r\n<div class=\"gm-iw\">\r\n<div class=\"gm-iw\">Viale Adriano Petrocchi, 54-68<\/div>\r\n<div class=\"gm-iw\">00018 <strong>Palombara Sabina,<\/strong> RM<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n[\/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_1720074807198{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Dal <strong>lunedi' al venerdi<\/strong>\r\nDalle 9:00 alle 15: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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_column_text]Per avere pi\u00f9 info, vai al sito web del Parco Regionale[\/vc_column_text][vc_btn title=\"Vai al sito web\" color=\"chino\" size=\"xs\" align=\"left\" i_icon_fontawesome=\"fas fa-share-square\" add_icon=\"true\" link=\"url:https%3A%2F%2Fparcolucretili.it%2F|target:_blank\" css=\".vc_custom_1720173689774{margin-top: 12px !important;}\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]La Riserva Naturale <strong>Monti Lucretili<\/strong>, copre una vasta area di circa <strong>18.000 ettari<\/strong> tra le province di <strong>Roma e Rieti<\/strong>. Istituita nel 1989, la riserva ha lo scopo di <strong>proteggere<\/strong> la <strong>ricchezza naturale e paesaggistica della zona<\/strong>, promuovendo al contempo attivit\u00e0 di educazione ambientale e sviluppo sostenibile. Il territorio della riserva \u00e8 caratterizzato da una variet\u00e0 di ambienti naturali, che vanno dalle <strong>foreste di faggio<\/strong> e <strong>querce<\/strong> alle <strong>praterie montane<\/strong>, <strong>ai pascoli e alle aree rocciose<\/strong>. Questo mosaico di habitat favorisce una <strong>biodiversit\u00e0 significativa<\/strong>, con una flora che include specie come il carpino, l'acero e il castagno, oltre a numerose piante erbacee e arbustive. La riserva include diversi comuni tra le province di Rieti e Roma. Alcuni dei comuni compresi sono Moricone, Montorio Romano, Nerola, Palombara Sabina, Monteflavio, Licenza, Percile, Orvinio, Scandriglia e San Polo dei Cavalieri. Questi comuni offrono punti di accesso alla riserva e sono caratterizzati da un ricco patrimonio storico e culturale.\r\n\r\n<strong>La fauna<\/strong> della Riserva Naturale Monti Lucretili \u00e8 altrettanto diversificata, con la presenza di mammiferi <strong>come il lupo<\/strong>, <strong>il cinghiale<\/strong>,<strong> il cervo e la volpe<\/strong>. La riserva ospita anche una ricca avifauna, tra cui specie di rapaci come <strong>l'aquila reale e il falco pellegrino<\/strong>, nonch\u00e9 numerosi piccoli uccelli che popolano i boschi e le praterie. Uno degli aspetti pi\u00f9 affascinanti della riserva \u00e8 la presenza di antichi insediamenti e testimonianze storiche che risalgono all'epoca romana e medievale. Si possono trovare resti di ville romane, castelli medievali e chiese rurali, che aggiungono un valore culturale significativo all'area protetta.\r\n\r\nLa riserva offre numerose opportunit\u00e0 per attivit\u00e0 all'aperto, come l'escursionismo, il trekking e il birdwatching. I visitatori possono esplorare una rete di sentieri ben segnalati che attraversano i vari ambienti naturali e offrono panorami mozzafiato. Sono disponibili anche visite guidate e programmi educativi rivolti a scuole e gruppi, con l'obiettivo di sensibilizzare il pubblico sull'importanza della conservazione della natura e della biodiversit\u00e0.\r\n\r\nOltre alla sua importanza ecologica e culturale, la Riserva Naturale Monti Lucretili svolge un ruolo cruciale nella protezione delle risorse idriche, con la presenza di numerose sorgenti e torrenti che contribuiscono all'approvvigionamento idrico delle aree circostanti. L'accesso alla riserva \u00e8 libero e gratuito, ma \u00e8 fondamentale rispettare le norme di comportamento per preservare l'integrit\u00e0 dell'ambiente naturale. Il centro visita della riserva fornisce informazioni utili, mappe e servizi per i visitatori, rendendo questa destinazione ideale per chi desidera immergersi nella natura e scoprire le bellezze storiche e paesaggistiche del Lazio.[\/vc_column_text][vc_empty_space height=\"25px\"][\/vc_column][\/vc_row]","post_title":"Parco naturale Regionale dei Monti Lucretili","post_link":"https:\/\/geosabina.it\/parco-naturale-regionale-dei-monti-lucretili\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Parco naturale Regionale dei Monti Lucretili\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/monti-lucretili-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1720074823757{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1720074807198{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_1720173689774{margin-top: 12px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":567,\"to_translate\":{\"en\":567}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Unnamed Road,Citt\u00e0 Metropolitana di, 00012 Roma RM, Italia","%_wpgmp_location_city%":"Roma","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.07133719999999","%_wpgmp_metabox_longitude%":"12.7630474","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:4:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"18\";i:3;s:2:\"20\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"23\";}","%_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","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Parco naturale Regionale dei Monti Lucretili","%_yoast_wpseo_metadesc%":"Il Parco Naturale dei Monti Lucretili, copre una vasta area di circa 18.000 ettari tra le province di Roma e Rieti. Istituita nel 1989, la riserva ha lo scopo di proteggere la ricchezza naturale e paesaggistica della zona.","%_yoast_wpseo_linkdex%":"60","%_oembed_1eb08ede5fcfd3a110467a2c63748b96%":"{{unknown}}","%_oembed_36cedc6b2f240b2eb3df757c5e017720%":"{{unknown}}","%_thumbnail_id%":"13751","%_dp_original%":"13728","%_last_translation_edit_mode%":"native-editor","%_edit_lock%":"1720173925:6","%_edit_last%":"6","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/bellezze-naturali_sito.png"},"id":13748,"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\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Riserva Naturale Monte Navegna e Monte Cervia","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Riserva Naturale Monte Navegna e Monte Cervia\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/Monte-Cervia-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\/altri-comuni\/riserva-naturale-monte-navegna-e-monte-cervia\/\" class=\"fc-post-link\">Riserva Naturale Monte Navegna e Monte Cervia<\/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 Roma, 33, 02020 Varco Sabino RI, Italia","location":{"lat":"42.2056078","city":"Varco Sabino","state":"Lazio","country":"Italia","lng":"13.0142294","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/riserva-naturale-monte-navegna-e-monte-cervia\/","zoom":18,"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 Riserva Naturale Monte Navegna e Monte Cervia \u00e8 un'area protetta situata nel Lazio, in Italia, che si estende su una superficie di circa 3.500 ettari tra le province di Rieti e L'Aquila. Istituita nel 1988, la riserva ha l'obiettivo di proteggere il patrimonio naturale e paesaggistico della zona e di promuovere uno sviluppo sostenibile per le comunit\u00e0 locali. Comprende le montagne di Monte Navegna, che raggiunge un'altitudine di 1.508 metri, e Monte Cervia, alto 1.439 metri.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/intorno-a-te\/punti-da-non-perdere\/\"][vc_empty_space height=\"25px\"][\/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%2Fplace%2FRiserva%2BNaturale%2BMonte%2BNavegna%2BE%2BMonte%2BCervia%2F%4042.2044337%2C12.9771454%2C13.5z%2Fdata%3D!4m6!3m5!1s0x132fbc841423cbd9%3A0xf094f9bab213c40!8m2!3d42.2056078!4d13.0142294!16s%252Fg%252F121rcr27%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>Riserva Naturale <strong>Monte Navegna e Monte Cervia<\/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_1720072273037{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]\r\n<div class=\"gm-style-iw gm-style-iw-c\" tabindex=\"-1\" role=\"dialog\">\r\n<div class=\"gm-style-iw-d\">\r\n<div class=\"gm-iw\">Via Roma, 33<\/div>\r\n<div class=\"gm-iw\">02020 <strong>Varco Sabino<\/strong> RI<\/div>\r\n<\/div>\r\n<\/div>\r\n[\/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_1702570858261{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]sempre aperto\r\n\r\n[\/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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]\r\n<div class=\"flex-shrink-0 flex flex-col relative items-end\">\r\n<div>\r\n<div class=\"pt-0.5 juice:pt-0\">\r\n<div class=\"gizmo-bot-avatar flex h-6 w-6 items-center justify-center overflow-hidden rounded-full juice:h-8 juice:w-8\">\r\n<div class=\"relative p-1 rounded-sm flex items-center justify-center bg-token-main-surface-primary text-token-text-primary h-8 w-8\"><\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<div class=\"group\/conversation-turn relative flex w-full min-w-0 flex-col agent-turn\">\r\n<div class=\"flex-col gap-1 md:gap-3\">\r\n<div class=\"flex flex-grow flex-col max-w-full\">\r\n<div class=\"min-h-[20px] text-message flex flex-col items-start whitespace-pre-wrap break-words [.text-message+&amp;]:mt-5 juice:w-full juice:items-end overflow-x-auto gap-2\" dir=\"auto\" data-message-author-role=\"assistant\" data-message-id=\"5bbfb21d-8046-436b-8ef3-9fc604540a4b\">\r\n<div class=\"flex w-full flex-col gap-1 juice:empty:hidden juice:first:pt-[3px]\">\r\n<div class=\"markdown prose w-full break-words dark:prose-invert dark\">\r\n\r\nLa Riserva Naturale Monte Navegna e Monte Cervia \u00e8 un'area protetta situata nel Lazio, in Italia, che si estende su una superficie di circa 3.500 ettari tra le province di Rieti e L'Aquila. Istituita nel 1988, la riserva ha l'obiettivo di proteggere il patrimonio naturale e paesaggistico della zona e di promuovere uno sviluppo sostenibile per le comunit\u00e0 locali. Comprende le montagne di Monte Navegna, che raggiunge un'altitudine di 1.508 metri, e Monte Cervia, alto 1.439 metri.\r\n\r\nLa riserva \u00e8 caratterizzata da una grande variet\u00e0 di habitat naturali. Tra questi si trovano foreste di faggio e querce, praterie montane e pascoli. La flora \u00e8 particolarmente ricca e diversificata, includendo specie tipiche delle aree appenniniche come l'acero e il castagno, oltre a diverse specie di orchidee selvatiche. La fauna della riserva \u00e8 altrettanto variegata, con la presenza di mammiferi come il lupo appenninico, il cinghiale, il cervo e la volpe. La riserva \u00e8 anche un habitat importante per diverse specie di uccelli, tra cui l'aquila reale e il falco pellegrino, nonch\u00e9 numerosi rapaci notturni.\r\n\r\nOltre alla protezione della biodiversit\u00e0, la riserva offre numerose opportunit\u00e0 per attivit\u00e0 ricreative all'aperto. Gli appassionati di escursionismo possono usufruire di una rete di sentieri segnalati che attraversano i vari ambienti della riserva. Il birdwatching \u00e8 un'altra attivit\u00e0 popolare, grazie alla ricca avifauna presente nella zona. Inoltre, la riserva organizza attivit\u00e0 didattiche e visite guidate, rivolte soprattutto a scuole e gruppi, per sensibilizzare il pubblico sull'importanza della conservazione della natura.\r\n\r\nDal punto di vista ecologico, la riserva svolge un ruolo fondamentale nella conservazione della biodiversit\u00e0 e nella protezione delle risorse idriche, grazie alla presenza di numerose sorgenti e corsi d'acqua. Culturalmente, l'area \u00e8 di grande interesse, con diversi siti archeologici e storici, tra cui antichi insediamenti, castelli medievali e chiese rurali che testimoniano la ricca storia della regione.\r\n\r\nLa Riserva Naturale Monte Navegna e Monte Cervia \u00e8 accessibile tutto l'anno e l'ingresso \u00e8 gratuito, sebbene sia importante rispettare le regole della riserva per preservare l'ambiente naturale. Il centro visita della riserva fornisce informazioni dettagliate, mappe dei sentieri e servizi per i visitatori, rendendo questa destinazione ideale per gli amanti della natura e per chi desidera esplorare le bellezze naturali e culturali del Lazio.\r\n\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][\/vc_column][\/vc_row]","post_title":"Riserva Naturale Monte Navegna e Monte Cervia","post_link":"https:\/\/geosabina.it\/altri-comuni\/riserva-naturale-monte-navegna-e-monte-cervia\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Riserva Naturale Monte Navegna e Monte Cervia\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/07\/Monte-Cervia-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1720072273037{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1702570858261{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;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":567,\"to_translate\":{\"en\":567}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Roma, 33, 02020 Varco Sabino RI, Italia","%_wpgmp_location_city%":"Varco Sabino","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2056078","%_wpgmp_metabox_longitude%":"13.0142294","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:4:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"18\";i:3;s:2:\"22\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"23\";}","%_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","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Riserva Naturale Monte Navegna e Monte Cervia","%_yoast_wpseo_metadesc%":"La Riserva Naturale Monte Navegna e Monte Cervia \u00e8 un'area protetta situata nel Lazio, in Italia, che si estende su una superficie di circa 3.500 ettari tra le province di Rieti e L'Aquila. Istituita nel 1988, la riserva ha l'obiettivo di proteggere il patrimonio naturale e paesaggistico della zona.","%_yoast_wpseo_linkdex%":"70","%_oembed_1eb08ede5fcfd3a110467a2c63748b96%":"{{unknown}}","%_oembed_36cedc6b2f240b2eb3df757c5e017720%":"{{unknown}}","%_thumbnail_id%":"13745","%_dp_original%":"10942","%_edit_lock%":"1720193561:6","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/bellezze-naturali_sito.png"},"id":13728,"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\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Il Borgo di Toffia","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Il Borgo di Toffia\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/11\/anteprima.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\/toffia\/il-borgo-di-toffia\/\" class=\"fc-post-link\">Il Borgo di Toffia<\/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 Collitrone, 48, 02039 Toffia RI, Italia","location":{"lat":"42.2122769","city":"Toffia","state":"Lazio","country":"Italia","lng":"12.7503915","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/toffia\/il-borgo-di-toffia\/","zoom":18,"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]Toffia, un affascinante borgo situato nel cuore dell\u2019Italia tra le colline della Sabina, \u00e8 rinomato per la sua ricca storia e la sua architettura, in particolare per i suoi antichi palazzi che risalgono a diverse epoche storiche.[\/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=\"3897\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/toffia\/\"][\/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%2BCollitrone%2C%2B48%2C%2B02039%2BToffia%2BRI%2F%4042.2122769%2C12.7478166%2C17z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132f0bc8f96281c3%3A0x6b21f26e6a5c79f2!8m2!3d42.2122769!4d12.7503915!16s%252Fg%252F11c2mw3bmw%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>Il Borgo di <strong>Toffia<\/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_1719499864337{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Collitrone, 48\r\n02039 <strong>Toffia<\/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_1719483058942{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_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]<strong>Toffia<\/strong>, un affascinante borgo situato nel cuore dell\u2019Italia tra le colline della Sabina, \u00e8 rinomato per la sua ricca storia e la sua architettura, in particolare per i suoi antichi palazzi che risalgono a diverse epoche storiche.\r\n\r\nAvventuratevi nelle strade lastricate di questo incantevole borgo e lasciatevi trasportare indietro nel tempo mentre scoprite la maestosit\u00e0 dei palazzi che circondano il centro storico. Ogni palazzo racconta una storia unica, dalle imponenti dimore delle <strong>famiglie nobili<\/strong> che hanno governato la regione, alle affascinanti residenze degli artisti e degli intellettuali che hanno contribuito a plasmare il tessuto culturale di Toffia.\r\n\r\nDurante questo itinerario, avrete l\u2019opportunit\u00e0 di ammirare l\u2019architettura in stile rinascimentale e barocco, con facciate decorate, cortili interni eleganti e dettagli architettonici affascinanti. Viaggerete attraverso le epoche esplorando le dimore di antiche famiglie aristocratiche, scoprirete le stanze segrete che custodiscono tesori artistici e vi perderete nei giardini incantati che circondano questi palazzi storici.\r\n\r\nIniziamo il nostro percorso proprio dalla porta principale, <a href=\"https:\/\/geosabina.it\/toffia\/porta-maggiore\/\"><strong>Porta Maggiore.<\/strong><\/a> Troviamo subito <a href=\"https:\/\/geosabina.it\/toffia\/palazzo-ruffetti-bufalieri\/\">Palazzo Ruffetti<\/a>, costruito da <strong>Fabrizio Ruffetti<\/strong> nel 1596, forse su disegno di <strong>Antonio da Sangallo il Giovane.<\/strong> L\u2019iscrizione commemorativa posta sul marcapiano sotto le finestre del primo livello ricorda questa data, e il palazzo fu completato dal figlio Mario. Successivamente appartenuto alla famiglia<strong> Bufalieri<\/strong>, il palazzo ha mantenuto una vocazione didattica, diventando sede delle <strong>Scuole Elementari di Toffia<\/strong> negli anni cinquanta del Novecento.\r\n\r\nPoco dopo la<a href=\"https:\/\/geosabina.it\/toffia\/biblioteca-di-toffia\/\"><strong> Biblioteca di Toffia<\/strong><\/a>, c\u2019\u00e8 <a href=\"https:\/\/geosabina.it\/toffia\/palazzo-orsini\/\"><strong>Palazzo Orsini<\/strong><\/a>, costruito nel XV secolo. Con le sue linee semplici e superbe, \u00e8 un magnifico esempio dell\u2019architettura umanistica. Gli Orsini possedevano pi\u00f9 di una dimora a Toffia, il che non sorprende considerando il loro dominio sulla Commenda farfense dal 1437 al 1543 e la loro ricostruzione della <strong>chiesa di Farfa<\/strong>, consacrata nel 1496 sopra la precedente basilica carolingia.\r\n\r\nProseguendo, troviamo <a href=\"https:\/\/geosabina.it\/toffia\/casa-degli-oddoni\/\"><strong>Casa degli Oddoni<\/strong><\/a> e <a href=\"https:\/\/geosabina.it\/toffia\/casa-locchi\/\"><strong>Casa Locchi<\/strong><\/a>, attaccati tra loro ma di due epoche storiche diverse. All\u2019inizio di Via Montecavallo, salendo verso la Chiesa di <a href=\"https:\/\/geosabina.it\/toffia\/chiesa-di-s-maria-nova\/\"><strong>S. Maria Nova<\/strong><\/a>, si incontra il settecentesco<a href=\"https:\/\/geosabina.it\/toffia\/palazzo-palica\/\"><strong> Palazzo Palica<\/strong><\/a>, poi <strong>Castellani Brancaleoni<\/strong>, oggi di vari proprietari, che d\u00e0 avvio a una zona pi\u00f9 nobile del paese.\r\n\r\n[\/vc_column_text][vc_empty_space height=\"30px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"3\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" images=\"13520,13526,13522\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"30px\"][vc_column_text]In Via Montecavallo si trova il seicentesco <a href=\"https:\/\/geosabina.it\/toffia\/palazzo-palma\/\"><strong>Palazzo Palma<\/strong><\/a>. Sul prospetto che guarda la valle, presenta una caratteristica loggetta incastonata tra quelle che dovevano essere due torri di guardia delle antiche mura. Sull\u2019architrave del bel portale in travertino, figurano due colombe con palme d\u2019olivo nel becco.\r\n\r\nIl Palazzo <a href=\"https:\/\/geosabina.it\/toffia\/palazzo-castellani-grio-casa-orsini\/\"><strong>Castellani Grio<\/strong><\/a>, come Palazzo Orsini in Via Porta Maggiore, fu costruito dalla <strong>famiglia Orsini<\/strong> nel XV secolo, durante il loro controllo sulla Commenda Farfense. L\u2019edificio presenta due piani pi\u00f9 un piano interrato.\r\n\r\nQuasi attaccato al <a href=\"https:\/\/geosabina.it\/toffia\/palazzo-castellani\/\"><strong>Palazzo Castellani<\/strong><\/a> troviamo la <a href=\"https:\/\/geosabina.it\/toffia\/casa-di-monsignor-fido\/\"><strong>Casa di Monsignore Fido.<\/strong><\/a> Questa cinquecentesca dimora, ora appartenente a diversi proprietari, \u00e8 probabilmente stata sede di alti prelati legati alla sede vescovile di Toffia.\r\n\r\nConcludiamo il nostro itinerario con<strong> Palazzo Castellani<\/strong> e <a href=\"https:\/\/geosabina.it\/toffia\/palazzo-gabrielli\/\"><strong>Palazzo Gabrielli.<\/strong><\/a> Nel primo, nel 1878, l\u2019archeologo Fiorelli pot\u00e9 esaminare, grazie alla cortesia dei signori <strong>Mariano e Gaspare Castellani<\/strong>, un frammento di lapide giacente in una stanza sotterranea. Sebbene molto corroso e in parte illeggibile, perch\u00e9 usato come soglia di porta, esso costituisce una testimonianza storica preziosa.\r\n\r\nPalazzo Gabrielli, secondo la tradizione, \u00e8 stato la residenza dei vescovi sabini.[\/vc_column_text][vc_empty_space height=\"30px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"3\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" images=\"13524,13528,13530\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"30px\"][\/vc_column][\/vc_row]","post_title":"Il Borgo di Toffia","post_link":"https:\/\/geosabina.it\/toffia\/il-borgo-di-toffia\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Il Borgo di Toffia\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/11\/anteprima.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1719499864337{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1719483058942{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\":628,\"to_translate\":{\"en\":628}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Collitrone, 48, 02039 Toffia RI, Italia","%_wpgmp_location_city%":"Toffia","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2122769","%_wpgmp_metabox_longitude%":"12.7503915","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"11\";}","%_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","%_thumbnail_id%":"4687","%_last_translation_edit_mode%":"native-editor","%_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\" allowfullscreen><\/iframe>","%_oembed_time_786910fae9e41ded3a3d625dd28cd55c%":"1655972262","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Il Borgo di Toffia","%_yoast_wpseo_metadesc%":"Toffia, un affascinante borgo situato nel cuore dell\u2019Italia tra le colline della Sabina, \u00e8 rinomato per la sua ricca storia e la sua architettura, in particolare per i suoi antichi palazzi che risalgono a diverse epoche storiche.","%_yoast_wpseo_linkdex%":"74","%_dp_original%":"6723","%_edit_lock%":"1719589493:3","%_edit_last%":"6","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/biblioteche_sito.png"},"id":13510,"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":"Punto Panoramico &#8220;Fori Porta&#8221; Montopoli","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Punto Panoramico &#8220;Fori Porta&#8221; Montopoli\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/06\/04-5-Montopoli-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\/altri-comuni\/punto-panoramico-fori-porta\/\" class=\"fc-post-link\">Punto Panoramico &#8220;Fori Porta&#8221; Montopoli<\/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 XII Ottobre, 4, 02034 Montopoli di Sabina RI, Italia","location":{"lat":"42.245370041144376","city":"Montopoli di Sabina","state":"Lazio","country":"Italia","lng":"12.691415876532435","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/punto-panoramico-fori-porta\/","zoom":18,"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]Da questo punto, lo sguardo si perde verso l'orizzonte, abbracciando le sfumature di verde dei campi e dei boschi, che cambiano con il variare delle stagioni. In primavera e in estate, il panorama si colora di tinte vivaci e luminose.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\"][vc_empty_space height=\"25px\"][\/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%2Fdir%2F%2FVia%2BXII%2BOttobre%2C%2B4%2C%2B02034%2BMontopoli%2Bdi%2BSabina%2BRI%2F%4042.2451815%2C12.6911726%2C20.25z%2Fdata%3D!4m9!4m8!1m0!1m5!1m1!1s0x132f0ebd4d303fbd%3A0x470471de4e588143!2m2!1d12.6913628!2d42.2452893!3e0%3Fentry%3Dttu%26g_ep%3DEgoyMDI0MDkxOC4xIKXMDSoASAFQAw%253D%253D|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>Punto Panoramico <strong>\"Fori Porta\"\u00a0<\/strong>Montopoli di Sabina<\/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_1718896767296{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via XII Ottobre, 4.\r\n02034, <strong>Montopoli di Sabina,<\/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_1716452714894{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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]All\u2019inizio della brevissima Via G. B. Orsini, proprio di fronte al Portonaccio del primo Palazzo Orsini di Montopoli di Sabina, risalta la cinquecentesca Porta Maggiore, il principale accesso al centro storico.\r\n\r\nDi fronte alla Porta Maggiore si trova un punto panoramico che offre una vista mozzafiato sulla valle circostante. Questo belvedere \u00e8 uno dei luoghi pi\u00f9 suggestivi di Montopoli di Sabina, dove si pu\u00f2 ammirare un paesaggio che si estende per chilometri, fatto di dolci colline, uliveti e piccoli borghi disseminati qua e l\u00e0.\r\n\r\nDa questo punto, lo sguardo si perde verso l'orizzonte, abbracciando le sfumature di verde dei campi e dei boschi, che cambiano con il variare delle stagioni. In primavera e in estate, il panorama si colora di tinte vivaci e luminose. In autunno e in inverno, i toni diventano pi\u00f9 caldi e avvolgenti, creando un'atmosfera quasi fiabesca.[\/vc_column_text][vc_empty_space height=\"30px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"3\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"13384,13382,13380\"][vc_column_text]Le foto della gallery sono state realizzate in collaborazione con il\u00a0<a href=\"https:\/\/www.facebook.com\/groups\/45975827398\" target=\"_blank\" rel=\"noopener\">gruppo Facebook \u201cFoto della Sabina\u201d<\/a>\u00a0a cura di\u00a0<a href=\"https:\/\/www.facebook.com\/FabrizioMei72\/\" target=\"_blank\" rel=\"noopener\">Fabrizio Mei.<\/a>[\/vc_column_text][vc_empty_space height=\"35px\"][vc_row_inner][vc_column_inner css=\".vc_custom_1716459725229{margin-top: 4px !important;margin-bottom: 2px !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;}\"][vc_text_separator title=\"Curiosit\u00e0\" i_icon_fontawesome=\"fas fa-camera-retro\" 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\" css=\".vc_custom_1718899563198{margin-top: -18px !important;}\"][vc_column_text]Porta Maggiore, che inizialmente doveva includere un ponte levatoio poi mai realizzato, \u00e8 il risultato di un'importante fase di espansione del borgo e della conseguente riorganizzazione delle sue mura difensive.\r\nL'area esterna a Porta Maggiore, comunemente nota come \"Fori Porta\", \u00e8 da sempre il tradizionale punto di ritrovo e di incontro per i cittadini di Montopoli. Recentemente, l'amministrazione locale ha reso ancora pi\u00f9 accogliente l'area sottostante, dotandola di nuove strutture e servizi.[\/vc_column_text][vc_empty_space height=\"20px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"1\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"13388\"][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row]","post_title":"Punto Panoramico &#8220;Fori Porta&#8221; Montopoli","post_link":"https:\/\/geosabina.it\/altri-comuni\/punto-panoramico-fori-porta\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Punto Panoramico &#8220;Fori Porta&#8221; Montopoli\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/06\/04-5-Montopoli-1024x576-1-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1718896767296{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1716452714894{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1716459725229{margin-top: 4px !important;margin-bottom: 2px !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;}.vc_custom_1718899563198{margin-top: -18px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":350,\"to_translate\":{\"en\":350}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via XII Ottobre, 4, 02034 Montopoli di Sabina RI, Italia","%_wpgmp_location_city%":"Montopoli di Sabina","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.245370041144376","%_wpgmp_metabox_longitude%":"12.691415876532435","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"8\";i:3;s:2:\"19\";i:4;s:2:\"20\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"11\";}","%_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","%_yoast_wpseo_focuskw%":"Punto Panoramico \"Fori Porta\"","%_yoast_wpseo_metadesc%":"All\u2019inizio della brevissima Via G. B. Orsini, proprio di fronte al Portonaccio del primo Palazzo Orsini di Montopoli di Sabina, risalta la cinquecentesca Porta Maggiore, il principale accesso al centro storico.","%_yoast_wpseo_linkdex%":"65","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"13386","%_dp_original%":"13137","%_edit_lock%":"1727085180:6","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png"},"id":13368,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png","name":"Punti Panoramici \/ Viewpoints","id":"11","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Punto Panoramico Fara Sabina","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Punto Panoramico Fara Sabina\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/06\/03-6-Fara-1024x576-Terminillo-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\/altri-comuni\/punto-panoramico-fara-in-sabina\/\" class=\"fc-post-link\">Punto Panoramico Fara Sabina<\/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 del Popolo, 2, 02032 Fara In Sabina RI, Italia","location":{"lat":"42.211481603579536","city":"Fara in Sabina","state":"Lazio","country":"Italia","lng":"12.728355068786623","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/punto-panoramico-fara-in-sabina\/","zoom":18,"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<strong>\u00a0Belvedere di Fara Sabina<\/strong> \u00e8 uno dei luoghi pi\u00f9 affascinanti della Sabina. Questo punto panoramico offre una vista mozzafiato che abbraccia colline verdi, valli rigogliose e un orizzonte che sembra infinito.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\"][vc_empty_space height=\"25px\"][\/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%2FBelvedere%2BFara%2Bin%2BSabina%2F%4042.2113078%2C12.7288865%2C19.86z%2Fdata%3D!4m6!3m5!1s0x132f0b41b783d18b%3A0x190b5b554640f999!8m2!3d42.2114907!4d12.7283421!16s%252Fg%252F11f6dt4bmb%3Fentry%3Dttu|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>Punto Panoramico <strong>Fara Sabina<\/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_1718010222181{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Viale Regina Margherita, 6\r\n02032 <strong>Fara Sabina<\/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_1716452714894{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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Il<strong>\u00a0Belvedere di Fara Sabina<\/strong> \u00e8 uno dei luoghi pi\u00f9 affascinanti della Sabina. Questo punto panoramico offre una vista mozzafiato che abbraccia colline verdi, valli rigogliose e un orizzonte che sembra infinito.\r\n\r\nDal Belvedere i visitatori possono godere di una vista spettacolare che spazia dai <strong>Monti Sabini<\/strong> fino alla <strong>Valle del Tevere<\/strong>. In giornate limpide, \u00e8 possibile scorgere persino la cupola di<strong> San Pietro a Roma.<\/strong> La bellezza del paesaggio cambia con le stagioni: in primavera, i campi fioriti e i boschi verdeggianti creano un quadro di colori vivaci, mentre in autunno le colline si tingono di calde sfumature dorate e rossastre.\r\nInoltre \u00e8 possibile vedere anche i <strong>paesi pi\u00f9 vicini<\/strong> come <strong>Vacone, Casperia, Salisano, Mompeo<\/strong> e le <strong>Montagne della sabina<\/strong> come il <strong>Monte Tancia<\/strong> e <strong>Monte Pizzuto.<\/strong>\r\n\r\nIl belvedere di Fara Sabina \u00e8 facilmente raggiungibile e dispone di un ampio parcheggio, un luogo ideale per una sessione di <strong>fotografia paesaggistica<\/strong>.[\/vc_column_text][vc_empty_space height=\"30px\"][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=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"13141,13143,13145,13217\"][vc_column_text]Le foto della gallery sono state realizzate in collaborazione con il\u00a0<a href=\"https:\/\/www.facebook.com\/groups\/45975827398\" target=\"_blank\" rel=\"noopener\">gruppo Facebook \u201cFoto della Sabina\u201d<\/a>\u00a0a cura di\u00a0<a href=\"https:\/\/www.facebook.com\/FabrizioMei72\/\" target=\"_blank\" rel=\"noopener\">Fabrizio Mei.<\/a>[\/vc_column_text][vc_empty_space height=\"35px\"][vc_row_inner][vc_column_inner css=\".vc_custom_1716459725229{margin-top: 4px !important;margin-bottom: 2px !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;}\"][vc_text_separator title=\"Cosa vedrai\" i_icon_fontawesome=\"fas fa-camera-retro\" 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\" css=\".vc_custom_1718294263156{margin-top: -18px !important;}\"][vc_column_text]<span style=\"color: #868686; font-size: 15px;\">Tramite il punto indicato sulla mappa, \u00e8 possibile scattare meravigliose <\/span><strong style=\"color: #868686; font-size: 15px;\">foto<\/strong><span style=\"color: #868686; font-size: 15px;\"> e godere dei <\/span><strong style=\"color: #868686; font-size: 15px;\">bellissimi panorami<\/strong><span style=\"color: #868686; font-size: 15px;\"> che questo posto ha da offrire. <\/span><span style=\"color: #868686; font-size: 15px;\">Da questo punto panoramico possiamo ammirare i Monti Sabini e i paesi vicino orientandosi anche grazie alla splendida foto scattata da Fabrizio Mei e riportata in basso:<\/span>[\/vc_column_text][vc_empty_space height=\"20px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"1\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"13213\"][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row]","post_title":"Punto Panoramico Fara Sabina","post_link":"https:\/\/geosabina.it\/altri-comuni\/punto-panoramico-fara-in-sabina\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Punto Panoramico Fara Sabina\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/06\/03-6-Fara-1024x576-Terminillo-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1718010222181{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1716452714894{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1716459725229{margin-top: 4px !important;margin-bottom: 2px !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;}.vc_custom_1718294263156{margin-top: -18px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":327,\"to_translate\":{\"en\":327}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via del Popolo, 2, 02032 Fara In Sabina RI, Italia","%_wpgmp_location_city%":"Fara in Sabina","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.211481603579536","%_wpgmp_metabox_longitude%":"12.728355068786623","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"19\";i:3;s:2:\"20\";i:4;s:2:\"24\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"11\";}","%_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","%_yoast_wpseo_focuskw%":"Punto Panoramico Fara Sabina","%_yoast_wpseo_metadesc%":"Immerso nel cuore della Sabina, il Belvedere di Fara Sabina \u00e8 uno dei luoghi pi\u00f9 incantevoli e affascinanti dell'Italia centrale. Questo punto panoramico offre una vista mozzafiato che abbraccia colline verdi, valli rigogliose e un orizzonte che sembra infinito.","%_yoast_wpseo_linkdex%":"67","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"13149","%_dp_original%":"12618","%_edit_lock%":"1720195622:6","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png"},"id":13137,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png","name":"Punti Panoramici \/ Viewpoints","id":"11","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Punto panoramico Toffia","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Punto panoramico Toffia\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/05\/02-1-Toffia-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\/toffia\/punto-panoramico-toffia\/\" class=\"fc-post-link\">Punto panoramico Toffia<\/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":"TOFFIA | Via Farnese (Km 14) # f10004, 02039 Toffia RI, Italia","location":{"lat":"42.20943369763802","city":"Toffia","state":"Lazio","country":"Italia","lng":"12.748620739950542","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/toffia\/punto-panoramico-toffia\/","zoom":18,"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]Toffia \u00e8 un borgo dalle origini antiche, con testimonianze che risalgono all'epoca romana. Il punto panoramico si trova in una<strong> posizione privilegiata<\/strong>, che vi permetter\u00e0 di abbracciare con lo sguardo tutto il fascino della Sabina.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"3897\" img_size=\"full\" alignment=\"center\" css_animation=\"none\"][\/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%2FTOFFIA%2B%257C%2BVia%2BFarnese%2B(Km%2B14)%2B%2523%2Bf10004%2F%4042.2088655%2C12.7481594%2C281m%2Fdata%3D!3m1!1e3!4m12!1m5!3m4!2zNDLCsDEzJzE3LjAiTiAxMsKwNDMnMDIuMyJF!8m2!3d42.2213889!4d12.7173056!3m5!1s0x132f0bb7fb41a72b%3A0x9a2407da0e916358!8m2!3d42.2093729!4d12.748629!16s%252Fg%252F11t7dxr7_7%3Fentry%3Dttu|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>Punto panoramico <strong>Toffia<\/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_1717159714009{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Farnese KM 14\r\n02039 <strong>Toffia <\/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_1716452714894{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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]<a href=\"https:\/\/geosabina.it\/destinations\/toffia\/\">Toffia<\/a> \u00e8 un borgo dalle origini antiche, con testimonianze che risalgono all'epoca romana. Il punto panoramico si trova in una<strong> posizione privilegiata<\/strong>, in coincidenza della fermata del bus, che vi permetter\u00e0 di abbracciare con lo sguardo tutto il fascino della Sabina.\r\n\r\n<strong>Dal punto panoramico di Toffia<\/strong>, lo sguardo si perde tra le colline verdi e rigogliose, costellate di uliveti e vigneti. In lontananza, si possono scorgere i Monti Sabini. Questo luogo \u00e8 perfetto per chi ama la natura e la tranquillit\u00e0, offrendo un angolo di paradiso dove rilassarsi e lasciarsi ispirare dalla bellezza del paesaggio.\r\n\r\nVisitare il punto panoramico di Toffia non significa solo ammirare un bel paesaggio, ma anche immergersi in un'esperienza autentica. Qui, la natura e la storia si fondono, creando un'atmosfera magica e senza tempo.\r\n\r\nVi invitiamo a <strong>scoprire questo angolo di pace e bellezza<\/strong>, dove ogni visitatore pu\u00f2 ritrovare una connessione profonda con la natura e con la propria anima[\/vc_column_text][vc_empty_space height=\"30px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"3\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"13008,13010,13012\"][vc_column_text]Le foto della gallery sono state realizzate in collaborazione con il\u00a0<a href=\"https:\/\/www.facebook.com\/groups\/45975827398\" target=\"_blank\" rel=\"noopener\">gruppo Facebook \u201cFoto della Sabina\u201d<\/a>\u00a0a cura di\u00a0<a href=\"https:\/\/www.facebook.com\/FabrizioMei72\/\" target=\"_blank\" rel=\"noopener\">Fabrizio Mei.<\/a>[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Punto panoramico Toffia","post_link":"https:\/\/geosabina.it\/toffia\/punto-panoramico-toffia\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Punto panoramico Toffia\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/05\/02-1-Toffia-1024x576-1-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1717159714009{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1716452714894{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\":301,\"to_translate\":{\"en\":301}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"TOFFIA | Via Farnese (Km 14) # f10004, 02039 Toffia RI, Italia","%_wpgmp_location_city%":"Toffia","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.20943369763802","%_wpgmp_metabox_longitude%":"12.748620739950542","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:4:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"11\";i:3;s:2:\"19\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"11\";}","%_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","%_yoast_wpseo_focuskw%":"Punto panoramico Toffia","%_yoast_wpseo_metadesc%":"Toffia \u00e8 un borgo dalle origini antiche. Il punto panoramico si trova in una posizione privilegiata, che vi permetter\u00e0 di abbracciare con lo sguardo tutto il fascino della Sabina.","%_yoast_wpseo_linkdex%":"72","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"13006","%_dp_original%":"12618","%_edit_lock%":"1722624132:6","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png"},"id":13004,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png","name":"Borghi e Centri Storici \/ Villages and Historical Centers","id":"2","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png","name":"Punti Panoramici \/ Viewpoints","id":"11","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Farfa","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Farfa\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/05\/01-1-farfa-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\/altri-comuni\/farfa\/\" class=\"fc-post-link\">Farfa<\/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 del Fontanone, 3, 02032 Fara in Sabina RI, Italia","location":{"lat":"42.22139585729148","city":"Fara in Sabina","state":"Lazio","country":"Italia","lng":"12.717220359910577","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/farfa\/","zoom":18,"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]Immerso nel cuore della Sabina si trova il pittoresco borgo di Farfa, un luogo dove storia, cultura e natura si fondono in un'esperienza unica. Farfa \u00e8 noto principalmente per la sua storica <strong>Abbazia<\/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 gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\"][vc_empty_space height=\"25px\"][\/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%2Fmaps.app.goo.gl%2FGFEcvgm4hw9ve5r99\" 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><strong>Farfa<\/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_1716460666317{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via del Fontanone, 3\r\n02032 <strong>Farfa <\/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_1716452714894{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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Immerso nel cuore della Sabina si trova il pittoresco borgo di Farfa, un luogo dove storia, cultura e natura si fondono in un'esperienza unica. Farfa \u00e8 noto principalmente per la sua storica <strong>Abbazia<\/strong>, un monastero benedettino che risale al VI secolo e che ha avuto un'influenza significativa sulla storia e la cultura della regione.\r\n\r\n<strong>L'Abbazia di Farfa<\/strong> \u00e8 il gioiello del borgo. Fondata nel VI secolo, \u00e8 stata uno dei centri religiosi e culturali <strong>pi\u00f9 potenti d'Italia<\/strong> durante il Medioevo. Per approfondire la sua storia vai alla scheda dedicata <a href=\"https:\/\/geosabina.it\/altri-comuni\/abbazia-di-farfa\/\"><strong>CLICCANDO QUI.<\/strong><\/a>\r\n\r\nPasseggiando per Farfa, si pu\u00f2 quasi sentire l'eco del passato. L'abbazia era un luogo di produzione <strong>intellettuale e artistica<\/strong>, e ancora oggi, le sue mura raccontano storie di secoli di spiritualit\u00e0 e sapere. Le visite guidate offrono approfondimenti affascinanti sulla storia e sull'architettura del monastero, permettendo di immergersi completamente nella sua ricca eredit\u00e0.\r\n<h4><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"30px\"][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=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"12653,12655,12657,12675\"][vc_empty_space height=\"35px\"][vc_column_text]<strong>Farfa<\/strong> \u00e8 situata in una regione nota per i suoi <strong>paesaggi<\/strong> collinari e le sue rigogliose campagne verdi. Il fiume Farfa, che scorre nelle vicinanze, contribuisce alla bellezza naturale del luogo, creando un ambiente ideale per <strong>escursioni e passeggiate nella natura<\/strong>. L'area \u00e8 ricca di biodiversit\u00e0, ospitando varie specie di flora e fauna che rendono ogni visita un'occasione per scoprire qualcosa di nuovo.\r\n\r\nLa comunit\u00e0 di Farfa \u00e8 piccola ma accogliente, profondamente legata alle tradizioni storiche e religiose della regione. Durante l'anno, il borgo e l'abbazia ospitano vari<strong> eventi culturali<\/strong>, concerti e manifestazioni che celebrano la storia e la tradizione del luogo. Inoltre, i visitatori possono <strong>degustare e acquistare prodotti locali<\/strong>, come<strong> l'olio d'oliva di alta qualit\u00e0<\/strong> per cui la Sabina \u00e8 famosa.\r\n<h4><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"35px\"][vc_row_inner][vc_column_inner css=\".vc_custom_1716459725229{margin-top: 4px !important;margin-bottom: 2px !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;}\"][vc_text_separator title=\"PUNTO PANORAMICO\" i_icon_fontawesome=\"fas fa-camera-retro\" 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\" css=\".vc_custom_1716457835214{margin-top: -18px !important;}\"][vc_empty_space height=\"20px\"][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=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"12628,12624,12626,13051\"][vc_column_text]\r\n<h4><b>Panorami di Farfa<\/b><\/h4>\r\n<div class=\"wpb_text_column wpb_content_element \">\r\n<div class=\"wpb_wrapper\">\r\n\r\nTramite il punto indicato sulla mappa, \u00e8 possibile scattare meravigliose <strong>foto<\/strong> e godere dei <strong>bellissimi panorami<\/strong> che questo posto ha da offrire. Farfa \u00e8 circondata da dolci colline che si estendono a perdita d'occhio, coperte da una rigogliosa vegetazione che varia con le stagioni, offrendo una tavolozza di <strong>colori unica.<\/strong>\r\nLe foto della gallery sono state realizzate in collaborazione con il <a href=\"https:\/\/www.facebook.com\/groups\/45975827398\" target=\"_blank\" rel=\"noopener\">gruppo Facebook \"Foto della Sabina\"<\/a> a cura di <a href=\"https:\/\/www.facebook.com\/FabrizioMei72\/\" target=\"_blank\" rel=\"noopener\">Fabrizio Mei.<\/a>\r\n\r\n<\/div>\r\n<\/div>\r\n[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"Farfa","post_link":"https:\/\/geosabina.it\/altri-comuni\/farfa\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Farfa\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/05\/01-1-farfa-1024x576-1-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1716460666317{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1716452714894{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1716459725229{margin-top: 4px !important;margin-bottom: 2px !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;}.vc_custom_1716457835214{margin-top: -18px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":470,\"to_translate\":{\"en\":470}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via del Fontanone, 3, 02032 Fara in Sabina RI, Italia","%_wpgmp_location_city%":"Fara in Sabina","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.22139585729148","%_wpgmp_metabox_longitude%":"12.717220359910577","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"19\";i:3;s:2:\"20\";i:4;s:2:\"24\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"11\";}","%_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","%_yoast_wpseo_focuskw%":"Farfa","%_yoast_wpseo_metadesc%":"Immerso nel cuore della Sabina si trova il pittoresco borgo di Farfa, un luogo dove storia, cultura e natura si fondono in un'esperienza unica. Farfa \u00e8 noto principalmente per la sua storica Abbazia, un monastero benedettino che risale al VI secolo e che ha avuto un'influenza significativa sulla storia e la cultura della regione.","%_yoast_wpseo_linkdex%":"75","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"12622","%_dp_original%":"6982","%_edit_lock%":"1725377288:4","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png"},"id":12618,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png","name":"Borghi e Centri Storici \/ Villages and Historical Centers","id":"2","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png","name":"Punti Panoramici \/ Viewpoints","id":"11","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"ITINERARIO | I laghi della Sabina","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 | I laghi della Sabina\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/10\/itinerari-artistici-1-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\/itinerari\/itinerario-laghi-della-sabina\/\" class=\"fc-post-link\">ITINERARIO | I laghi della Sabina<\/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":"Lago del Salto, Provincia di Rieti, Italia","location":{"lat":"42.2603567","state":"Lazio","country":"Italia","lng":"13.0601805","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/itinerari\/itinerario-laghi-della-sabina\/","zoom":18,"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]Per gli appassionati dei laghi, ecco l'occasione per un entusiasmante lungo weekend immersi nella natura della Sabina, una terra generosamente ricca di acque che vanta ben otto laghi, di cui quattro balneabili.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row][vc_column][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2><strong>Laghi<\/strong> della Sabina<\/h2>\r\n[\/vc_column_text][vc_column_text css=\".vc_custom_1713540278221{margin-top: -20px !important;}\"]\r\n<h5>Itinerario Naturalistico<\/h5>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column][\/vc_row][vc_row gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/4\" css=\".vc_custom_1696326100559{border-top-width: 10px !important;border-right-width: 10px !important;border-bottom-width: 10px !important;border-left-width: 10px !important;padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;background-color: #f4f4f4 !important;border-left-color: #ffffff !important;border-left-style: solid !important;border-right-color: #ffffff !important;border-right-style: solid !important;border-top-color: #ffffff !important;border-top-style: solid !important;border-bottom-color: #ffffff !important;border-bottom-style: solid !important;}\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-sm vc_hidden-xs\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_single_image image=\"9189\" 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 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_1713540599380{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 in Auto e 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_1714472833839{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;\">4<\/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_1714468387895{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;\">4 Giorni<\/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_1714472846727{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;\">Medio<\/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_1713540676198{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;\">Lago del Salto<\/span><\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"3\/4\"][vc_column_text]Per gli appassionati dei laghi, ecco l'occasione per un entusiasmante lungo weekend immersi nella natura della Sabina, una terra generosamente ricca di acque che vanta ben otto laghi, di cui quattro balneabili.\r\n\r\nTra questi, un lago si nasconde su un altipiano al confine con l\u2019Abruzzo, mentre altri due si trovano all'interno della Riserva Naturale dei Laghi Lungo e Ripasottile. Non dimentichiamo l'incantevole lago nell\u2019Alta Valle del Velino.\r\n\r\nIl nostro itinerario ci porter\u00e0 attraverso la Valle del Salto e la Valle del Turano, per poi spostarci verso nord, in direzione di Rieti. Qui avremo l'opportunit\u00e0 di immergerci nelle acque cristalline del grazioso laghetto di Ventina e del Lago di Piediluco, entrambi resti dell'antico lacus Velinus, prosciugato dai Romani durante le opere di bonifica intraprese da Marco Curio Dentato nel 290 a.C.[\/vc_column_text][vc_empty_space height=\"30px\"][vc_tta_tour shape=\"square\" color=\"green\" spacing=\"20\" gap=\"15\" active_section=\"1\" no_fill_content_area=\"true\" title=\"Itinerario\"][vc_tta_section title=\"TAPPA 1\" tab_id=\"tappa1\"][vc_column_text]Partiamo da Roma per avventurarci nel suggestivo paesaggio del<strong> Lago del Salto<\/strong>, raggiungibile attraverso la strada A24, con uscita Valle del Salto. Seguendo la SR578 Salto Cicolana, ci immergiamo gradualmente nell'atmosfera rilassante che ci aspetta. Attraversiamo Fiamignano e poi scendiamo verso il pittoresco borgo di Sant\u2019Ippolito, abbracciato dalle rive del lago. Questo bacino, nato dall'intervento umano, ci accoglie con la sua invitante atmosfera <strong>balneabile.<\/strong>\r\n\r\nLe sue <strong>spiagge<\/strong>, alcune delle quali dotate di comodi servizi come noleggio di sdraio e ombrelloni, offrono la possibilit\u00e0 di godersi il sole o di avventurarsi in una tranquilla canoa per esplorare il lago da una prospettiva diversa. Tra le opzioni, la Spiaggia della Diga del Salto, che include anche un'area per il campeggio, e la Spiaggia Altobelli a Borgo San Pietro, affacciata in modo pittoresco sulle acque del lago.\r\n\r\nAnche per chi preferisce<strong> nuotare<\/strong>, l'esperienza \u00e8 unica: le acque del lago offrono uno spettacolo mozzafiato, circondate come sono dalla rigogliosa <strong>natura che abbraccia le sue sponde.<\/strong> Le maestose montagne del Nuria e Navegna fungono da cornice, arricchite da boschi di querce e castagni che accentuano la bellezza del paesaggio.\r\n\r\nNel pomeriggio, concediamoci una passeggiata tra le viuzze di due borghi affacciati sul lago: Petrella Salto e Fiamignano. Qui, troviamo un accogliente albergo dove trascorrere la notte. Prima di chiudere gli occhi, assaporiamo le delizie culinarie locali in uno dei ristoranti panoramici che si affacciano sul lago, godendo di una vista incantevole.\r\n\r\nPer chi desidera esplorare ulteriormente la zona, l'altopiano del Rascino, nei dintorni di Fiamignano, offre uno spettacolo naturale altrettanto affascinante: il lago di Rascino, incastonato tra le maestose montagne dell'Appennino Abruzzese, una vera delizia per gli amanti della pesca, grazie alla sua popolazione di lucci.[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 1\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FLago%2Bdel%2BSalto%2F%4042.257643%2C13.0552058%2C14z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132fba1b7c281aa1%3A0x4d7a38db73ac5c12!8m2!3d42.2603567!4d13.0601805!16s%252Fm%252F05pb214%3Fentry%3Dttu|target:_blank\"][\/vc_column_inner][\/vc_row_inner][\/vc_tta_section][vc_tta_section title=\"TAPPA 2\" tab_id=\"1696344647611-95d2120a-8962\"][vc_column_text]Alla stessa latitudine della suggestiva <strong>Valle del Salto<\/strong> si estende la <strong>Valle del Turano<\/strong>, separata da essa dal maestoso <strong>Monte Navegna<\/strong>. Il percorso per raggiungerla \u00e8 avvincente: ci addentriamo lungo la SP67 per circa 25 chilometri, attraversando una galleria di ben 9 chilometri, fino ad arrivare al magnifico<strong> Lago del Turano<\/strong>. Qui, accanto alle sue acque tranquille, si staglia l'antico borgo medievale di Castel di Tora, che si specchia nel bacino artificiale, e il pittoresco paese di Colle di Tora, arroccato su una stretta lingua di terra che si protende nel lago.\r\n\r\nLe tonalit\u00e0 pi\u00f9 delicate e rilassanti delle acque e del paesaggio circostante, nonostante la presenza delle montagne, donano un'atmosfera di pace e serenit\u00e0. Nella zona, si trovano incantevoli hotel e B&amp;B dove poter trascorrere la notte, dopo una giornata all'insegna del divertimento sulle rive del lago e di esplorazione della cultura enogastronomica locale.\r\n\r\nLa Valle del Turano \u00e8 rinomata non solo per la sua straordinaria variet\u00e0 di prodotti della terra e delle montagne, tra cui spiccano i prelibati tartufi, ma anche per le specialit\u00e0 ittiche del lago. Tra queste, le \"rosciole\", pesci tipici del lago che vengono celebrati ogni luglio durante una suggestiva festa tradizionale. Da non perdere le paste fresche tirate a mano e l'olio extravergine di oliva della Sabina DOP, testimone della ricchezza enogastronomica della zona.\r\n\r\nSul Lago del Turano, inoltre, \u00e8 possibile praticare una variet\u00e0 di sport acquatici, come canoa e pesca, oppure concedersi una rinfrescante nuotata per immergersi appieno nella bellezza della natura circostante.[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 2\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FLago%2Bdel%2BTurano%2F%4042.2005938%2C12.9312213%2C13z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132fa4a0a40d8961%3A0x7f8c5e07889367e2!8m2!3d42.2181926!4d12.9521888!16s%252Fm%252F05p5n1m%3Fentry%3Dttu|target:_blank\"][\/vc_column_inner][\/vc_row_inner][\/vc_tta_section][vc_tta_section title=\"TAPPA 3\" tab_id=\"1696344891500-aa2c7edd-9eb6\"][vc_column_text]Il terzo giorno della nostra avventura ci vedr\u00e0 remare controcorrente lungo il fiume Turano <strong>fino a Rieti<\/strong>, per esplorare i suggestivi laghi della Valle Santa. Dopo aver attraversato Rieti, ci immetteremo sulla via Salaria per raggiungere il pittoresco <strong>lago di Paterno<\/strong>, incastonato nel borgo di<strong> Castel Sant\u2019Angelo<\/strong> all'inizio dell'Alta Valle del Velino, ad est di Rieti. Questo luogo non solo \u00e8 un incanto naturale, ma possiede anche un'importanza storica considerevole, poich\u00e9 si dice che proprio qui i Romani stabilirono il centro geografico d'Italia.\r\n\r\nDopo una breve esplorazione, riprenderemo la nostra strada in direzione della <strong>Riserva Naturale dei Laghi Lungo e Ripasottile<\/strong>, un'oasi di pace immersa nella natura della piana reatina. Anche se i laghi non offrono spiagge balneabili, vale assolutamente la pena avventurarsi lungo i sentieri circostanti per godere degli spettacolari panorami delle acque alimentate dal fiume Velino. Gli amanti dell'osservazione degli uccelli troveranno inoltre un paradiso qui, grazie alla ricca variet\u00e0 di specie presenti.\r\n\r\nPrima di proseguire, ci concederemo una pausa pranzo in uno dei deliziosi agriturismi o ristoranti della zona, gustando le prelibatezze locali come trote e gamberi di fiume freschissimi. Poi, riprenderemo il nostro viaggio verso il <strong>Lago di Ventina<\/strong>, situato nel comune di Colli sul Velino. Questo piccolo gioiello ellittico, circondato da colline verdi, si trova nel cuore della <strong>Valle Santa<\/strong>, a pochi passi dal suggestivo Santuario del Presepe di Greccio.\r\n\r\nQui, ci concederemo un momento di puro relax sulla graziosa spiaggetta all'ombra di una maestosa quercia, magari dopo una rinfrescante nuotata nelle acque cristalline o un'emozionante sessione di carpfishing per gli appassionati. Infine, ci avventureremo fino a Labro, al confine con l'Umbria, dove trascorreremo la notte in uno dei pittoreschi paesi della <strong>Conca Reatina.<\/strong>\r\n\r\nIl punto pi\u00f9 alto di Labro ci regaler\u00e0 una vista mozzafiato sul Lago di Piediluco, che sar\u00e0 la nostra ultima tappa prima di concludere questo indimenticabile viaggio.[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 3\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FLago%2Bdi%2BPaterno%2F%4042.382396%2C13.0114765%2C17z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132fb242c5d1fd93%3A0x3af5a373b9320aad!8m2!3d42.3822584!4d13.0137323!16s%252Fm%252F0bmhngq%3Fentry%3Dttu|target:_blank\"][\/vc_column_inner][\/vc_row_inner][\/vc_tta_section][vc_tta_section title=\"TAPPA 4\" tab_id=\"1714467656393-d43dd52b-553b\"][vc_column_text]Per l'ultimo giorno della nostra avventura tra <strong>i laghi della Sabina<\/strong>, ci immergiamo nella bellezza delle sponde del<strong> Lago di Piediluco<\/strong>. Abbandoniamo il Lazio e ci dirigiamo verso l'Umbria, trovandoci nella provincia di Terni nonostante la vicinanza con Rieti. Questo lago, insieme agli altri cinque della piana reatina, \u00e8 il residuo pi\u00f9 esteso dell'antico <strong>lacus Velinus<\/strong>, che un tempo occupava l'intera valle prima della bonifica romana che trasform\u00f2 queste terre in fertili campi agricoli.\r\n\r\nLe sue rive offrono paesaggi incantevoli, con una natura imponente che circonda il bacino naturale. Vicino al grazioso villaggio di Piediluco, troviamo stabilimenti attrezzati per una giornata di relax completo o per praticare sport acquatici come il canottaggio (qui ha sede il Circolo Canottieri di Piediluco), la pesca o, grazie ai divertenti <strong>eco-battelli<\/strong>, possiamo optare per un giro del lago, particolarmente suggestivo al tramonto. Dopo una rigenerante nuotata, ci concediamo una passeggiata tra le pittoresche stradine del paese, che vanta una chiesa trecentesca dedicata al passaggio di <strong>San Francesco d\u2019Assisi.<\/strong>\r\n\r\nPer la cena, possiamo deliziarci in una delle numerose trattorie tradizionali della zona, dove potremo gustare una vasta selezione di specialit\u00e0 a base di pesce d'acqua dolce.[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 4\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.it%2Fmaps%2Fplace%2FLago%2Bdi%2BPaterno%2F%4042.382396%2C13.0114765%2C17z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132fb242c5d1fd93%3A0x3af5a373b9320aad!8m2!3d42.3822584!4d13.0137323!16s%252Fm%252F0bmhngq%3Fentry%3Dttu|target:_blank\"][\/vc_column_inner][\/vc_row_inner][\/vc_tta_section][\/vc_tta_tour][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][\/vc_column][\/vc_row]","post_title":"ITINERARIO | I laghi della Sabina","post_link":"https:\/\/geosabina.it\/itinerari\/itinerario-laghi-della-sabina\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"ITINERARIO | I laghi della Sabina\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/10\/itinerari-artistici-1-300x191.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1713540278221{margin-top: -20px !important;}.vc_custom_1696326100559{border-top-width: 10px !important;border-right-width: 10px !important;border-bottom-width: 10px !important;border-left-width: 10px !important;padding-top: 10px !important;padding-right: 10px !important;padding-bottom: 10px !important;padding-left: 10px !important;background-color: #f4f4f4 !important;border-left-color: #ffffff !important;border-left-style: solid !important;border-right-color: #ffffff !important;border-right-style: solid !important;border-top-color: #ffffff !important;border-top-style: solid !important;border-bottom-color: #ffffff !important;border-bottom-style: solid !important;}.vc_custom_1696325961236{padding: 20px !important;}.vc_custom_1713540599380{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1714472833839{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1714468387895{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1714472846727{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1713540676198{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":1330,\"to_translate\":{\"en\":1330}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Lago del Salto, Provincia di Rieti, Italia","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2603567","%_wpgmp_metabox_longitude%":"13.0601805","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:4:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"16\";i:3;s:2:\"17\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:2:\"22\";}","%_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","%_wpb_post_custom_css%":".itinerari {\r\n    width:100%;\r\n    max-width:160px;\r\n    text-align:center;\r\n    margin:auto;\r\n}","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"8","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"I Laghi della Sabina","%_yoast_wpseo_metadesc%":"Itinerario turistico che parte da Magliano Sabina e passa per Tarano e Vescovio creato per poter visitare da musei, bellezze naturali e santuari storici della sabina.","%_yoast_wpseo_linkdex%":"64","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Itinerario Naturalistico","%_thumbnail_id%":"9160","%_dp_original%":"6908","%_edit_lock%":"1714475901:6","%_edit_last%":"6","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-artistici_sito.png"},"id":12148,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-artistici_sito.png","name":"Itinerari Artistici \/ Artistic Itineraries","id":"22","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Il Castello di Nerola","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Il Castello di Nerola\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/01\/castello-di-nerola-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\/altri-comuni\/il-castello-di-nerola\/\" class=\"fc-post-link\">Il Castello di Nerola<\/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 Bigelli Aldo, 54, 00017 Nerola RM, Italia","location":{"lat":"42.1626608","city":"Nerola","state":"Lazio","country":"Italia","lng":"12.7870589","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/il-castello-di-nerola\/","zoom":18,"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'imponente Castello Orsini a Nerola, oggi una raffinata struttura alberghiera a 5 stelle e sede di eventi, si presenta come un'incantevole cornice dai panorami mozzafiato. A\u00a0soli 40 chilometri dal cuore di Roma, la \"Citt\u00e0 Eterna\", il Castello Orsini racconta una storia millenaria di potere, intrighi, battaglie ed amori[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/3\"][vc_row_inner][vc_column_inner][vc_empty_space height=\"40px\"][vc_single_image image=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/comuni-in-rete\/\"][\/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%2FCastello%2BOrsini%2BHotel%2C%2BVia%2BBigelli%2BAldo%2C%2BNerola%2BRM%2F%4042.1626544%2C12.7458674%2C13z%2Fdata%3D!4m8!4m7!1m0!1m5!1m1!1s0x132f0abeb926fdb7%3A0x7dd6bb218d929cf6!2m2!1d12.7869219!2d42.162506%3Fhl%3Dit%26entry%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<h1>Il Castello di <strong>Nerola<\/strong><\/h1>\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_1705919815492{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Bigelli Aldo, 54\r\n00017 Nerola, RM[\/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\"][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_1705920242164{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 css=\".vc_custom_1705920286597{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\" el_id=\"bottoneindicazioni\" 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]L'imponente Castello Orsini a Nerola, oggi una raffinata struttura alberghiera a 5 stelle e sede di eventi, si presenta come un'incantevole cornice dai panorami mozzafiato.\r\n\r\nDominando la fertile campagna della Sabina, a soli 40 chilometri dal cuore di Roma, la \"Citt\u00e0 Eterna\", il Castello Orsini racconta una storia millenaria di potere, intrighi, battaglie ed amori, affascinando con il suo charme senza tempo che evoca nobilt\u00e0, bellezza ed eccellenza.\r\n\r\nLa sua costruzione ebbe inizio nel lontano 1070, intorno alla vecchia rocca dei Prefetti di Vico, per volere di Napoleone Orsini, trovando compimento nel 1085 grazie al figlio Gentil Virginio Orsini. Nel corso dei secoli, il castello sub\u00ec diverse trasformazioni, compreso il progetto rinascimentale di Francesco di Giorgio Martini.\r\n\r\nNel 1092, Papa Urbano II acquist\u00f2 il castello, segnando un momento di tensione con gli Orsini. Nei secoli successivi, divenne residenza ufficiale di vari Papi, tra cui Pasquale II, Gelasio II, Callisto II, Onorio II e Innocenzo II. Tuttavia, con l'avvio delle crociate, il castello fu abbandonato come sede papale.\r\n\r\nDopo il periodo delle crociate, il Castello ritorn\u00f2 nelle mani degli Orsini, che continuarono ad impreziosirlo e ampliarlo. Nel tardo Cinquecento, Galileo Galilei fu ospite per un mese, mentre nel 1591 papa Gregorio XIV trov\u00f2 rifugio qui durante un'epidemia di peste a Roma.\r\n\r\nNel 1696, gli Orsini cedettero il castello agli Odescalchi, un'antica famiglia originaria di Como. Nel 1689, alla morte di Innocenzo XI, Guglielmo III d'Inghilterra lo acquist\u00f2 e, successivamente, Anna d'Inghilterra ne eredit\u00f2 la propriet\u00e0. Durante questo periodo, il castello ospit\u00f2 personalit\u00e0 come Carlo Fontana e Alessandro Marchetti. Successivamente, fu acquisito da John Lethbridge, noto per aver ideato la prima tuta da palombaro.\r\n\r\nNel 1730, il castello ritorn\u00f2 alla Chiesa come residenza papale e fu successivamente propriet\u00e0 di vari Papi, tra cui Clemente XII, Benedetto XIV, Clemente XIII, Clemente XIV e Pio VI. Durante questo periodo, Napoleone Bonaparte discusse qui il suo prossimo matrimonio. Tuttavia, dopo un secolo di abbandono, fu testimone nel 1867 della Campagna dell'Agro Romano per la liberazione di Roma, con l'occupazione da parte di volontari garibaldini guidati da Menotti Garibaldi.\r\n\r\nSuccessivamente, nel 1930, il calciatore Giuseppe Meazza acquist\u00f2 il castello e ne cur\u00f2 la ristrutturazione e l'estensione del giardino. Nel 1934, ospit\u00f2 una festa in onore della vittoria dell'Italia nella Coppa del Mondo. Con l'avvento del fascismo, il castello pass\u00f2 alla societ\u00e0 C.A.D.L. su decisione di Benito Mussolini, che vi fece creare un teatro.\r\n\r\nDopo essere stato ceduto al Marchese Ferrari-Frey, il castello ritorn\u00f2 alla societ\u00e0 C.A.D.L. solo nel 1967, e dal 1994 \u00e8 diventato un prestigioso hotel.[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Il Castello di Nerola","post_link":"https:\/\/geosabina.it\/altri-comuni\/il-castello-di-nerola\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Il Castello di Nerola\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/01\/castello-di-nerola-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1705919815492{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_1705920242164{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1705920286597{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\":567,\"to_translate\":{\"en\":567}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Bigelli Aldo, 54, 00017 Nerola RM, Italia","%_wpgmp_location_city%":"Nerola","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.1626608","%_wpgmp_metabox_longitude%":"12.7870589","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"18\";i:3;s:2:\"20\";i:4;s:2:\"27\";}","%_wpgmp_metabox_marker_id%":"a:3:{i:0;s:1:\"5\";i:1;s:2:\"13\";i:2;s:2:\"23\";}","%_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","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_wordproof_timestamp%":"","%_dp_original%":"6826","%_edit_lock%":"1720194184:6","%_edit_last%":"4","%_thumbnail_id%":"11081","%_yoast_wpseo_focuskw%":"Il Castello di Nerola","%_yoast_wpseo_metadesc%":"L'imponente Castello di Nerola, oggi una raffinata struttura alberghiera a 5 stelle e sede di eventi, si presenta come un'incantevole cornice dai panorami mozzafiato.","%_yoast_wpseo_linkdex%":"71","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dimore-storiche_sito.png"},"id":11077,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/dimore-storiche_sito.png","name":"Dimore Storiche \/ Historic Residences","id":"5","type":"category","extension_fields":{"cat_order":"1"}},{"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"}},{"icon":"https:\/\/geosabina.it\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Lago di Ripasottile e Lago Lungo","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lago di Ripasottile e Lago Lungo\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/05\/lago_lungo-e-ripasottile-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\/altri-comuni\/lago-di-ripasottile-e-lago-lungo\/\" class=\"fc-post-link\">Lago di Ripasottile e Lago Lungo<\/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":"Lago di Ripasottile, 02100 Rieti RI, Italia","location":{"lat":"42.4746984","city":"Rieti","state":"Lazio","country":"Italia","lng":"12.8155381","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/lago-di-ripasottile-e-lago-lungo\/","zoom":18,"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 piana di Rieti si distingue come uno dei rari scenari nel Lazio dove l'acqua sembra danzare in armonia con il cielo, Incorniciata tra gli spazi generosi dei Monti Sabini e dei Monti Reatini.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/intorno-a-te\/punti-da-non-perdere\/\"][vc_empty_space height=\"25px\"][\/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%2FLago%2Bdi%2BRipasottile%2C%2B02100%2BRieti%2BRI%2F%4042.4744264%2C12.8143719%2C15.25z%2Fdata%3D!4m8!4m7!1m0!1m5!1m1!1s0x132e555d85e2443b%3A0xaf1d76093f8e6595!2m2!1d12.8155381!2d42.4746984%3Fhl%3Dit%26entry%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>Lago di <strong>Ripasottile<\/strong> e Lago <strong>Lungo<\/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_1705577126516{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]\r\n<div class=\"gm-style-iw gm-style-iw-c\" tabindex=\"-1\" role=\"dialog\">\r\n<div class=\"gm-style-iw-d\">\r\n<div class=\"gm-iw\">Lago di Ripasottile<\/div>\r\n<div class=\"gm-iw\">02100 Rieti, RI<\/div>\r\n<\/div>\r\n<\/div>\r\n[\/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_1702570858261{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]sempre aperto\r\n\r\n[\/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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]La piana di Rieti si distingue come uno dei rari scenari nel Lazio dove l'acqua sembra danzare in armonia con il cielo. Incorniciata tra gli spazi generosi dei Monti Sabini e dei Monti Reatini, costituisce un nodo vitale di corsi d'acqua, sia superficiali che sotterranei, donando una risorsa incommensurabile, gratuita e inesauribile. Nelle vicinanze di Rieti, i fiumi Salto e Turano si fondono nel Velino, mentre numerosissime sorgenti alle radici dei monti contribuiscono a questo affascinante ecosistema. In epoche passate, la conca ospitava il maestoso \"Lacus Velinus\", prosciugato quasi completamente dai Romani tramite la cascata delle Marmore, per garantirsi ampie terre coltivabili. Tuttavia, due piccoli laghi sopravvivono come testimonianza di questa epoca, divenuti oggi importanti santuari umidi e rifugi per numerose specie di uccelli acquatici. Protetti da una Riserva Naturale Regionale, esploreremo entrambi i laghi, prima il suggestivo Lago di Ripasottile e poi il tranquillo Lago Lungo. Percorreremo le loro silenziose rive tra canneti e boschi umidi, o ci soffermeremo nei vari capanni per osservare da vicino la ricca avifauna. Ma non ci limiteremo a questo: avremo l'opportunit\u00e0 di apprezzare la luminosit\u00e0 unica della piana, respirare il profumo del suo vento, ascoltare i suoni circostanti e contemplare la cerchia immobile e discreta dei monti come osservatori silenziosi. In sintesi, una giornata indimenticabile alla scoperta di luoghi remoti e, proprio per questo, carichi di emozione e bellezza.[\/vc_column_text][vc_empty_space height=\"25px\"][\/vc_column][\/vc_row]","post_title":"Lago di Ripasottile e Lago Lungo","post_link":"https:\/\/geosabina.it\/altri-comuni\/lago-di-ripasottile-e-lago-lungo\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lago di Ripasottile e Lago Lungo\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/05\/lago_lungo-e-ripasottile-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1705577126516{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1702570858261{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;}","%_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%":"Lago di Ripasottile, 02100 Rieti RI, Italia","%_wpgmp_location_city%":"Rieti","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.4746984","%_wpgmp_metabox_longitude%":"12.8155381","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"18\";i:3;s:2:\"20\";i:4;s:2:\"21\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"23\";}","%_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","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Lago di Ripasottile e Lago Lungo","%_yoast_wpseo_metadesc%":"La piana di Rieti si distingue come uno dei rari scenari nel Lazio dove l'acqua sembra danzare in armonia con il cielo. Incorniciata tra gli spazi generosi dei Monti Sabini e dei Monti Reatini","%_yoast_wpseo_linkdex%":"65","%_oembed_1eb08ede5fcfd3a110467a2c63748b96%":"{{unknown}}","%_oembed_36cedc6b2f240b2eb3df757c5e017720%":"{{unknown}}","%_dp_original%":"10777","%_edit_lock%":"1720195258:6","%_edit_last%":"4","%_thumbnail_id%":"12470","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/bellezze-naturali_sito.png"},"id":10942,"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\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Il Borgo di Pian de&#8217; Valli","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Il Borgo di Pian de&#8217; Valli\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/12\/borgo-terminillo-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\/altri-comuni\/il-borgo-di-pian-de-valli\/\" class=\"fc-post-link\">Il Borgo di Pian de&#8217; Valli<\/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":"02100 Pian De' Valli RI, Italia","location":{"lat":"42.4529179","city":"Rieti","state":"Lazio","country":"Italia","lng":"12.985296","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/il-borgo-di-pian-de-valli\/","zoom":18,"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 suggestivo borgo di Pian de' Valli, incorniciato nel comune di Rieti e adagiato ai piedi del maestoso Terminillo a quota 1620 metri sul livello del mare, emerge come una delle gemme pi\u00f9 affascinanti dell'Appennino Centrale.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/intorno-a-te\/punti-da-non-perdere\/\"][vc_empty_space height=\"25px\"][\/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%2FPian%2Bde'%2BValli%2B-%2BTerminillo%2F%4042.454178%2C12.9729666%2C16z%2Fdata%3D!4m10!1m2!2m1!1s%2BPAESE%2BPian%2Bde%2BValli!3m6!1s0x132e5297fd9174df%3A0x5103242610b44834!8m2!3d42.456741!4d12.9776204!15sChNQQUVTRSBQaWFuIGRlIFZhbGxpWhUiE3BhZXNlIHBpYW4gZGUgdmFsbGmSARJ0b3VyaXN0X2F0dHJhY3Rpb26aASRDaGREU1VoTk1HOW5TMFZKUTBGblNVTmxjM050VUhKM1JSQULgAQA!16s%252Fg%252F1ywtx73j8%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>Il Borgo di <strong>Pian de' Valli<\/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_1702983724205{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Pian De' Valli, Terminillo\r\n02100, Rieti[\/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_1702570858261{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]sempre aperto\r\n\r\n[\/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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Il suggestivo borgo di Pian de' Valli, incorniciato nel comune di Rieti e adagiato ai piedi del maestoso Terminillo a quota 1620 metri sul livello del mare, emerge come una delle gemme pi\u00f9 affascinanti dell'Appennino Centrale.\r\n\r\nQuest'incantevole localit\u00e0 accoglie il maggior numero di strutture ricettive e commerciali dedite all'esplorazione del monte Terminillo, con la stazione di partenza degli impianti di risalita a breve distanza dal cuore del centro abitato.\r\n\r\nUn punto di riferimento di grande rilevanza \u00e8 la celebre funivia del Terminillo, ancor oggi operativa durante le stagioni invernali ed estive, consolidandosi nel corso dei decenni come simbolo storico di Pian de' Valli. Numerose attivit\u00e0, tra cui accoglienti bar, ristoranti, alberghi e negozi, soddisfano appieno le esigenze degli abitanti del luogo e dei visitatori.\r\n\r\nTuttavia, Pian de' Valli \u00e8 molto pi\u00f9 di un semplice crocevia. Numerosi edifici, eretti sin dalla sua fondazione negli anni '30 durante il periodo fascista e successivamente nel fervore degli anni '70\/'80, vantano strutture architettoniche all'avanguardia, divenendo oggetto di recensioni nei libri di storia e nei manuali di architettura.\r\n\r\nTra gli esempi tangibili si annoverano la suggestiva Chiesa di San Francesco, le stazioni di partenza e arrivo della Funivia, e i caratteristici residence come il Pian de' Valli, con la sua affascinante struttura a \"L\", il Tre Faggi, con le sue \"palafitte in cemento armato\", o il singolare \"Panettone\" con la sua forma distintiva.\r\n\r\nAl sorgere del sole, si pu\u00f2 iniziare la giornata con una deliziosa colazione presso i vari bar e ristori, proseguire con un'avventura tra i sentieri per il trekking estivo o immergersi in una divertente sciata invernale con gli amici tra le maestose faggete. \u00c8 possibile rigenerarsi con uno spuntino, rilassarsi al sole nei verdi prati o concedersi una lettura del giornale. Poi, magari, un the o una cioccolata calda, una sessione di allenamento in palestra o un momento di relax in una spa. La giornata pu\u00f2 concludersi con la degustazione di piatti tipici presso uno dei ristoranti locali, seguita da un meritato riposo in uno degli accoglienti alberghi di Pian de' Valli.\r\n\r\nIn sintesi, Pian de' Valli si configura come solo uno dei gioielli che punteggiano il territorio del Terminillo, offrendo un rifugio ideale per le vacanze, lontano dal caos cittadino, e regalando l'opportunit\u00e0 di immergersi completamente nella bellezza della natura circostante.\r\n\r\nInsomma, le opzioni per trascorrere il tempo non mancano affatto.[\/vc_column_text][vc_empty_space height=\"25px\"][\/vc_column][\/vc_row]","post_title":"Il Borgo di Pian de&#8217; Valli","post_link":"https:\/\/geosabina.it\/altri-comuni\/il-borgo-di-pian-de-valli\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Il Borgo di Pian de&#8217; Valli\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/12\/borgo-terminillo-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1702983724205{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1702570858261{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;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":536,\"to_translate\":{\"en\":536}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"02100 Pian De' Valli RI, Italia","%_wpgmp_location_city%":"Rieti","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.4529179","%_wpgmp_metabox_longitude%":"12.985296","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"18\";i:3;s:2:\"20\";i:4;s:2:\"25\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"2\";i:1;s:2:\"23\";}","%_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","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Il Borgo di Pian de' Valli","%_yoast_wpseo_metadesc%":"Il suggestivo borgo di Pian de' Valli, incorniciato nel comune di Rieti e adagiato ai piedi del maestoso Terminillo a quota 1620 metri sul livello del mare, emerge come una delle gemme pi\u00f9 affascinanti dell'Appennino Centrale.","%_yoast_wpseo_linkdex%":"72","%_oembed_1eb08ede5fcfd3a110467a2c63748b96%":"{{unknown}}","%_oembed_36cedc6b2f240b2eb3df757c5e017720%":"{{unknown}}","%_thumbnail_id%":"10844","%_dp_original%":"10777","%_edit_lock%":"1720201312:4","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png"},"id":10840,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png","name":"Borghi e Centri Storici \/ Villages and Historical Centers","id":"2","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https:\/\/geosabina.it\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Gole del Farfa","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Gole del Farfa\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/12\/gole-del-farfa-oriz-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\/altri-comuni\/gole-del-farfa\/\" class=\"fc-post-link\">Gole del Farfa<\/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":"02031 Castelnuovo di Farfa RI, Italia","location":{"lat":"42.2413919","city":"Castelnuovo di Farfa","state":"Lazio","country":"Italia","lng":"12.7515791","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/gole-del-farfa\/","zoom":18,"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 Monumento Naturale delle Gole del Farfa, esteso su una superficie di 35 ettari tra i comuni di Castelnuovo di Farfa e Mompeo nella provincia di Rieti, rappresenta un'incantevole porzione del territorio della Bassa Sabina, facente parte della Riserva Naturale Regionale Nazzano Tevere 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 gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/intorno-a-te\/punti-da-non-perdere\/\"][vc_empty_space height=\"25px\"][\/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%2Fdir%2F%2FGole%2Bdel%2BFarfa%2B-%2B%2Bingresso%2Bda%2BCastelnuovo%2F%4042.2413919%2C12.7515791%2C17z%2Fdata%3D!4m9!4m8!1m0!1m5!1m1!1s0x132f098c098a6377%3A0xaa34cda3fa031226!2m2!1d12.754154!2d42.2413919!3e0%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>Gole del <strong>Farfa<\/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_1716538157846{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]\r\n<div class=\"gm-style-iw gm-style-iw-c\" tabindex=\"-1\" role=\"dialog\">\r\n<div class=\"gm-style-iw-d\">\r\n<div class=\"gm-iw\">Mompeo<\/div>\r\n<div class=\"gm-iw\">02040, Rieti<\/div>\r\n<\/div>\r\n&nbsp;\r\n\r\n<\/div>\r\n[\/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_1702570858261{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]sempre aperto\r\n\r\n[\/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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Il Monumento Naturale delle Gole del Farfa, esteso su una superficie di 35 ettari tra i comuni di Castelnuovo di Farfa e Mompeo nella provincia di Rieti, rappresenta un'incantevole porzione del territorio della Bassa Sabina, facente parte della Riserva Naturale Regionale Nazzano Tevere Farfa.\r\n\r\nSituato a soli 50 chilometri da Roma, le Gole del Farfa costituiscono una destinazione ideale per un'escursione di un giorno dalla Capitale, offrendo un vero paradiso per gli amanti del trekking e della natura. Chiunque si avventuri lungo il percorso rimarr\u00e0 sorpreso dalla vegetazione lussureggiante e dalle acque cristalline che, nel corso dei secoli, hanno modellato incantevoli anse e canyon. Questo angolo di natura cos\u00ec unico, incontaminato e ricco di colori, \u00e8 una scoperta che, fino ad oggi, poteva essere riscontrata solo nella dolina carsica del Revotano nel comune di Roccantica. Qui, come nelle Gole del Farfa, gli alberi sono avvolti da lunghe barbe di muschi verdissimi, prosperando grazie alla vicinanza con l'acqua e l'umidit\u00e0.\r\n\r\nSeguendo il percorso lungo le Gole del Farfa, avrai l'opportunit\u00e0 di addentrarti in un bosco di lecci, cerri e carpini, con la presenza di pioppi e salici che hanno creato una vera e propria foresta a galleria.\r\n\r\nIl letto ciottoloso attraversato dal fiume Farfa contribuisce a mantenere particolarmente limpide le acque di questa porzione di fiume, che talvolta sembrano quasi assumere una tonalit\u00e0 bianca a causa della spumosit\u00e0 generata nei vortici e nelle cascatelle naturali lungo il percorso.[\/vc_column_text][vc_empty_space height=\"25px\"][vc_column_text]Anche durante i mesi estivi, l'acqua delle Gole del Farfa mantiene la sua freschezza e freddezza, senza scoraggiare coloro che scelgono di trascorrere i pomeriggi pi\u00f9 caldi lungo le sue rive. In questo periodo dell'anno, molti cercano rifugio sulla sponda del Farfa, immergendosi in un'oasi di frescura e tranquillit\u00e0. Il torrente Farfa \u00e8 celebre come luogo di balneazione in tutta la Sabina, e le sue acque trovano impiego anche per riempire le storiche Piscine di Farfa. Dal 1960, queste piscine sono diventate una destinazione estiva per i residenti della Sabina e non solo, offrendo un luogo ideale per rinfrescarsi e rilassarsi a bordo piscina.[\/vc_column_text][vc_empty_space height=\"25px\"][\/vc_column][\/vc_row]","post_title":"Gole del Farfa","post_link":"https:\/\/geosabina.it\/altri-comuni\/gole-del-farfa\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Gole del Farfa\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/12\/gole-del-farfa-oriz-1-300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1716538157846{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1702570858261{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;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":454,\"to_translate\":{\"en\":454}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"02031 Castelnuovo di Farfa RI, Italia","%_wpgmp_location_city%":"Castelnuovo di Farfa","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2413919","%_wpgmp_metabox_longitude%":"12.7515791","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"18\";i:3;s:2:\"20\";i:4;s:2:\"24\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"23\";}","%_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","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Gole del Farfa","%_yoast_wpseo_metadesc%":"Il Monumento Naturale delle Gole del Farfa, esteso su una superficie di 35 ettari tra i comuni di Castelnuovo di Farfa e Mompeo, rappresenta un'incantevole porzione del territorio della Bassa Sabina.","%_yoast_wpseo_linkdex%":"72","%_oembed_1eb08ede5fcfd3a110467a2c63748b96%":"{{unknown}}","%_oembed_36cedc6b2f240b2eb3df757c5e017720%":"{{unknown}}","%_thumbnail_id%":"10825","%_dp_original%":"10777","%_edit_lock%":"1720194141:6","%_edit_last%":"4","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/bellezze-naturali_sito.png"},"id":10821,"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\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Pozze del Diavolo","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pozze del Diavolo\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/06\/Pozze-del-Diavolo-2-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\/altri-comuni\/pozze-del-diavolo\/\" class=\"fc-post-link\">Pozze del Diavolo<\/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":"02040 Salisano RI, Italia","location":{"lat":"42.3003123","city":"Salisano","state":"Lazio","country":"Italia","lng":"12.7377003","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/pozze-del-diavolo\/","zoom":18,"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]Ai piedi del maestoso Monte Tancia, il pi\u00f9 elevato tra i monti sabini, e nelle vicinanze del Monte Ode, si trova un luogo incantato noto come le Pozze del Diavolo. Immerso in boschi densi, questo magico angolo \u00e8 reso suggestivo dal torrente Galantina che si precipita in cascate[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/intorno-a-te\/punti-da-non-perdere\/\"][vc_empty_space height=\"25px\"][\/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%2F41.8316288%2C12.8778365%2Fdove%2Bsi%2Btrovano%2Ble%2Bpozze%2Bdel%2Bdiavolo%2Brieti%2F%4042.0673169%2C12.3757913%2C10z%2Fdata%3D!3m1!4b1!4m9!4m8!1m1!4e1!1m5!1m1!1s0x132f09ae98c99f77%3A0xa92d96004613545d!2m2!1d12.7377003!2d42.3003123%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>Pozze del <strong>Diavolo<\/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_1716538233410{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]\r\n<div class=\"gm-style-iw gm-style-iw-c\" tabindex=\"-1\" role=\"dialog\">\r\n<div class=\"gm-style-iw-d\">\r\n<div class=\"gm-iw\">Salisano<\/div>\r\n<div>02040, Rieti<\/div>\r\n<\/div>\r\n&nbsp;\r\n\r\n<\/div>\r\n[\/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_1702570858261{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]sempre aperto\r\n\r\n[\/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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Ai piedi del maestoso Monte Tancia, il pi\u00f9 elevato tra i monti sabini, e nelle vicinanze del Monte Ode, si trova un luogo incantato noto come le Pozze del Diavolo. Immerso in boschi densi, questo magico angolo \u00e8 reso suggestivo dal torrente Galantina che si precipita in cascate, creando pittoresche pozze lungo il suo corso.\r\n\r\nQuesto gioiello naturale, \u00e8 accessibile attraverso un sentiero che segue il corso del torrente Galantina e conduce fino all'eremo di San Michele. Le Pozze del Diavolo, una sorta di piscina naturale, rappresentano una meraviglia della natura, con l'acqua verde smeraldo che si tuffa in cascata, circondata da boschi lussureggianti. Un luogo magico che sembra distante dal caos della citt\u00e0, quasi un angolo di paradiso nel cuore della Sabina.\r\n\r\nPer raggiungere questo luogo incantato, potete percorrere il sentiero che parte da Poggio Catino o da Monte San Giovanni in Sabina. Attraversando il Valico del Tancia e il pittoresco ponticello presso l'antica Osteria del Tancia di origine medievale, potrete seguire il corso del Torrente Galantina.\r\n\r\nIl sentiero vi guider\u00e0 fino alle Pozze del Diavolo, dove il torrente forma una cascata che si riversa in vasche naturali. Lungo il percorso, potrete ammirare due pozze, una a monte della cascata e l'altra a valle. Il ritorno pu\u00f2 essere arricchito seguendo il Sentiero degli Eremi, che vi condurr\u00e0 agli eremi di San Michele e San Leonardo.\r\n\r\nQuesto luogo segreto, nascosto tra le valli e le montagne della Sabina, rappresenta una tappa imperdibile per coloro che desiderano scoprire la bellezza incontaminata del Lazio, lontano dalla frenesia della vita quotidiana.[\/vc_column_text][vc_empty_space height=\"25px\"][qodef_image_gallery type=\"carousel\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" space_between_items=\"tiny\" number_of_visible_items=\"3\" slider_loop=\"no\" slider_autoplay=\"no\" slider_navigation=\"no\" slider_pagination=\"no\" images=\"13364,13360,13356\" image_size=\"full\"][vc_empty_space height=\"25px\"][\/vc_column][\/vc_row]","post_title":"Pozze del Diavolo","post_link":"https:\/\/geosabina.it\/altri-comuni\/pozze-del-diavolo\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pozze del Diavolo\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/06\/Pozze-del-Diavolo-2-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1716538233410{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1702570858261{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;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":368,\"to_translate\":{\"en\":368}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"02040 Salisano RI, Italia","%_wpgmp_location_city%":"Salisano","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.3003123","%_wpgmp_metabox_longitude%":"12.7377003","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"18\";i:3;s:2:\"20\";i:4;s:2:\"29\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"23\";}","%_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","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Pozze del Diavolo","%_yoast_wpseo_metadesc%":"Ai piedi del maestoso Monte Tancia, il pi\u00f9 elevato tra i monti sabini, e nelle vicinanze del Monte Ode, si trova un luogo incantato noto come le Pozze del Diavolo.","%_yoast_wpseo_linkdex%":"72","%_oembed_1eb08ede5fcfd3a110467a2c63748b96%":"{{unknown}}","%_oembed_36cedc6b2f240b2eb3df757c5e017720%":"{{unknown}}","%_dp_original%":"9700","%_edit_lock%":"1720195539:6","%_edit_last%":"4","%_thumbnail_id%":"13350","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/bellezze-naturali_sito.png"},"id":10777,"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\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Il Museo Civico Archeologico di Fara in Sabina","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Il Museo Civico Archeologico di Fara in Sabina\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/01\/museo-civico-di-fara-sabina-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\/altri-comuni\/il-museo-civico-archeologico-di-fara-in-sabina\/\" class=\"fc-post-link\">Il Museo Civico Archeologico di Fara in Sabina<\/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 Duomo, 3, 02032 Fara In Sabina RI, Italia","location":{"lat":"42.2095064","city":"Fara in Sabina","state":"Lazio","country":"Italia","lng":"12.7288289","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/il-museo-civico-archeologico-di-fara-in-sabina\/","zoom":18,"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 Civico Archeologico di Fara in Sabina (MUSAF) ha aperto le sue porte nel 2001 all'interno del suggestivo Palazzo Brancaleoni, un edificio rinascimentale situato nella piazza del Duomo nel cuore del centro storico di Fara Sabina.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/intorno-a-te\/punti-da-non-perdere\/\"][\/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%2Fplace%2FPiazza%2BDuomo%2C%2B3%2C%2B02032%2BFara%2BIn%2BSabina%2BRI%2F%4042.2093997%2C12.7284015%2C19.75z%2Fdata%3D!4m6!3m5!1s0x132f0b93a7a11403%3A0x8a6340c9d4f8d2d2!8m2!3d42.2095064!4d12.7288289!16s%252Fg%252F11c2brzz4n%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>Il Museo Civico Archeologico di<strong> Fara in Sabina<\/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_1699427201526{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]P.zza del Duomo, 3\r\n02032 Fara in Sabina (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_1711446266912{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Dal <strong>giovedi<\/strong> alla <strong>Domenica<\/strong>\r\n<strong>ore<\/strong>: 10.00, 11.30, 14.00, 15.30, 17.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_1711446276794{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Tel<\/strong>: 0765 277321 \/ 380 2838920\r\n<strong>Mail<\/strong>: visitfarainsabina@gmail.com[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]<strong>Il Museo Civico Archeologico di Fara in Sabina<\/strong> (MUSAF) ha aperto i battenti nel 2001 all'interno del suggestivo <strong>Palazzo Brancaleoni<\/strong>, edificio rinascimentale situato in Piazza del Duomo, nel cuore del centro storico di Fara Sabina.\r\n\r\nLa storia della famiglia Brancaleoni affonda le sue radici nel 1257, con il nobile Andrea Brancaleonis de Romania. Questa famiglia di potenti feudatari, originariamente alleata della Santa Sede e della fazione guelfa, ottenne numerosi privilegi grazie al <strong>Cardinale Leone<\/strong> e divenne proprietaria di vasti possedimenti nella <strong>Sabina<\/strong> e nella zona del <strong>distretto di Roma<\/strong> chiamata Romania tra il XII e il XIV secolo. Tra le loro residenze spiccano <strong>Ginestra<\/strong> e <strong>Monteleone Sabino<\/strong>, quest'ultima divenuta nei secoli la residenza principale della famiglia.\r\n\r\nNel 1265, durante il tentativo del re di Sicilia Carlo d'Angi\u00f2 di fermare l'offensiva di Manfredi contro Roma, Andrea Brancaleoni e suo fratello Oddone vennero nominati vicari e capitani della giustizia abruzzese, dimostrando cos\u00ec la loro fedelt\u00e0 alla corona.\r\n\r\n<strong>L'attuale edificio<\/strong>, un affascinante esempio di architettura rinascimentale, \u00e8 il risultato dell'unione di diverse case torri risalenti alla met\u00e0 del XIII secolo, anche se non \u00e8 chiaro a quale ramo specifico della famiglia Brancaleoni appartenesse. La facciata originale del XV secolo si \u00e8 conservata intatta, mentre l'interno \u00e8 stato pesantemente ristrutturato dai proprietari successivi. <strong>All'interno<\/strong>, una delle sale presenta affreschi in stile tardo-barocco, decorati con motivi grotteschi tipici delle residenze aristocratiche della fine del XVIII secolo.\r\n\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][qodef_image_gallery type=\"grid\" enable_image_shadow=\"no\" image_behavior=\"lightbox\" number_of_columns=\"four\" space_between_items=\"tiny\" images=\"11749,11745,11751,11747\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"20px\"][vc_column_text]<strong>Il Museo Civico Archeologico di Fara in Sabina<\/strong>, ha aperto le sue porte al <strong>corredo funerario della Tomba XI della Necropoli di Colle del Forno<\/strong> e al suo reperto pi\u00f9 celebre:<strong> il Carro del Principe di Eretum.<\/strong>\u00a0Dopo un anno di lavori di ristrutturazione e di allestimento degli spazi museali di <strong>Palazzo Brancaleoni. <\/strong>Il recupero, il restauro, la fruizione e valorizzazione del prezioso ritrovamento sono stati resi possibili dal lavoro sinergico del Comune di Fara in Sabina e della Soprintendenza Archeologia,<strong> Belle Arti e Paesaggio per l\u2019area metropolitana di Roma e per la provincia di Rieti<\/strong>. Lo sforzo per consegnare alla comunit\u00e0 questo antico tesoro \u00e8 intimamente legato alle vicende del suo \u201critorno\u201d in patria, che rendono ancora pi\u00f9 significativa l\u2019appartenenza di questi preziosi beni al suo territorio. Si era infatti persa traccia di gran parte del corredo del Carro di Eretum, saccheggiato e illecitamente esportato, fino a quando le autorit\u00e0 italiane hanno identificato tale patrimonio all\u2019interno delle collezioni della Ny Carlsberg Glyptotek di Copenaghen e, dopo anni di trattative, grazie all\u2019intervento del Comando TPC dei Carabinieri, hanno ottenuto indietro quanto ognuno di noi potr\u00e0 ammirare. Infatti tutti hanno\u00a0 la possibilit\u00e0 di conoscere da vicino i <strong>reperti della\u00a0 sala museale<\/strong>.\r\n\r\nLe <strong>visite guidate<\/strong> sono previste dal gioved\u00ec alla domenica. Invece, dal luned\u00ec al mercoled\u00ec, si potranno eseguire su prenotazione.[\/vc_column_text][vc_empty_space height=\"40px\"][\/vc_column][\/vc_row]","post_title":"Il Museo Civico Archeologico di Fara in Sabina","post_link":"https:\/\/geosabina.it\/altri-comuni\/il-museo-civico-archeologico-di-fara-in-sabina\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Il Museo Civico Archeologico di Fara in Sabina\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/01\/museo-civico-di-fara-sabina-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1699427201526{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1711446266912{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1711446276794{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\":598,\"to_translate\":{\"en\":598}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Piazza Duomo, 3, 02032 Fara In Sabina RI, Italia","%_wpgmp_location_city%":"Fara in Sabina","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2095064","%_wpgmp_metabox_longitude%":"12.7288289","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:4:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"20\";i:3;s:2:\"24\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:2:\"13\";i:1;s:2:\"23\";}","%_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","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_wordproof_timestamp%":"","%_dp_original%":"6826","%_edit_lock%":"1720194478:6","%_edit_last%":"4","%_yoast_wpseo_focuskw%":"Il Museo Civico Archeologico di Fara in Sabina","%_yoast_wpseo_metadesc%":"Il Museo Civico Archeologico di Fara in Sabina (MUSAF) si trova all\u2019interno del suggestivo Palazzo Brancaleoni, in Piazza del Duomo, nel cuore del centro storico di Fara Sabina.","%_yoast_wpseo_linkdex%":"70","%_thumbnail_id%":"11002","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/archeologia_sito.png"},"id":9720,"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"}},{"icon":"https:\/\/geosabina.it\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Rieti Sotterranea","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rieti Sotterranea\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/05\/rieti_sotterranea_geosabina-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\/altri-comuni\/rieti-sotterranea\/\" class=\"fc-post-link\">Rieti Sotterranea<\/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 Cavour, 02100 Rieti RI, Italia","location":{"lat":"42.3995211","city":"Rieti","state":"Lazio","country":"Italia","lng":"12.8610231","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/rieti-sotterranea\/","zoom":18,"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'intricato labirinto sotterraneo di Rieti ebbe origine con l'intento di agevolare il passaggio della Via Salaria, l'antica strada del sale, oltre il fiume Velino, proteggendo la citt\u00e0 dalle alluvioni e dalle zone paludose che si formavano lungo le vie antiche durante le piene del fiume[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/intorno-a-te\/punti-da-non-perdere\/\"][\/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%2Fplace%2FRieti%2BSotterranea%2F%4042.397945%2C12.8573537%2C16.75z%2Fdata%3D!4m20!1m13!4m12!1m4!2m2!1d12.681216!2d42.2641664!4e1!1m6!1m2!1s0x132fab84fa0f2e01%3A0x2e34685cad4dab15!2sindirizzo%2Brieti%2Bsotterranea!2m2!1d12.8610231!2d42.3995211!3m5!1s0x132fab84fa0f2e01%3A0x2e34685cad4dab15!8m2!3d42.3995211!4d12.8610231!16s%252Fg%252F11j8ktnrqj%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<h1>Rieti <strong>Sotterranea <\/strong><\/h1>\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_1699611530059{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Piazza Cavour\r\n02100 - Rieti 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_1699348736756{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_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_btn title=\"Vai al sito web\" color=\"chino\" size=\"xs\" align=\"left\" i_icon_fontawesome=\"fas fa-share-square\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.rietidascoprire.it%2Fportfolio%2Frieti-sotterranea%2F|target:_blank\" css=\".vc_custom_1699696346279{margin-top: 12px !important;}\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]L'intricato labirinto sotterraneo di Rieti ebbe origine con l'intento di agevolare il passaggio della Via Salaria, l'antica strada del sale, oltre il fiume Velino, proteggendo la citt\u00e0 dalle alluvioni e dalle zone paludose che si formavano lungo le vie antiche durante le piene del fiume.\r\n\r\nQuesti tunnel si intrecciano tra le profondit\u00e0 di alcune residenze nobili di Rieti, con pareti costruite con massicci blocchi di travertino caverno, che sostengono il livello stradale soprastante.\r\n\r\nIl promontorio di travertino su cui la citt\u00e0 si svilupp\u00f2, dalla preistoria all'alto medioevo dopo il III secolo a.C., fu circondato da una robusta rete di mura in opus quadratum, intervallate dalle porte che delimitavano il tracciato urbano della Salaria. Questa strada selciata, che attraversava l'Italia centrale, garantiva il collegamento tra il Tirreno e l'Adriatico, definendo nel centro cittadino il cardo e il decumano.\r\n\r\nDal lato meridionale, la Salaria attraversava la porta Romana, posizionata all'apice del cardo, come testimonia l'epigrafe di C. Carantio ancora oggi incastonata sulla facciata della chiesa di San Pietro Apostolo. Proseguendo verso est, attraversava la porta Herculana. Verso ovest, il decumano continuava attraverso la porta Quintia o Cinzia, tramite un passaggio secondario che si dirigeva verso l'Umbria.[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Rieti Sotterranea","post_link":"https:\/\/geosabina.it\/altri-comuni\/rieti-sotterranea\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rieti Sotterranea\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/05\/rieti_sotterranea_geosabina-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1699611530059{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1699348736756{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_1699696346279{margin-top: 12px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":312,\"to_translate\":{\"en\":312}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Piazza Cavour, 02100 Rieti RI, Italia","%_wpgmp_location_city%":"Rieti","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.3995211","%_wpgmp_metabox_longitude%":"12.8610231","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:4:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"18\";i:3;s:2:\"25\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:2:\"13\";i:1;s:2:\"23\";}","%_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","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Rieti Sotterranea","%_yoast_wpseo_metadesc%":"L'intricato labirinto sotterraneo di Rieti ebbe origine con l'intento di agevolare il passaggio della Via Salaria, l'antica strada del sale, oltre il fiume Velino, proteggendo la citt\u00e0 dalle alluvioni","%_yoast_wpseo_linkdex%":"59","%_dp_original%":"9706","%_edit_lock%":"1720201247:4","%_edit_last%":"4","%_thumbnail_id%":"12474","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/archeologia_sito.png"},"id":9714,"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"}},{"icon":"https:\/\/geosabina.it\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Il Museo del Silenzio","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Il Museo del Silenzio\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/01\/museo-del-silenzio-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\/altri-comuni\/il-museo-del-silenzio\/\" class=\"fc-post-link\">Il Museo del Silenzio<\/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 Santa Maria in Castello, 4, 02032 Fara In Sabina RI, Italia","location":{"lat":"42.2096223","city":"Fara in Sabina","state":"Lazio","country":"Italia","lng":"12.7291954","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/il-museo-del-silenzio\/","zoom":18,"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]I visitatori sono accolti nel \"recinto sacro\" rappresentato dal monastero stesso, immergendosi in un'esperienza sensoriale, intellettuale ed emotiva. La dicotomia tra buio e luce, silenzio e parola, offre la chiave per comprendere il mondo sia fisicamente che metaforicamente[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/intorno-a-te\/punti-da-non-perdere\/\"][\/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%2Fplace%2FMuseo%2BDel%2BSilenzio%2F%4042.2094379%2C12.7292318%2C20z%2Fdata%3D!4m15!1m8!3m7!1s0x132f0b930ac10567%3A0xfcbf878bf35bb909!2sVia%2BSanta%2BMaria%2Bin%2BCastello%2C%2B4%2C%2B02032%2BFara%2BIn%2BSabina%2BRI!3b1!8m2!3d42.2096223!4d12.7291954!16s%252Fg%252F11c235qzrk!3m5!1s0x132f0b937539f487%3A0x4de6cbb322f1f477!8m2!3d42.2095871!4d12.729397!16s%252Fg%252F11h54zqzsc%3Fhl%3Dit%26entry%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<h1>Il Museo del <strong>Silenzio<\/strong><\/h1>\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_1699609925032{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Santa Maria in Castello 4,\r\n02032 - Fara In Sabina, 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_1699348736756{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_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_btn title=\"Vai al sito web\" color=\"chino\" size=\"xs\" align=\"left\" i_icon_fontawesome=\"fas fa-share-square\" add_icon=\"true\" link=\"url:http%3A%2F%2Fwww.clarisseremite.com%2Fmuseodelsilenzio.html|target:_blank\" css=\".vc_custom_1699611802568{margin-top: 12px !important;}\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Il Museo del silenzio, inaugurato nel 2004, si distingue per la sua innovativit\u00e0 linguistica e strutturale, concentrandosi sul silenzio che ha costituito il cuore di questo luogo fin dal 1673.\r\n\r\nI visitatori sono accolti nel \"recinto sacro\" rappresentato dal monastero stesso, immergendosi in un'esperienza sensoriale, intellettuale ed emotiva. La dicotomia tra buio e luce, silenzio e parola, offre la chiave per comprendere il mondo sia fisicamente che metaforicamente.\r\n\r\nAll'interno del Museo, 21 teche contengono oggetti comuni, semplici e modesti. Quando illuminati, essi evocano la potenza di una memoria storica che, anche dopo secoli, riflette su sette grandi tematiche che caratterizzavano la vita quotidiana della prima comunit\u00e0 monastica:\r\n<ol>\r\n \t<li>Preghiera<\/li>\r\n \t<li>Silenzio<\/li>\r\n \t<li>Disciplina<\/li>\r\n \t<li>Cucito<\/li>\r\n \t<li>Farmacia<\/li>\r\n \t<li>Cucina<\/li>\r\n \t<li>Lavoro<\/li>\r\n<\/ol>\r\n[\/vc_column_text][vc_empty_space height=\"25px\"][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\" custom_class=\"gallery_app\" image_size=\"full\" images=\"9853,9855,9857,9859\"][vc_column_text css=\".vc_custom_1699958746901{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]\r\n<h6>Le foto sono reperite dal sito ufficiale<\/h6>\r\n[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Il Museo del Silenzio","post_link":"https:\/\/geosabina.it\/altri-comuni\/il-museo-del-silenzio\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Il Museo del Silenzio\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/01\/museo-del-silenzio-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1699958746901{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1699609925032{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1699348736756{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_1699611802568{margin-top: 12px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":234,\"to_translate\":{\"en\":234}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Santa Maria in Castello, 4, 02032 Fara In Sabina RI, Italia","%_wpgmp_location_city%":"Fara in Sabina","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2096223","%_wpgmp_metabox_longitude%":"12.7291954","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:4:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"20\";i:3;s:2:\"24\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:2:\"13\";i:1;s:2:\"23\";}","%_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","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_dp_original%":"6826","%_edit_lock%":"1720194402:6","%_edit_last%":"4","%_yoast_wpseo_focuskw%":"Il Museo del Silenzio","%_yoast_wpseo_metadesc%":"Il Museo del silenzio, inaugurato nel 2004, si distingue per la sua innovativit\u00e0 linguistica e strutturale, concentrandosi sul silenzio che ha costituito il cuore di questo luogo fin dal 1673.","%_yoast_wpseo_linkdex%":"65","%_thumbnail_id%":"11034","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/archeologia_sito.png"},"id":9706,"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"}},{"icon":"https:\/\/geosabina.it\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Il Bunker Soratte","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Il Bunker Soratte\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/12\/002-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\/altri-comuni\/il-bunker-soratte\/\" class=\"fc-post-link\">Il Bunker Soratte<\/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":"Viale Europa, 58, 00060 Sant'Oreste RM, Italia","location":{"lat":"42.2368902","city":"Sant'Oreste","state":"Lazio","country":"Italia","lng":"12.5139931","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/il-bunker-soratte\/","zoom":18,"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]Le Gallerie del Monte Soratte, conosciute come il \"Bunker di Soratte,\" sono un'importante opera di ingegneria militare. Queste strutture sotterranee, lunghe circa 4 chilometri, furono scavate a partire dal 1937 su iniziativa di Benito Mussolini[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/intorno-a-te\/punti-da-non-perdere\/\"][vc_empty_space height=\"25px\"][\/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%2Fplace%2FBunker%2BSoratte%2F%4042.2370291%2C12.5091909%2C17z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132f14154ace8c1d%3A0x881d17f0b2739244!8m2!3d42.2370252!4d12.5117658!16s%252Fg%252F11gbfd5xfy%3Fhl%3Dit%26entry%3Dttu\" el_id=\"bottoneindicazioni\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"2\/3\"][vc_empty_space][vc_column_text]\r\n<h2>Il Bunker <strong>Soratte<\/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]<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_1720769275267{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]\r\n<div class=\"gm-style-iw gm-style-iw-c\" tabindex=\"-1\" role=\"dialog\">\r\n<div class=\"gm-style-iw-d\">\r\n<div class=\"gm-iw\">Viale Europa<\/div>\r\n<div class=\"gm-iw\">00060 - Sant'Oreste (RM)<\/div>\r\n<\/div>\r\n&nbsp;\r\n\r\n<\/div>\r\n[\/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_1699339570615{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Aperto durante le visite guidate[\/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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_btn title=\"Vai al sito web del Bunker Soratte\" color=\"black\" size=\"xs\" align=\"left\" i_icon_fontawesome=\"fas fa-share-square\" add_icon=\"true\" link=\"url:https%3A%2F%2Fbunkersoratte.it|target:_blank\" css=\".vc_custom_1720769343621{margin-top: 12px !important;}\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space][vc_column_text]Le Gallerie del Monte Soratte, conosciute come il \"Bunker di Soratte,\" sono un'importante opera di ingegneria militare. Queste strutture sotterranee, lunghe circa 4 chilometri, furono scavate a partire dal 1937 su iniziativa di Benito Mussolini. L'obiettivo era creare un rifugio antiaereo sicuro per le alte cariche dell'Esercito italiano, nel caso di attacchi aerei durante la Seconda Guerra Mondiale.\r\n\r\nI lavori di costruzione furono avviati nel 1937 sotto la direzione del Genio Militare di Roma, su ordine di Mussolini. Le gallerie consistono in un intricato sistema di tunnel e cunicoli su quattro livelli differenti. Il livello pi\u00f9 profondo ospitava il rifugio antiaereo, attrezzato con tutti i comfort necessari per accogliere le alte cariche dell'Esercito italiano per un periodo prolungato. Il livello pi\u00f9 superficiale conteneva i locali tecnici, come centrali elettriche e stazioni di comunicazione.\r\n\r\nDurante la Seconda Guerra Mondiale, nel settembre del 1943, le gallerie furono utilizzate per la prima volta durante i bombardamenti alleati su Roma. In quel periodo, il bunker fungeva da quartier generale per il Comando Supremo del Sud, guidato dal generale Albert Kesselring. Dopo la guerra, le gallerie furono abbandonate e rimasero in stato di disuso per diversi decenni.\r\n\r\nNegli anni '90, il Comune di Sant'Oreste, dove si trova il Monte Soratte, avvi\u00f2 un progetto di restauro e recupero delle gallerie, completato nel 2004. Oggi, le Gallerie del Monte Soratte sono aperte al pubblico e possono essere visitate su prenotazione. Il percorso di visita dura circa un'ora e mezza e offre un'opportunit\u00e0 unica per esplorare la storia e la struttura di questo significativo complesso militare.\r\n\r\nLe Gallerie del Monte Soratte rappresentano un importante simbolo della storia militare italiana, ricordando le vicende belliche del paese e dimostrando l'abilit\u00e0 dell'ingegneria militare italiana durante la Seconda Guerra Mondiale. Oggi, grazie all'impegno della Libera Associazione Culturale Santorestese \u201cBunker Soratte\u201d, queste gallerie sono aperte ai visitatori, offrendo una testimonianza tangibile del passato.[\/vc_column_text][vc_empty_space height=\"25px\"][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\" custom_class=\"gallery_app\" image_size=\"full\" images=\"9834,9836,9838,9840\"][vc_column_text css=\".vc_custom_1699957342527{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]\r\n<h6>Le foto sono reperite dal sito ufficiale del bunker: bunkersoratte.it<\/h6>\r\n[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Il Bunker Soratte","post_link":"https:\/\/geosabina.it\/altri-comuni\/il-bunker-soratte\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Il Bunker Soratte\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/12\/002-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1699957342527{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1720769275267{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1699339570615{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_1720769343621{margin-top: 12px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":438,\"to_translate\":{\"en\":438}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Viale Europa, 58, 00060 Sant'Oreste RM, Italia","%_wpgmp_location_city%":"Sant'Oreste","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2368902","%_wpgmp_metabox_longitude%":"12.5139931","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"18\";i:3;s:2:\"20\";i:4;s:2:\"26\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"9\";i:1;s:2:\"23\";}","%_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","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Il Bunker di Soratte","%_yoast_wpseo_metadesc%":"il \"Bunker di Soratte,\" \u00e8 un'importante opera di ingegneria militare. Queste strutture sotterranee, lunghe circa 4 chilometri, furono scavate a partire dal 1937 su iniziativa di Benito Mussolini.","%_yoast_wpseo_linkdex%":"72","%_dp_original%":"9693","%_edit_lock%":"1720769276:4","%_edit_last%":"4","%_oembed_1eb08ede5fcfd3a110467a2c63748b96%":"{{unknown}}","%_oembed_36cedc6b2f240b2eb3df757c5e017720%":"{{unknown}}","%_thumbnail_id%":"10231","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/musei_sito.png"},"id":9700,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/musei_sito.png","name":"Musei \/ Museums","id":"9","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https:\/\/geosabina.it\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Il Museo dell&#8217;olio","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Il Museo dell&#8217;olio\" width=\"300\" height=\"176\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/11\/mulino-xviii-secolo-300x176.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\/altri-comuni\/il-museo-dellolio\/\" class=\"fc-post-link\">Il Museo dell&#8217;olio<\/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":"Viale Regina Margherita, 02031 Castelnuovo di Farfa RI, Italia","location":{"lat":"42.2315733","city":"Castelnuovo di Farfa","state":"Lazio","country":"Italia","lng":"12.7445633","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/il-museo-dellolio\/","zoom":18,"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 dell'Olio, situato a Castelnuovo di Farfa, accoglie i visitatori con un'intrigante esposizione esterna. Graffiti incisi sulla malta colorata richiamano le sfumature dell'olio, mentre le frasi sottolineano il mistero condiviso tra l'arte e l'olio.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/intorno-a-te\/punti-da-non-perdere\/\"][vc_empty_space height=\"25px\"][\/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%2Fplace%2FMuseo%2Bdell'Olio%2Bdella%2BSabina%2F%4042.2319111%2C12.7425902%2C20z%2Fdata%3D!4m22!1m15!4m14!1m6!1m2!1s0x132f09622e0a58b5%3A0x9720c280832c9415!2sMuseo%2Bdell'Olio%2Bdella%2BSabina%2C%2BViale%2BRegina%2BMargherita%2C%2BCastelnuovo%2Bdi%2BFarfa%2C%2BRI!2m2!1d12.7430334!2d42.2320084!1m6!1m2!1s0x132f0ee62f010f87%3A0xefbad483e0df959a!2sPoggio%2BMirteto%2C%2B02047%2BRI!2m2!1d12.6876246!2d42.2682668!3m5!1s0x132f09622e0a58b5%3A0x9720c280832c9415!8m2!3d42.2320084!4d12.7430334!16s%252Fg%252F12hm23k1p%3Fhl%3Dit%26entry%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>Il Museo dell'olio<\/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_1699336665130{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]\r\n<div class=\"gm-style-iw gm-style-iw-c\" tabindex=\"-1\" role=\"dialog\">\r\n<div class=\"gm-style-iw-d\">\r\n<div class=\"gm-iw\">Viale Regina Margherita, 02031<\/div>\r\n<div class=\"gm-iw\">Castelnuovo di Farfa RI<\/div>\r\n<\/div>\r\n&nbsp;\r\n\r\n<\/div>\r\n[\/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_1699336553153{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]aperto dalle <strong>10:00<\/strong> alle <strong>18.00<\/strong>\r\nVenerd\u00ec \u2013 Sabato - Domenica e festivi[\/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_btn title=\"Vai al sito web\" color=\"chino\" size=\"xs\" align=\"left\" i_icon_fontawesome=\"fas fa-share-square\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.castelnuovodifarfaturismo.it%2Fscopri-museo-dell-olio|target:_blank\" css=\".vc_custom_1699695312306{margin-top: 12px !important;}\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]Il Museo dell'Olio, situato a Castelnuovo di Farfa, accoglie i visitatori con un'intrigante esposizione esterna. Graffiti incisi sulla malta colorata richiamano le sfumature dell'olio, mentre le frasi sottolineano il mistero condiviso tra l'arte e l'olio.\r\n\r\nAll'interno del museo, la prima opera cattura l'attenzione: un segmento di tronco d'ulivo, con assi di legno di varie dimensioni che formano una suggestiva chioma. Le pareti nere, adornate con fili d'oro, evocano il flusso dell'olio attraverso lo spazio, creando un'atmosfera che abbraccia pianeti e libert\u00e0.\r\n\r\nUn passo successivo svela un'opera incompiuta di Alik Cavaliere, a causa della prematura morte dell'artista. Sette frammenti bronzei, ritratti scultorei di un olivo umanizzato, giacciono sul pavimento, raffigurando una natura sempre diversa, ma vibrante.\r\n\r\nLa visita continua in una caverna illuminata da tenue luce, dove una barca capovolta in rame galleggia su barchette simili. La sala delle macchine presenta le antiche presse, testimonianza cruciale del passato processo di produzione dell'olio, mentre una melodia unica prende vita nella sala dell'oleofono, sincronizzando il gocciare irregolare dell'olio con la rotazione di un secolare tronco d'ulivo.\r\n\r\nLa penultima tappa conduce al vecchio mulino del tardo XVIII secolo, dove una mola, di solito azionata da un asino, serviva alla comunit\u00e0 non solo per l'olio, ma anche per altri alimenti.\r\n\r\nL'ultima fase del percorso, fuori dal museo, si svolge presso il forno, con un'insegna che recita \"Olio al pane alla terra il sogno\". Un fuoco simbolico cuoce pani di ceramica, mentre quelli gi\u00e0 pronti sono disposti su una panca di legno, adornati con ramoscelli d'ulivo dorato, simbolo della trasformazione dell'olio nel dare nuovo sapore al pane, analogamente all'arte e alla vita di ogni individuo.\r\n\r\nCos\u00ec si conclude la nostra visita in quello che riteniamo essere una delle attrazioni pi\u00f9 originali e suggestive della Sabina.[\/vc_column_text][vc_empty_space height=\"25px\"][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\" custom_class=\"gallery_app\" image_size=\"full\" images=\"9824,9826,9828,9830\"][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Il Museo dell&#8217;olio","post_link":"https:\/\/geosabina.it\/altri-comuni\/il-museo-dellolio\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Il Museo dell&#8217;olio\" width=\"300\" height=\"176\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/11\/mulino-xviii-secolo-300x176.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1699336665130{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1699336553153{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_1699695312306{margin-top: 12px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":475,\"to_translate\":{\"en\":475}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Viale Regina Margherita, 02031 Castelnuovo di Farfa RI, Italia","%_wpgmp_location_city%":"Castelnuovo di Farfa","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2315733","%_wpgmp_metabox_longitude%":"12.7445633","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:4:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"18\";i:3;s:2:\"28\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"9\";i:1;s:2:\"23\";}","%_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","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Il Museo dell'olio","%_yoast_wpseo_metadesc%":"Situato a Castelnuovo di Farfa, il Museo dell'Olio della Sabina \u00e8 un luogo dedicato interamente alla storia e alla cultura dell'olio d'oliva nella regione della Sabina.","%_yoast_wpseo_linkdex%":"70","%_dp_original%":"6970","%_edit_lock%":"1720201010:4","%_edit_last%":"4","%_thumbnail_id%":"9868","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/musei_sito.png"},"id":9693,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/musei_sito.png","name":"Musei \/ Museums","id":"9","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https:\/\/geosabina.it\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Parco Il Monte e Chiesetta del Monte","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Parco Il Monte e Chiesetta del Monte\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/04\/parco_del_monte-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\/montasola\/parco-il-monte-e-chiesetta-del-monte\/\" class=\"fc-post-link\">Parco Il Monte e Chiesetta del Monte<\/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":"02040 Montasola RI, Italia","location":{"lat":"42.38777779999999","city":"Montasola","state":"Lazio","country":"Italia","lng":"12.681554","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/montasola\/parco-il-monte-e-chiesetta-del-monte\/","zoom":18,"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]Su una collina vicino al borgo di Montasola, il Parco Il Monte \u00e8 un bellissimo spazio verde, ben curato e sempre vivo. All' interno si trovano aree per ogni esigenza, dal parco giochi per i bambini agli spazi di verde dove fare pic-nic[\/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=\"3877\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/montasola\/\"][\/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%2FParco%2B%2522Il%2BMonte%2522%2F%4042.3873711%2C12.6810857%2C18.5z%2Fdata%3D!4m14!1m7!3m6!1s0x132f05d96a4dc1af%3A0x981d93e8e81a8c48!2sParco%2B%2522Il%2BMonte%2522!8m2!3d42.3877778!4d12.681554!16s%252Fg%252F11t7595sc5!3m5!1s0x132f05d96a4dc1af%3A0x981d93e8e81a8c48!8m2!3d42.3877778!4d12.681554!16s%252Fg%252F11t7595sc5%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>Parco<strong> il Monte <\/strong>e<strong> Chiesetta <\/strong>del Monte<\/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_1695380653531{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Forcella\r\n02040 <strong>Montasola\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_1702542960309{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]Su una collina vicino al borgo di Montasola, il Parco Il Monte \u00e8 un bellissimo spazio verde, ben curato e sempre vivo. All' interno si trovano aree per ogni esigenza, dal parco giochi per i bambini, spazzi di verde dove fare pic-nic, una sala coperta, un anfiteatro che viene utilizzato durante l'inverno come pista di pattinaggio e ovviamente <strong>un panorama che regala impagabili viste sul tramonto e sui monti vicini.<\/strong>\r\n\r\nIn pi\u00f9, sempre all\u2019interno del parco, si trova la <strong>Chiesetta del Monte<\/strong>, donata anche questa dal benefattore <a href=\"https:\/\/geosabina.it\/il-complesso-opera-pia-cimini-montasola\/\">Franceso Cimini.<\/a> La chiesa \u00e8 un edificio semplice, con una facciata in pietra a vista e un interno a navata unica. L'interno della chiesa \u00e8 decorato con un <strong>affresco raffigurante l'Ascensione di Maria<\/strong>.[\/vc_column_text][vc_empty_space height=\"20px\"][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=\"no\" slider_pagination=\"no\" images=\"12502,12504,12506,12508\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Parco Il Monte e Chiesetta del Monte","post_link":"https:\/\/geosabina.it\/montasola\/parco-il-monte-e-chiesetta-del-monte\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Parco Il Monte e Chiesetta del Monte\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2024\/04\/parco_del_monte-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_1695380653531{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1702542960309{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\":235,\"to_translate\":{\"en\":235}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"02040 Montasola RI, Italia","%_wpgmp_location_city%":"Montasola","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.38777779999999","%_wpgmp_metabox_longitude%":"12.681554","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:4:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";i:3;s:2:\"19\";}","%_wpgmp_metabox_marker_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"4\";i:2;s:2:\"11\";}","%_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%":"12367","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Parco Il Monte","%_yoast_wpseo_metadesc%":"Su una collina vicino al borgo di Montasola, il Parco Il Monte \u00e8 un bellissimo spazio verde, ben curato e sempre vivo.","%_yoast_wpseo_linkdex%":"74","%_dp_original%":"5255","%_edit_lock%":"1715584682:6","%_edit_last%":"6","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Montasola","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/bellezze-naturali_sito.png"},"id":8217,"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\/chiese_sito.png","name":"Chiese e Santuari \/ Churches and Sanctuaries","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/punto-panoramico_sito.png","name":"Punti Panoramici \/ Viewpoints","id":"11","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"La Chiesa dei Santi Pietro e Tommaso","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"La Chiesa dei Santi Pietro e Tommaso\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/42-mInterno-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\/montasola\/la-chiesa-dei-santi-pietro-e-tommaso\/\" class=\"fc-post-link\">La Chiesa dei Santi Pietro e Tommaso<\/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 S. Michele Arcangelo, 3, 02040 Montasola RI, Italia","location":{"lat":"42.3856566","city":"Montasola","state":"Lazio","country":"Italia","lng":"12.6809516","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/montasola\/la-chiesa-dei-santi-pietro-e-tommaso\/","zoom":18,"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 parrocchiale di S. Pietro e Tommaso nel Comune di Montasola \u00e8 costruita quasi alla sommit\u00e0 dell\u2019abitato e custodisce un\u2019epigrafe, posta sulla porta d\u2019accesso alla chiesa, che ci d\u00e0 la data di fondazione della cittadina avvenuta nell\u2019anno 1191[\/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=\"3877\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/montasola\/\"][\/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.com%2Fmaps%2Fplace%2Fsanti%2BPietro%2Be%2BTommaso%2F%4042.3856709%2C12.6808616%2C15z%2Fdata%3D!4m14!1m7!3m6!1s0x132f0470e963c845%3A0x2766cd198304e170!2ssanti%2BPietro%2Be%2BTommaso!8m2!3d42.3856709!4d12.6808616!16s%252Fg%252F11g6rjm2vs!3m5!1s0x132f0470e963c845%3A0x2766cd198304e170!8m2!3d42.3856709!4d12.6808616!16s%252Fg%252F11g6rjm2vs%3Fentry%3Dttu|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>La Chiesa dei Santi <strong>Pietro e Tommaso<\/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_1695315689230{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via S. Michele Arcangelo, 3\r\n02040 <strong>Montasola\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_1702459159883{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]aperto durante le funzioni religiose[\/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]La chiesa parrocchiale di S. Pietro e Tommaso nel Comune di Montasola \u00e8 costruita quasi alla sommit\u00e0 dell\u2019abitato e custodisce un\u2019epigrafe, posta sulla porta d\u2019accesso alla chiesa, che ci d\u00e0 la data di fondazione della cittadina avvenuta nell\u2019anno 1191 per opera di Papa Celestino III, ricordando nel contempo la costruzione della chiesa dedicata agli apostoli Pietro e Tommaso\r\nInizialmente si trovavano cinque altari oltre quello maggiore(probabilmente uno \u00e8 stato smantellato completamente, in quanto oggi mancante): l\u2019altare maggiore \u00e8 dedicato al SS. Sacramento e alla Madonna Assunta. Nella nicchia centrale dell\u2019abside \u00e8 collocata la statua lignea dell\u2019Assunta; alla sua destra una statua raffigurante S.Antonio e alla sinistra un\u2019altra immagine della Madonna, veneratissima nel culto delle popolazioni sabine.\r\nGli affreschi rappresentano La Madonna con i Santi Eusebio e Giovanni, gli stessi che s\u2019incontrano nei quadri posti sulla parete del coro oltre a S.Pietro e Tommaso.\r\nAll\u2019esterno,la facciata della chiesa non presenta un alto valore artistico; aldil\u00e0 delle epigrafi che vi compaiono non si rivela altro che una semplice facciata intonacata. Uno dei motivi potrebbe essere proprio l\u2019alto numero delle ristrutturazioni e rimaneggiamenti effettuati alla chiesa nel corso dei secoli; tant\u2019\u00e8 che, s\u2019\u00e8 visto, la direzione originaria potrebbe non coincidere con l\u2019attuale direzione della chiesa;oltremodo giustificato dal fatto che la facciata si indirizza non su una piazza o su una via che goda di visibilit\u00e0,tipico di un luogo dedicato al culto religioso, ma stretta tra le piccole vie che caratterizzano la struttura medievale del borgo.[\/vc_column_text][vc_empty_space][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=\"8193,8191,8189,8187\" custom_class=\"gallery_app\" image_size=\"full\"][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"La Chiesa dei Santi Pietro e Tommaso","post_link":"https:\/\/geosabina.it\/montasola\/la-chiesa-dei-santi-pietro-e-tommaso\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"La Chiesa dei Santi Pietro e Tommaso\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/42-mInterno-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_1695315689230{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1702459159883{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\":366,\"to_translate\":{\"en\":366}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via S. Michele Arcangelo, 3, 02040 Montasola RI, Italia","%_wpgmp_location_city%":"Montasola","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.3856566","%_wpgmp_metabox_longitude%":"12.6809516","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_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%":"8179","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"La Chiesa dei Santi Pietro e Tommaso","%_yoast_wpseo_metadesc%":"La chiesa di S. Pietro e Tommaso a Montasola (RI) custodisce un\u2019epigrafe che ci d\u00e0 la data di fondazione della cittadina avvenuta nell\u2019anno 1191","%_yoast_wpseo_linkdex%":"62","%_dp_original%":"5255","%_edit_lock%":"1702542946:6","%_edit_last%":"6","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Montasola","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png"},"id":8169,"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":"Fonte Vecchia","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Fonte Vecchia\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/fonte-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\/montasola\/fonte-vecchia\/\" class=\"fc-post-link\">Fonte Vecchia<\/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 Forcella, 21, 02040 Montasola RI, Italia","location":{"lat":"42.3883892","city":"Montasola","state":"Lazio","country":"Italia","lng":"12.6880282","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/montasola\/fonte-vecchia\/","zoom":18,"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 Fonte Vecchia di Montasola \u00e8 un'antica fontana situata nel comune di Montasola, \u00c8 situata a ridosso della strada che conduce alla Madonna di Cottanello, ed \u00e8 un importante punto di riferimento per il paese.[\/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=\"3877\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/montasola\/\"][\/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%2FVia%2BFontevecchia%2C%2B1%2C%2B02040%2BMontasola%2BRI%2F%4042.3866019%2C12.6842171%2C17z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132f047477045ccb%3A0x8917117412f0778!8m2!3d42.386598!4d12.686792!16s%252Fg%252F11cs780t1f%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>Fonte <strong>Vecchia<\/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_1695313637432{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Fonte vecchia, 1\r\n02040 <strong>Montasola\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_1695313702438{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Sempre <strong>aperto<\/strong>[\/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]La Fonte Vecchia di Montasola \u00e8 un'antica fontana situata nel comune di Montasola, in provincia di Rieti, nel Lazio. \u00c8 situata a ridosso della strada che conduce alla Madonna di Cottanello, ed \u00e8 un importante punto di riferimento per il paese.\r\nIl manufatto denominato Fonte Vecchia risale a tempi antichissimi e, sia pure ristrutturata negli ultimi decenni, conserva un originalissimo disegno architettonico di chiss\u00e0 quale remoto ideatore.\r\nParticolarit\u00e0 principale il disegno delle fontanelle situato su due diversi livelli del terreno: una parte superiore \u00e8 costituita dalla cupola, quella inferiore da due vasche utilizzate come abbeveratoio e collegate alla prima da una terza vasca intermedia.\r\nSi tratta di un\u2019opera molto rara che merita l\u2019attenzione del turista per la sua originalit\u00e0 costruttiva. La Sabina \u00e8 arricchita da molte di queste opere giunte fino a noi attraverso il tempo e che costituiscono un patrimonio popolare unico ed irrepetibile. In un momento di rilancio e d\u2019interesse per le radici, la nostra terra merita particolare attenzione.[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Fonte Vecchia","post_link":"https:\/\/geosabina.it\/montasola\/fonte-vecchia\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Fonte Vecchia\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/09\/fonte-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_1695313637432{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1695313702438{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\":264,\"to_translate\":{\"en\":264}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Forcella, 21, 02040 Montasola RI, Italia","%_wpgmp_location_city%":"Montasola","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.3883892","%_wpgmp_metabox_longitude%":"12.6880282","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_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%":"8164","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Fonte vecchia","%_yoast_wpseo_metadesc%":"La Fonte Vecchia di Montasola \u00e8 un'antica fontana situata nel comune di Montasola situata a ridosso della strada che conduce alla Madonna di Cottanello, ed \u00e8 un importante punto di riferimento per il paese.","%_yoast_wpseo_linkdex%":"70","%_dp_original%":"5255","%_edit_lock%":"1727433547:4","%_edit_last%":"4","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Montasola","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/archeologia_sito.png"},"id":8148,"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 San Michele Arcangelo","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 San Michele Arcangelo\" width=\"300\" height=\"122\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/07\/geosabina-300x122.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\/montasola\/chiesa-san-michele-arcangelo\/\" class=\"fc-post-link\">Chiesa San Michele Arcangelo<\/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 Forcella, 21, 02040 Montasola RI, Italia","location":{"lat":"42.3860259","city":"Montasola","state":"Lazio","country":"Italia","lng":"12.6805253","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/montasola\/chiesa-san-michele-arcangelo\/","zoom":18,"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 di <strong>San Michele Arcangelo<\/strong> \u00e8 un edificio religioso situato nel comune di Montasola, in provincia di Rieti, nel Lazio. \u00c8 la pi\u00f9 antica chiesa del paese, risalente probabilmente al XII secolo.[\/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=\"3877\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/destinations\/montasola\/\"][\/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.com%2Fmaps%2Fplace%2Fsan%2BMichele%2BArcangelo%2F%4042.386001%2C12.6812784%2C18.5z%2Fdata%3D!4m6!3m5!1s0x132f0470c0df97b7%3A0xb10f32d422dfc5ad!8m2!3d42.3861315!4d12.6806547!16s%252Fg%252F11dxqjtp3r%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 San <strong>Michele Arcangelo<\/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_1654675460198{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Forcella, 21\r\n02040 <strong>Montasola\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_1698057499916{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Aperta durante le funzioni religiose\r\n\r\n[\/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]La chiesa di <strong>San Michele Arcangelo<\/strong> \u00e8 un edificio religioso situato nel comune di Montasola, in provincia di Rieti, nel Lazio. \u00c8 la pi\u00f9 antica chiesa del paese, risalente probabilmente al XII secolo.\r\nSituata in posizione dominante sul centro abitato, in un'area che era sede dell'antico castello di Montasola. L'edificio \u00e8 a navata unica con abside semicircolare, ed \u00e8 realizzato in pietrame locale. La facciata \u00e8 a capanna, con un portale centrale sormontato da un arco a sesto acuto. In alto, \u00e8 presente un rosone circolare.\r\nL'interno \u00e8 semplice e austero, L'altare maggiore \u00e8 dedicato a San Michele Arcangelo, e conserva una statua lignea del santo risalente al XVI secolo. Di particolare interesse \u00e8 la pila dell'acqua santa, in marmo con figure di animali e lo stemma pontificio scolpiti.\r\nAll\u2019interno conserva intatto il pavimento originale e un quadro della Madonna; ai lati si reggono le forme, incassate nel muro, di due altari, uno di rimpetto all\u2019altro: l\u2019altare di Santa Lucia sulla destra, con una bella tela dedicata alla santa ma da restaurare e quello di S. Maria Maddalena la penitente, sulla sinistra.\r\nLa chiesetta fu tenuta per anni quasi in abbandono: il tetto precipit\u00f2, e forse in quel periodo i quadri dei due altari scomparvero. Da non molto tempo sono stati eseguiti i necessari restauri grazie soprattutto ai proventi mandati da una comunit\u00e0 di Montasola che nei primi anni del secolo scorso emigr\u00f2 in Francia, nel paese di Annecy, ad indicarne l\u2019attaccamento alle loro radici e l\u2019affetto per i luoghi cari alle usanze e alla memoria. Nel pavimento si osservano i chiusini di due tombe e nella piccola sacrestia la pietra di un ossario.\r\nLa chiesa di San Michele Arcangelo \u00e8 oggi un importante testimonianza dell'architettura medievale nella Sabina e oggi \u00e8 un luogo di culto e di interesse storico-artistico.[\/vc_column_text][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Chiesa San Michele Arcangelo","post_link":"https:\/\/geosabina.it\/montasola\/chiesa-san-michele-arcangelo\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chiesa San Michele Arcangelo\" width=\"300\" height=\"122\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/07\/geosabina-300x122.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_1654675460198{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1698057499916{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\":415,\"to_translate\":{\"en\":415}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Forcella, 21, 02040 Montasola RI, Italia","%_wpgmp_location_city%":"Montasola","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.3860259","%_wpgmp_metabox_longitude%":"12.6805253","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_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","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Chiesa San Michele Arcangelo","%_yoast_wpseo_metadesc%":"La chiesa di San Michele Arcangelo \u00e8 un edificio religioso situato nel comune di Montasola, in provincia di Rieti, nel Lazio. \u00c8 la pi\u00f9 antica chiesa del paese, risalente probabilmente al XII secolo.","%_yoast_wpseo_linkdex%":"72","%_dp_original%":"5255","%_edit_lock%":"1704490948:1","%_edit_last%":"1","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% Montasola","%_thumbnail_id%":"8900","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/chiese_sito.png"},"id":8139,"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":"Abbazia di Farfa","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Abbazia di Farfa\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/11\/farfa-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\/altri-comuni\/abbazia-di-farfa\/\" class=\"fc-post-link\">Abbazia di Farfa<\/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 del Monastero, 1, 02032 Castelnuovo di Farfa RI, Italia","location":{"lat":"42.221594","city":"Fara in Sabina","state":"Lazio","country":"Italia","lng":"12.7180345","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/abbazia-di-farfa\/","zoom":18,"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'Abbazia di Farfa, situata nella pittoresca campagna italiana a circa 60 chilometri a nord-est di Roma, \u00e8 una delle abbazie benedettine pi\u00f9 antiche e importanti d'Italia. La sua storia affonda le radici nel VI secolo, quando un gruppo di monaci benedettini si stabil\u00ec in questo luogo remoto[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/intorno-a-te\/punti-da-non-perdere\/\"][vc_empty_space height=\"25px\"][\/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%2Fplace%2FAbbazia%2BDi%2BFarfa%2BUff.%2BParr.%2F%4042.2212651%2C12.7180842%2C20z%2Fdata%3D!4m19!1m12!4m11!1m6!1m2!1s0x132f0bf73a3d6c07%3A0xf8609d106d61956d!2sAbbazia%2BDi%2BFarfa%2BUff.%2BParr.%2C%2BVia%2Bdi%2BPorta%2BMontopoli%2C%2BFarfa%2C%2BRI!2m2!1d12.7180842!2d42.2212651!1m3!2m2!1d12.7185984!2d42.2216391!3m5!1s0x132f0bf73a3d6c07%3A0xf8609d106d61956d!8m2!3d42.2212651!4d12.7180842!16s%252Fg%252F11b6jggpsk%3Fhl%3Dit%26entry%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>Abbazia di <strong>Farfa<\/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_1716452225158{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via del Monastero, 1\r\n02032 <strong>Fara in Sabina<\/strong>\u00a0(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_1718533406916{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]<strong>Dal marted\u00ec alla domenica:<\/strong>\r\ndalle 10:00 alle 12:00 e dalle 15:30 alle 16.30[\/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>Info e prenotazioni <\/strong><\/h4>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][vc_btn title=\"Vai al sito web dell'abbazia\" color=\"chino\" size=\"xs\" align=\"left\" i_icon_fontawesome=\"fas fa-share-square\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.abbaziadifarfa.it%2F|target:_blank\" css=\".vc_custom_1699694672070{margin-top: 12px !important;}\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"40px\"][vc_column_text]L'Abbazia di Farfa, situata nella pittoresca campagna italiana a circa 60 chilometri a nord-est di Roma, \u00e8 una delle abbazie benedettine pi\u00f9 antiche e importanti d'Italia. La sua storia affonda le radici nel VI secolo, quando un gruppo di monaci benedettini si stabil\u00ec in questo luogo remoto, circondato da una natura rigogliosa e da colline verdi che sembrano abbracciare l'antico complesso monastico.\r\n\r\nL'abbazia di Farfa ha una storia ricca e complessa che si intreccia con quella dell'Italia medievale. Nel corso dei secoli, \u00e8 cresciuta in importanza diventando un centro di cultura, spiritualit\u00e0 e potere. I monaci di Farfa erano noti per la loro erudizione e per il loro impegno nella preservazione e nella trasmissione del sapere classico. La biblioteca dell'abbazia divenne famosa per la sua vasta collezione di manoscritti, che includevano opere di autori antichi e medievali.\r\n\r\nL'architettura dell'abbazia riflette lo stile romanico, con i suoi archi a tutto sesto, i portali decorati e gli affreschi che narrano storie sacre. Il campanile svetta nel cielo, una testimonianza silenziosa dei secoli di preghiere e devozione che si sono svolte all'interno di queste mura antiche. I chiostri, con i loro colonnati eleganti, sono luoghi di pace e contemplazione, dove i monaci potevano ritirarsi per pregare e meditare.[\/vc_column_text][vc_empty_space height=\"30px\"][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=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"9417,9415,9413,9411\"][vc_empty_space height=\"30px\"][vc_column_text]Nel corso dei secoli, l'abbazia di Farfa ha attraversato periodi di prosperit\u00e0 e declino, subendo danni durante le guerre e i conflitti. Tuttavia, la sua resilienza \u00e8 evidente nel suo continuo esistere attraverso i secoli, come un faro di spiritualit\u00e0 e storia in un mondo che cambia incessantemente.\r\n\r\nOggi, l'abbazia di Farfa \u00e8 aperta ai visitatori, offrendo loro l'opportunit\u00e0 di immergersi nella sua storia millenaria. I turisti possono passeggiare tra gli antichi chiostri, ammirare gli affreschi medievali e visitare la biblioteca che custodisce tesori letterari. Ogni angolo di questo luogo emana un'atmosfera di sacralit\u00e0 e mistero, catturando l'immaginazione di coloro che lo visitano.\r\n\r\nIn sintesi, l'Abbazia di Farfa rappresenta un'importante testimonianza del ricco patrimonio culturale e spirituale dell'Italia. La sua bellezza intramontabile e la sua storia affascinante la rendono un luogo unico, un ponte tra il passato e il presente, che continua a ispirare e incantare chiunque abbia la fortuna di varcare le sue soglie millenarie.[\/vc_column_text][vc_empty_space height=\"30px\"][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=\"no\" slider_pagination=\"no\" custom_class=\"gallery_app\" image_size=\"full\" images=\"12680,12682,12684,12686\"][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Abbazia di Farfa","post_link":"https:\/\/geosabina.it\/altri-comuni\/abbazia-di-farfa\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Abbazia di Farfa\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/11\/farfa-300x169.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1716452225158{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1718533406916{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_1699694672070{margin-top: 12px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":512,\"to_translate\":{\"en\":512}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via del Monastero, 1, 02032 Castelnuovo di Farfa RI, Italia","%_wpgmp_location_city%":"Fara in Sabina","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.221594","%_wpgmp_metabox_longitude%":"12.7180345","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:4:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"18\";i:3;s:2:\"24\";}","%_wpgmp_metabox_marker_id%":"a:3:{i:0;s:1:\"2\";i:1;s:1:\"4\";i:2;s:2:\"23\";}","%_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%":"6826","%_edit_lock%":"1727261961:2","%_edit_last%":"4","%_yoast_wpseo_focuskw%":"Abbazia di Farfa","%_yoast_wpseo_metadesc%":"L'Abbazia di Farfa, situata nella pittoresca campagna italiana a circa 60 chilometri a nord-est di Roma, \u00e8 una delle abbazie benedettine pi\u00f9 antiche e importanti d'Italia.","%_yoast_wpseo_linkdex%":"72","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"9775","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png"},"id":6982,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png","name":"Borghi e Centri Storici \/ Villages and Historical Centers","id":"2","type":"category","extension_fields":{"cat_order":"1"}},{"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"}},{"icon":"https:\/\/geosabina.it\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Riserva Naturale Regionale Tevere-Farfa","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Riserva Naturale Regionale Tevere-Farfa\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/11\/anteprima.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\/altri-comuni\/riserva-naturale-regionale-tevere-farfa\/\" class=\"fc-post-link\">Riserva Naturale Regionale Tevere-Farfa<\/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":"00060 Nazzano RM, Italia","location":{"lat":"42.2298563","city":"Nazzano","state":"Lazio","country":"Italia","lng":"12.5960617","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/riserva-naturale-regionale-tevere-farfa\/","zoom":18,"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 Riserva Naturale Tevere-Farfa ha una superficie di circa 700 ettari all\u2019interno dei comuni di Nazzano (Rm), Torrita Tiberina (Rm) e Montopoli in Sabina (Ri). La sua storia \u00e8 indissolubilmente legata alla costruzione di una diga artificiale[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/comuni-in-rete\/\"][vc_empty_space height=\"25px\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner][vc_column_inner][vc_empty_space height=\"40px\"][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%2FRiserva%2BNaturale%2BRegionale%2BNazzano%2BTevere-Farfa%2F%4042.2057422%2C12.608281%2C17.33z%2Fdata%3D!4m22!1m15!4m14!1m6!1m2!1s0x132f0ee62f010f87%3A0xefbad483e0df959a!2sPoggio%2BMirteto%2C%2B02047%2BRI!2m2!1d12.6876246!2d42.2682668!1m6!1m2!1s0x132f1273e1cd8901%3A0xf094f9bab213bb0!2sRiserva%2BNaturale%2BRegionale%2BNazzano%2BTevere-Farfa%2C%2BS.P.%2BTiberina%2Bkm%2B28%2C100%2C%2Blocalit%25C3%25A0%2BMeana%2C%2B00060%2BNazzano%2BRM!2m2!1d12.607681!2d42.2055991!3m5!1s0x132f1273e1cd8901%3A0xf094f9bab213bb0!8m2!3d42.2055991!4d12.607681!16s%252Fg%252F1227d3gg%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>Riserva Naturale Regionale <strong>Tevere-Farfa<\/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_1659016481659{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Nazzano, RM, Italia[\/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\"][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_1695379285103{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]<strong>DALLA DIGA \u2026.. UN\u2019 AREA PROTETTA<\/strong>\r\nLa Riserva Naturale Tevere-Farfa ha una superficie di circa 700 ettari all\u2019interno dei comuni di Nazzano (Rm), Torrita Tiberina (Rm) e Montopoli in Sabina (Ri). La sua storia \u00e8 indissolubilmente legata alla costruzione di una diga artificiale da parte dell\u2019Enel tra il 1953 e il 1955 e alla morfologia del Tevere, che in questo tratto scorre lentamente formando ampie anse e meandri.\r\nIl pi\u00f9 lento scorrimento delle acque fluviali e la confluenza del torrente Farfa hanno infatti creato il lago di Nazzano che nel corso degli anni si \u00e8 popolato di specie di flora e fauna tipiche delle zone umide. Gradualmente salici, pioppi e ontani hanno colonizzato le sponde del bacino realizzando uno dei pochi esempi di \u201cbosco ripariale\u201d presente nel Lazio, mentre la cannuccia di palude e la tifa hanno rivestito i banchi di detrito che con il tempo si sono accumulati presso le rive o al centro del lago, formando dei caratteristici isolotti\r\n\r\n<strong>L\u2019 AMBIENTE NATURALE<\/strong>\r\nLa valle fluviale, tipicamente alluvionale con depositi d\u2019argille, sabbie e ghiaie, \u00e8 delimitata da colline di modeste dimensioni costituite da sedimenti d\u2019origine marina. La ricca presenza d\u2019uccelli nell\u2019ambiente lacustre costituisce uno dei motivi di maggior interesse per i visitatori.\r\nOltre agli anatidi, come il germano reale, l\u2019alzavola, il fischione e la moretta, \u00e8 possibile osservare lo svasso maggiore, la folaga, il martin pescatore e rapaci come il falco di palude e il falco pescatore. Il canneto, costituito prevalentemente dalla cannuccia e dalla tifa, \u00e8 talvolta impreziosito dalla gialla fioritura dell\u2019iris di palude, mentre sui terreni argillosi, tra le radici dei salici bianchi e rossi, troviamo la bardana e l\u2019equiseto dalla tipica forma a ferro di cavallo[\/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_video link=\"https:\/\/youtu.be\/l96wxeTT-Fc\"][vc_empty_space height=\"25px\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"Riserva Naturale Regionale Tevere-Farfa","post_link":"https:\/\/geosabina.it\/altri-comuni\/riserva-naturale-regionale-tevere-farfa\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Riserva Naturale Regionale Tevere-Farfa\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/11\/anteprima.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1659016481659{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_1695379285103{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\":409,\"to_translate\":{\"en\":409}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"00060 Nazzano RM, Italia","%_wpgmp_location_city%":"Nazzano","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2298563","%_wpgmp_metabox_longitude%":"12.5960617","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:4:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"8\";i:3;s:2:\"20\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"23\";}","%_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%":"4687","%_dp_original%":"6826","%_edit_lock%":"1720193707:6","%_edit_last%":"4","%_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\" allowfullscreen><\/iframe>","%_oembed_time_7b6459f1c42c0443573e9f4033c19060%":"1659016765","%_yoast_wpseo_focuskw%":"Riserva Naturale Regionale Tevere-Farfa","%_yoast_wpseo_metadesc%":"La Riserva Naturale Tevere Farfa \u00e8 famosa per la sua bellezza paesaggistica e la ricchezza della fauna e flora. Questo luogo incantevole offre agli amanti della natura una vasta gamma di ecosistemi, attrazioni naturali e attivit\u00e0 all'aperto.","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/bellezze-naturali_sito.png"},"id":6975,"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\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","name":"Punti da non perdere","id":"23","type":"category","extension_fields":{"cat_order":"2"}}]},{"source":"post","title":"Rocchette e Rocchettine","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rocchette e Rocchettine\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/10\/rocchettine--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\/altri-comuni\/rocchette-e-rocchettine\/\" class=\"fc-post-link\">Rocchette e Rocchettine<\/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 Martino Porta, 28, 02049 Rocchette RI, Italia","location":{"lat":"42.37469","city":"Torri in Sabina","state":"Lazio","country":"Italia","lng":"12.625652","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/altri-comuni\/rocchette-e-rocchettine\/","zoom":18,"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]<strong>Rocchette e Rocchettine<\/strong>, sorgono come sentinelle silenziose che una volta presidiavano strategicamente la via tra la Valle del Tevere e la Piana di Rieti. Rocchette, originariamente nota come <strong>Rocca Bertalda.<\/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 gap=\"20\" 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=\"6151\" img_size=\"full\" onclick=\"custom_link\" css_animation=\"none\" link=\"https:\/\/geosabina.it\/intorno-a-te\/punti-da-non-perdere\/\"][vc_empty_space height=\"25px\"][\/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%2Fplace%2FRuderi%2Bdi%2BRocchettine%2F%4042.3731889%2C12.6243858%2C16.75z%2Fdata%3D!4m16!1m9!4m8!1m6!1m2!1s0x132f04cb966629c9%3A0xbaa496e5591c3788!2sRocchette%2C%2BRI!2m2!1d12.625568!2d42.3748031!1m0!3m5!1s0x132f04cc6a77a5f3%3A0x7db24e52d2bfb761!8m2!3d42.3726779!4d12.6256943!16s%252Fg%252F11c31r1ms8%3Fhl%3Dit%26entry%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>Rocchette e <strong>Rocchettine<\/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_1659016234589{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Via Martino Porta, 28\r\n02049 <strong>Rocchette<\/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_1697528085330{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}\"]Sempre aperto\r\n\r\n[\/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_1658933067764{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]Questi due borghi medievali nel cuore della Sabina, sono testimonianza di un passato ricco di avvenimenti e fascino intramontabile.\r\n\r\n<strong>Rocchette e Rocchettine<\/strong>, sorgono come sentinelle silenziose che una volta presidiavano strategicamente la via tra la Valle del Tevere e la Piana di Rieti. Rocchette, originariamente nota come <strong>Rocca Bertalda<\/strong>, oggi mantiene viva l'antica tradizione come centro rurale. Le sue stradine lastricate e le mura imponenti che si affacciano sulla valle sono testimonianza di un passato di difesa e orgoglio. Nonostante l'evoluzione nel tempo, Rocchette ha saputo conservare l'autenticit\u00e0 medievale, offrendo ai visitatori un tuffo nel passato con ogni pietra e vicolo.\r\n\r\nD'altra parte, Rocchettine, conosciuta anche come <strong>Rocca Guidonesca<\/strong>, vive nell'ombra del suo passato glorioso. Questo borgo, un tempo sotto il controllo dei Savelli e degli Orsini, \u00e8 ora un borgo fantasma. Tuttavia, nonostante la sua desolazione, Rocchettine \u00e8 un luogo affascinante da esplorare. Accedervi \u00e8 come fare un salto indietro nel tempo, vagando tra le rovine e cercando di immaginare la vita che un tempo animava queste strade.\r\n\r\nUn elemento che unisce queste due localit\u00e0 \u00e8 la loro eredit\u00e0 storica. Entrambe le fortezze, un tempo di propriet\u00e0 della Diocesi Sabina, hanno attraversato epoche di cambiamenti e trasformazioni. La chiesa di<strong> San Lorenzo<\/strong> a Rocchettine, ristrutturata nel 1700, \u00e8 l'unico edificio ancora in piedi e rappresenta una testimonianza toccante della devozione di un tempo.\r\n\r\nOggi, Rocchette e Rocchettine sono pi\u00f9 di semplici frammenti di storia. Sono una finestra aperta sul passato, una lezione sulla resilienza e l'adattamento nel corso dei secoli. Ogni pietra racconta una storia, ogni vicolo nasconde segreti antichi, rendendo questi borghi non solo luoghi da visitare ma anche esperienze da vivere. Per chiunque ami l'atmosfera suggestiva dei borghi medievali, Rocchette e Rocchettine offrono un viaggio nel tempo, una passeggiata tra le rovine del passato che continua a incantare e ispirare.[\/vc_column_text][vc_empty_space height=\"80px\"][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_1712855447670{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>Cascate a Rocchette e Rocchettine.<\/b><\/h4>\r\nLe Cascate di Rocchette e Rocchettine sono situate nel territorio della Riserva Naturale Regionale Montagne della Duchessa.\r\n\r\nLe cascate sono formate dal fiume Rio della Rocchetta e offrono uno spettacolo naturale suggestivo, soprattutto durante i periodi di maggiore flusso d'acqua, come dopo piogge abbondanti o nel periodo primaverile durante lo scioglimento delle nevi.\r\n\r\nL'area circostante \u00e8 anche nota per le sue bellezze naturali e offre opportunit\u00e0 per escursioni e attivit\u00e0 all'aperto. Le cascate di Rocchette e Rocchettine sono un luogo popolare per gli amanti della natura e per coloro che cercano una pausa rilassante dal trambusto della vita quotidiana.[\/vc_column_text][vc_empty_space height=\"30px\"][\/vc_column_inner][\/vc_row_inner][\/vc_column][\/vc_row]","post_title":"Rocchette e Rocchettine","post_link":"https:\/\/geosabina.it\/altri-comuni\/rocchette-e-rocchettine\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rocchette e Rocchettine\" width=\"300\" height=\"169\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2023\/10\/rocchettine--300x169.png\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_wpb_shortcodes_custom_css%":".vc_custom_1659016234589{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1697528085330{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_1658933067764{border-left-width: 3px !important;padding-left: 10px !important;border-left-color: #81d742 !important;border-left-style: solid !important;}.vc_custom_1712855447670{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\":512,\"to_translate\":{\"en\":512}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via Martino Porta, 28, 02049 Rocchette RI, Italia","%_wpgmp_location_city%":"Torri in Sabina","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.37469","%_wpgmp_metabox_longitude%":"12.625652","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:5:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:2:\"18\";i:3;s:2:\"20\";i:4;s:2:\"23\";}","%_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%":"9440","%_dp_original%":"6826","%_edit_lock%":"1720193814:6","%_edit_last%":"4","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Rocchette e Rocchettine","%_yoast_wpseo_metadesc%":"Nel cuore della pittoresca Sabina nel Lazio, si trovano Rocchette e Rocchettine, due antichi borghi medievali che un tempo dominavano la strada che collegava la Valle del Tevere alla Piana di Rieti.","%_yoast_wpseo_linkdex%":"69","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png"},"id":6970,"infowindow_disable":false,"categories":[{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/borghi_sito.png","name":"Borghi e Centri Storici \/ Villages and Historical Centers","id":"2","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"ITINERARIO | Stimigliano \u2013 Forano e Oasi Tevere Farfa","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 | Stimigliano \u2013 Forano e Oasi Tevere Farfa\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/07\/itinerari-logo-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\/itinerari\/stimigliano-forano-e-oasi-tevere-farfa\/\" class=\"fc-post-link\">ITINERARIO | Stimigliano \u2013 Forano e Oasi Tevere Farfa<\/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":"02048 Stimigliano RI, Italia","location":{"lat":"42.3009899","city":"Stimigliano","state":"Lazio","country":"Italia","lng":"12.5628575","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/itinerari\/stimigliano-forano-e-oasi-tevere-farfa\/","zoom":18,"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]Partendo da Roma si prende l\u2019A1 verso Orte, si esce a Ponzano-Soratte, direzione SR657 verso Stimigliano. Sono circa 7 km, in poco pi\u00f9 di 10 minuti si arriva al paese. Il paese di Stimigliano \u00e8 chiamato \u201cla Porta della Sabina\u201d, \u00e8 infatti il primo paese che si incontra prima di Roma, uscendo dall\u2019autostrada. E\u2019 raccolto intorno all\u2019imponente Palazzo Baronale della famiglia Orsini, opera costruito e ampliato, in varie fasi, durante il XVI secolo. Si possono trovare all\u2019interno del Palazzo, dipinti dei seguaci di Taddeo e Federcio Zuccari, con immagini che riproducono la vita di Giuseppe e Maria. Il bellissimo borgo medievale \u00e8 impreziosito dalla chiesa di SS. Cosma e Damiano e la chiesa di San Valentino. Dal paese \u00e8 possibile ammirare buona parte della Bassa Sabina e le curve dolci del Tevere.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/4\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-sm vc_hidden-xs\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_single_image image=\"9189\" 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 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_1696326193021{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 in Auto e 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_1696326261455{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;\">3<\/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_1696326280823{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_1696326295906{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_1696929147312{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;\">Stimigliano<\/span><\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"3\/4\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Stimigliano \u2013 Forano e <strong>Oasi Tevere Farfa<\/strong><\/h2>\r\n[\/vc_column_text][vc_column_text css=\".vc_custom_1696926701890{margin-top: -20px !important;}\"]\r\n<h5>Itinerario Naturalistico<\/h5>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h5>Nella campagna sabina le bellezze si alternano tra il naturale e l\u2019artistico. In particolare in questa proposta di itinerario, si prevedono tre incantevoli paesi che si affacciano sulla <strong>vallata del Tevere<\/strong> e dai quali si raggiunge la meravigliosa <strong>Oasi Tevere Farfa<\/strong>.<\/h5>\r\n[\/vc_column_text][vc_tta_tour shape=\"square\" color=\"green\" spacing=\"20\" gap=\"15\" active_section=\"1\" no_fill_content_area=\"true\" title=\"Itinerario\"][vc_tta_section title=\"TAPPA 1\" tab_id=\"1696344647582-eada1aca-2c3555e5-7010\"][vc_column_text]Partendo da Roma si prende l\u2019A1 verso Orte, si esce a Ponzano-Soratte, direzione SR657 verso Stimigliano. Sono circa 7 km, in poco pi\u00f9 di 10 minuti si arriva al paese. Il paese di Stimigliano \u00e8 chiamato \u201cla Porta della Sabina\u201d, \u00e8 infatti il primo paese che si incontra prima di Roma, uscendo dall\u2019autostrada. E\u2019 raccolto intorno all\u2019imponente Palazzo Baronale della famiglia Orsini, opera costruito e ampliato, in varie fasi, durante il XVI secolo. Si possono trovare all\u2019interno del Palazzo, dipinti dei seguaci di Taddeo e Federcio Zuccari, con immagini che riproducono la vita di Giuseppe e Maria. Il bellissimo borgo medievale \u00e8 impreziosito dalla chiesa di SS. Cosma e Damiano e la chiesa di San Valentino. Dal paese \u00e8 possibile ammirare buona parte della Bassa Sabina e le curve dolci del Tevere.[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 1\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.com%2Fmaps%2Fplace%2F02048%2BStimigliano%2BRI%2F%4042.2791617%2C12.58497%2C13z%2Fdata%3D!4m22!1m15!4m14!1m6!1m2!1s0x132f10ee2a48fabf%3A0x3c10322da6d471f3!2sStimigliano%2C%2BRI!2m2!1d12.5628575!2d42.3009899!1m6!1m2!1s0x132f0ee62f010f87%3A0xefbad483e0df959a!2sPoggio%2BMirteto%2C%2BRI!2m2!1d12.6876246!2d42.2682668!3m5!1s0x132f10ee2a48fabf%3A0x3c10322da6d471f3!8m2!3d42.3009899!4d12.5628575!16s%252Fg%252F11bc6h2mln%3Fhl%3Dit%26entry%3Dttu|target:_blank\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Vai alla scheda del comune di Stimigliano\" style=\"outline\" shape=\"square\" color=\"warning\" i_align=\"right\" i_icon_fontawesome=\"far fa-file-alt\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Fdestinations%2Fstimigliano%2F\"][\/vc_column_inner][\/vc_row_inner][\/vc_tta_section][vc_tta_section title=\"TAPPA 2\" tab_id=\"1696344647611-95d2120a-896255e5-7010\"][vc_column_text]<strong>Da Stimigliano ci spostiamo a Forano<\/strong>, tornando sulla strada SR657 e lasciando l\u2019autostrada sulla destra, alla prima rotonda, si sale verso il paese. Forano \u00e8 un piccolo nucleo che ha una storia assai lontana, ci sono infatti testimonianze di stanziamenti sabini gi\u00e0 a partire dal IX secolo a.C. A partire dalla caduta dell\u2019Impero Romano, le campagne si spopolano e nei secoli a venire il paese assorbe le identit\u00e0 dei signori locali, sino a diventare Libero comune nel 1262. Il suggestivo Palazzo Ducale, edificato intorno al XIII secolo, sovrasta i ruderi dell\u2019antica Rocca. Numerose le chiese: la S.S. Trinit\u00e0 e Maria Assunta, edificata alla fine del XVII secolo, l\u2019ottocentesca Chiesa Evangelica Valdese e la Chiesa di San Sebastiano. Incantevole il Parco della Rimembranza, dedicato ai caduti della Prima Guerra Mondiale, risalente al 1925.\r\n\r\nLa piccola frazione di <strong>Gavignano<\/strong> \u00e8 un nucleo, piccolo ma importante dal punto di vista archeologico, sono presenti infatti tracce di mura di epoca romana.\r\n\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 2\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.com%2Fmaps%2Fplace%2F02044%2BForano%2BRI%2F%4042.2998686%2C12.5847013%2C15z%2Fdata%3D!3m1!4b1!4m6!3m5!1s0x132f1046b8fcd0d7%3A0xed04d45627f43e2c!8m2!3d42.2952897!4d12.5951416!16zL20vMGdtNWdq%3Fhl%3Dit%26entry%3Dttu|target:_blank\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Vai alla scheda del comune di Forano\" style=\"outline\" shape=\"square\" color=\"warning\" i_align=\"right\" i_icon_fontawesome=\"far fa-file-alt\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Fdestinations%2Ftarano%2F\"][\/vc_column_inner][\/vc_row_inner][\/vc_tta_section][vc_tta_section title=\"TAPPA 3\" tab_id=\"1696344891500-aa2c7edd-9eb655e5-7010\"][vc_column_text]Il nostro itinerario volge al termine, concludendosi nelle affascinanti abbracci della natura, nell\u2019<strong>Oasi Tevere Farfa<\/strong>. Sempre sulla SR657, direzione Poggio Mirteto; arrivati alla Stazione ferroviaria, si prosegue verso Roma e alla prima rotonda si svolta decisamente a destra. Dal ponte in poi ci sono varie possibilit\u00e0: subito sotto il ponte a sinistra inizia un percorso sterrato che si pu\u00f2 percorrere anche in bicicletta. Dopo il ponte, specularmente, si trova un piccolo attracco dal quale iniziare una piacevole passeggiata. Se si prosegue oltre, direzione Nazzano, potrete trovare la segnaletiche per altri percorsi nel parco.La Riserva \u00e8 una mirabile estensione di 700 ettari di boschi e radure, con Pioppi, Salici e Ontani e tante altre variet\u00e0 che seguono il percorso del Tevere.\r\n\r\nLa passeggiata termina nella Riserva, con i profumi della natura e delle bellezze della <strong>Bassa Sabina<\/strong>. Un assaggio che prelude a tante altre scoperte.[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 3\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.com%2Fmaps%2F%4042.2356096%2C12.6270884%2C3a%2C75y%2C97.39h%2C81.49t%2Fdata%3D!3m6!1e1!3m4!1sBcppBg4eVpVYJVtH_rCM9g!2e0!7i13312!8i6656%3Fhl%3Dit%26entry%3Dttu|target:_blank\"][\/vc_column_inner][vc_column_inner width=\"1\/2\" offset=\"vc_hidden-lg vc_hidden-md vc_hidden-sm vc_hidden-xs\"][vc_btn title=\"Vai alla scheda del Santuario di Vescovio\" style=\"outline\" shape=\"square\" color=\"warning\" i_align=\"right\" i_icon_fontawesome=\"far fa-file-alt\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Faltri-comuni%2Fvescovio-area-archeologica-forum-novum-e-santuario%2F\"][\/vc_column_inner][\/vc_row_inner][\/vc_tta_section][\/vc_tta_tour][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row][vc_row][vc_column][vc_empty_space height=\"50px\"][\/vc_column][\/vc_row]","post_title":"ITINERARIO | Stimigliano \u2013 Forano e Oasi Tevere Farfa","post_link":"https:\/\/geosabina.it\/itinerari\/stimigliano-forano-e-oasi-tevere-farfa\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"ITINERARIO | Stimigliano \u2013 Forano e Oasi Tevere Farfa\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/07\/itinerari-logo-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_1696326193021{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696326261455{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696326280823{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696326295906{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696929147312{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696926701890{margin-top: -20px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":618,\"to_translate\":{\"en\":618}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"02048 Stimigliano RI, Italia","%_wpgmp_location_city%":"Stimigliano","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.3009899","%_wpgmp_metabox_longitude%":"12.5628575","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"3\";i:1;s:2:\"16\";i:2;s:2:\"17\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:2:\"19\";i:1;s:2:\"22\";}","%_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%":"6920","%_wpb_post_custom_css%":".itinerari {\r\n    width:100%;\r\n    max-width:300px;\r\n}","%_dp_original%":"6908","%_edit_lock%":"1706196069:6","%_edit_last%":"6","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Stimigliano \u2013 Forano e Oasi Tevere Farfa","%_yoast_wpseo_metadesc%":"Nella campagna sabina le bellezze si alternano tra il naturale e l\u2019artistico. In particolare in questa proposta di itinerario, si prevedono tre incantevoli paesi che si affacciano sulla vallata del Tevere e dai quali si raggiunge la meravigliosa Oasi Tevere Farfa.","%_yoast_wpseo_linkdex%":"56","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-artistici_sito.png"},"id":6957,"infowindow_disable":false,"categories":[{"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"}},{"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari-artistici_sito.png","name":"Itinerari Artistici \/ Artistic Itineraries","id":"22","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"ITINERARIO | Verso il monte Tancia in Mountain Bike","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 | Verso il monte Tancia in Mountain Bike\" 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\/itinerari\/verso-il-monte-tancia-in-mountain-bike\/\" class=\"fc-post-link\">ITINERARIO | Verso il monte Tancia in Mountain Bike<\/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 del Borgo, 23, 02034 Bocchignano RI, Italia","location":{"lat":"42.254903980586214","city":"Montopoli di Sabina","state":"Lazio","country":"Italia","lng":"12.70134783352126","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/itinerari\/verso-il-monte-tancia-in-mountain-bike\/","zoom":18,"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]A Bocchignano si arriva percorrendo la Salario sino al km 35,9, poi si gira per Poggio Mirteto (Sp 313). Al km 10,2, localit\u00e0 Colonnetta, si svolta a destra (Sp 42) indicazioni per Salisano. Superata la localit\u00e0 Granari, in direzione Farfa, al km 14 si svolta a sinistra per Bocchignano.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/4\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-sm vc_hidden-xs\"][vc_empty_space height=\"20px\"][vc_empty_space height=\"20px\"][vc_single_image image=\"9189\" 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 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_1696326193021{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 in Auto e 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_1697447772264{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;\">2<\/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_1697448963968{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;\">Circa 4 ore<\/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_1697448057055{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;\">Media<\/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_1697448100798{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;\">Bocchignano<\/span><\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"3\/4\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Verso il monte Tancia <strong>in Mountain Bike<\/strong><\/h2>\r\n[\/vc_column_text][vc_column_text css=\".vc_custom_1697447705574{margin-top: -20px !important;}\"]\r\n<h5>Itinerario Naturalistico<\/h5>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_column_text]<strong>DESCRIZIONE<\/strong>\r\nItinerario di media difficolt\u00e0 nei monti Sabini, tra Salisano e Poggio Catino, passando per il monte Tancia. Il percorso si alterna tra sterrato e asfaltato, ma poco frequentato.\r\n\r\n<strong>COME ARRIVARE<\/strong>\r\nA Bocchignano si arriva percorrendo la Salario sino al km 35,9, poi si gira per Poggio Mirteto (Sp 313). Al km 10,2, localit\u00e0 Colonnetta, si svolta a destra (Sp 42) indicazioni per Salisano. Superata la localit\u00e0 Granari, in direzione Farfa, al km 14 si svolta a sinistra per Bocchignano.\r\n\r\n<strong>ITINERARIO<\/strong>\r\nKm 3,0 \u2013 391 mslmKm 0,0 \u2013 175 mslm\r\nIl punto di partenza \u00e8 il bivio sulla provinciale per Salisano in corrispondenza di una chiesa. Si imbocca la sterrata in salita \u2013 via piedimonte \u2013 a destra della chiesa che sale verso S. Valentino di Poggio Mirteto\r\nKm 0,6 \u2013 245 mslm\r\nSi prosegue sulla sinistra in salita alternando ripide rampe cementate a tratti di sterrato. Al km 1 si supera un cancello\r\nKm 1,1 \u2013 285 mslm\r\nIn corrispondenza di una casa si prosegue tenendo la sinistra\r\nKm 2,6 \u2013 364 mslm\r\nAl bivio si gira a sinistra su asfalto\r\n\r\nSuperata una ripida rampa si incrocia un\u2019altra strada e si gira a destra. Dopo 900 m in corrispondenza di una brusca curva a destra, l\u2019asfalto lascia il posto allo sterrato che sale nel bosco\r\n\r\nKm 6,1 \u2013 636 mslm\r\nSi incontra un bivio caratterizzato da un grosso cartello in legno illeggibile. Si continua sulla destra\r\nKm 7,3 \u2013 634 mslm\r\nAl bivio si prosegue sulla sinistra\r\n\r\nKm 7,6 \u2013 648 mslm\r\nIn localit\u00e0 \u201cCasale Ferri\u201d si incontra un\u2019altra sterrata. Si prende a sinistra e si pedala per 1 km su buon fondo pianeggiante\r\n\r\nKm 8,7 \u2013 626 mslm\r\nGiunti sulla strada provinciale si gira a destra su asfalto. Nel primo km si affrontano alcuni saliscendi. Superato un ponticello \u2013 dove \u00e8 possibile fare una deviazione a piedi alla grotta di S. Michele (15 min) \u2013 la pendenza si fa sentire\r\n\r\nKm 11,7 \u2013 784 mslm\r\nArrivati alla sella, punto pi\u00f9 alto della giornata, si gira a destra su sterrato passando accanto all\u2019antica Osteria del Tancia, oggi riadattata ad ostello. Come scritto sui cartelli da qui passava, fino al secolo scorso, una importante via di comunicazione\r\n\r\nKm 12,1 792 mslm\r\nAl bivio si prende la sterrata di destra. Si guadagna ancora quota per poi iniziare la lunga discesa verso Salisano. Si passa accanto ad un casale con area attrezzata e si entra nel bosco. Verso il paese si incontra nuovamente l\u2019asfalto\r\nKm 19,2 \u2013 416 mslm\r\nAll\u2019incrocio si tralascia di entrare in paese e si gira a sinistra in discesa\r\n\r\nKm 19,7 \u2013 389 mslm\r\nArrivati sulla provinciale si gira a destra. In 8 km si ritorna velocemente a Bocchignano. Volendo evitare il traffico di camion, particolarmente pesante nei giorni feriali, conviene deviare come appresso descritto\r\nKm 22,1 \u2013 291 mslm\r\nSi lascia la provinciale e si gira a sinistra su via roccabaldesca in discesa\r\n\r\nKm 22,2 \u2013 288 mslm\r\nDopo pochi metri girare a destra su via rocca. Un paio di ripide discese ci portano nella piana\r\n\r\nKm 25,9 \u2013 112 mslm\r\nSi ritrova la strada principale. Si gira a destra e in leggera salita si ritorna a Bocchignano in un paio di km\r\n\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_btn title=\"Vai al punto di partenza\" 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%2FBocchignano%2C%2BRieti%2F42.2550455%2C12.7029108%2F%4042.2548569%2C12.7012942%2C17.75z%2Fdata%3D!4m8!4m7!1m5!1m1!1s0x132f0ec7e4c0e255%3A0xa094f9d5b9f18d0!2m2!1d12.7027399!2d42.2555611!1m0%3Fhl%3Dit%26entry%3Dttu\" el_id=\"bottoneindicazioni\"][vc_empty_space height=\"40px\"][\/vc_column][\/vc_row]","post_title":"ITINERARIO | Verso il monte Tancia in Mountain Bike","post_link":"https:\/\/geosabina.it\/itinerari\/verso-il-monte-tancia-in-mountain-bike\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"ITINERARIO | Verso il monte Tancia in Mountain Bike\" 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_1696326193021{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1697447772264{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1697448963968{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1697448057055{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1697448100798{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1697447705574{margin-top: -20px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":682,\"to_translate\":{\"en\":682}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"Via del Borgo, 23, 02034 Bocchignano RI, Italia","%_wpgmp_location_city%":"Montopoli di Sabina","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.254903980586214","%_wpgmp_metabox_longitude%":"12.70134783352126","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"3\";i:1;s:2:\"16\";i:2;s:2:\"17\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;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","%_wpb_post_custom_css%":".itinerari {\r\n    width:100%;\r\n    max-width:300px;\r\n}","%_dp_original%":"6930","%_edit_lock%":"1706196277:6","%_edit_last%":"6","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Verso il monte Tancia in Mountain Bike","%_yoast_wpseo_metadesc%":"Benvenuti in un'avventura in mountain bike attraverso le pittoresche montagne della Sabina, un tesoro nascosto nel cuore dell'Italia.","%_yoast_wpseo_linkdex%":"60","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari_sito.png"},"id":6952,"infowindow_disable":false,"categories":[{"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":"ITINERARIO | Colle Cosimo, Colle Capanne e Monte Morrone","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 | Colle Cosimo, Colle Capanne e Monte Morrone\" 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\/itinerari\/colle-cosimo-colle-capanne-e-monte-morrone\/\" class=\"fc-post-link\">ITINERARIO | Colle Cosimo, Colle Capanne e Monte Morrone<\/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 RI, Italia","location":{"lat":"42.2752902","city":"Poggio Mirteto","state":"Lazio","country":"Italia","lng":"12.6922343","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/itinerari\/colle-cosimo-colle-capanne-e-monte-morrone\/","zoom":18,"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 natura della sabina \u00e8 una natura meravigliosa, a tratti selvaggia e incontaminata, i piccoli paesi che circondano le campagne e i monti, incorniciano la fastosit\u00e0 del paesaggio; le stagioni sono l\u2019espressione vivida di fioriture e raccolti.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/4\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-sm vc_hidden-xs\"][vc_empty_space height=\"20px\"][vc_single_image image=\"9189\" img_size=\"full\" alignment=\"center\" onclick=\"custom_link\" el_class=\"itinerari\" link=\"https:\/\/geosabina.it\/itinerari\/\"][vc_empty_space height=\"20px\"][\/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_1696587101819{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 in Auto e 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_1696587139913{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_1696587211690{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;\">2.30 h<\/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_1696587220410{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_1696587235947{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;\">Poggio Mirteto<\/span><\/strong>[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][\/vc_column][vc_column width=\"3\/4\"][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Colle Cosimo, Colle Capanne e <strong>Monte Morrone<\/strong><\/h2>\r\n[\/vc_column_text][vc_column_text css=\".vc_custom_1706195357694{margin-top: -20px !important;}\"]\r\n<h5>Itinerario Naturalistico<\/h5>\r\n[\/vc_column_text][vc_empty_space height=\"40px\"][vc_column_text]La natura della sabina \u00e8 una natura meravigliosa, a tratti selvaggia e incontaminata, i piccoli paesi che circondano le campagne e i monti, incorniciano la fastosit\u00e0 del paesaggio; le stagioni sono l\u2019espressione vivida di fioriture e raccolti. Molte le colline e alture che si possono scorgere e con poco sforzo raggiungere in auto per poi proseguire a piedi per sentieri e boschi. In questa selezione di itinerari dedicati ai monti, ne abbiamo previsti alcuni, per incuriosire e per dare l\u2019input a una pi\u00f9 vasta possibilit\u00e0 di percorsi e viaggi. La forza del paesaggio sabino rapisce e gratifica, donando respiro e sollievo, come una cura ai mali del progresso e del quotidiano, si rallenta e si osserva l\u2019intorno, come a volersi immergere nei colori e nella leggerezza.\r\n\r\nIl primo itinerario prevede due colli e un monte: Colle Cosimo, Colle Capanne e Monte Morrone.\r\n\r\n<strong>Dislivello<\/strong>: 270 metri circa\r\n\r\n<strong>Indumenti<\/strong>: Scarponi, giacca a vento, cappello, indumenti antipioggia (eventuale ricambio completo), acqua da bere\r\n\r\nLe alture interessate costituiscono la vera \u201cporta\u201d d\u2019ingresso sul versante SO. Molto interessante come itinerario poich\u00e9 comprende quasi tutte le fasce climatiche. Anche se ben ombreggiato e sconsigliato in piena estate o nei periodi di siccit\u00e0. Non ci sono fontanili.\r\n\r\n<strong>Itinerario<\/strong>\r\n\r\nIn auto da Poggio Mirteto si sale verso la frazione di San Valentino, percorrendo la strada asfaltata. Quando la strada asfaltata termina, proprio in corrispondenza di un tornante sulla destra (con slargo e fontanile), inizia una strada bianca, l\u00e0 potete parcheggiare l\u2019auto e proseguire a piedi. Siamo a quota 494 m s.l.m.\r\n\r\nSi continua sulla strada bianca per qualche decina di metri. Sulla sinistra si potr\u00e0 intravedere un sentiero sassoso in salita, all\u2019interno di un bosco di lecci. Si prende il sentiero e dopo circa 15 minuti di passeggiata si arriva su una sella erbosa con radura. Si prosegue in discesa, sempre sul sentiero sassoso, si giunge a un fosso. Si oltrepassa il fosso e si arriva ad un trivio. Si prende il sentiero centrale che sale obliquo verso sinistra e dopo circa 30 minuti si incrocia la strada bianca che si era lasciata all\u2019inizio. Immediatamente dopo, sulla sinistra, una larga mulattiera sale verso la cresta sud di Colle Capanne. Verso sud si pu\u00f2 ammirare la valle del Tevere e si scorge la catena dei Monti Lecretili. Al culmine di Colle Capanne (circa 50 minuti) si ridiscende verso ovest, si segue una recinzione, lasciandosi la macchia boschiva sempre sulla destra. Si arriva a una vasta zona aperta e si prosegue tra radure, zone boschive e macchia mista. Finalmente si arriva all\u2019anticima di Monte Morrone. Proseguendo per circa un\u2019ora e venti, si arriva alla cima vera e propria di Monte Morrone.\r\n\r\n(si ringrazia Alberto Casazza che con il suo prezioso libro di itinerari sabini ha contribuito alla realizzazione di questo percorso)[\/vc_column_text][vc_empty_space height=\"40px\"][vc_row_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Indicazioni stradali punto di partenza tappa 1\" style=\"outline\" shape=\"square\" color=\"green\" i_align=\"right\" i_icon_fontawesome=\"fas fa-route\" add_icon=\"true\" link=\"url:https%3A%2F%2Fwww.google.com%2Fmaps%2Fplace%2F02047%2BSan%2BValentino%2BRI%2F%4042.2717815%2C12.6957311%2C18.5z%2Fdata%3D!4m22!1m15!4m14!1m6!1m2!1s0x132f0edee08f08f9%3A0x30bd23359d9d2a39!2sSan%2BValentino%2C%2BPoggio%2BMirteto%2BRI!2m2!1d12.6951999!2d42.2718755!1m6!1m2!1s0x132f0eef47bbeb93%3A0x65a394f287fe7819!2sComune%2BDi%2BPoggio%2BMirteto%2C%2BPiazza%2BMartiri%2Bdella%2BLibert%25C3%25A0%2C%2B40%2C%2B02047%2BPoggio%2BMirteto%2BRI!2m2!1d12.6838721!2d42.2644455!3m5!1s0x132f0edee08f08f9%3A0x30bd23359d9d2a39!8m2!3d42.2718755!4d12.6951999!16s%252Fg%252F119vsx9_q%3Fhl%3Dit%26entry%3Dttu|target:_blank\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_btn title=\"Vai alla scheda del comune di Poggio Mirteto\" style=\"outline\" shape=\"square\" color=\"warning\" i_align=\"right\" i_icon_fontawesome=\"far fa-file-alt\" add_icon=\"true\" link=\"url:https%3A%2F%2Fgeosabina.it%2Fdestinations%2Fpoggio-mirteto%2F\"][\/vc_column_inner][\/vc_row_inner][vc_empty_space height=\"80px\"][\/vc_column][\/vc_row]","post_title":"ITINERARIO | Colle Cosimo, Colle Capanne e Monte Morrone","post_link":"https:\/\/geosabina.it\/itinerari\/colle-cosimo-colle-capanne-e-monte-morrone\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"ITINERARIO | Colle Cosimo, Colle Capanne e Monte Morrone\" 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_1696587101819{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696587139913{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696587211690{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696587220410{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1696587235947{padding-top: 1px !important;padding-right: 10px !important;padding-bottom: 8px !important;padding-left: 10px !important;background-color: #efac52 !important;}.vc_custom_1706195357694{margin-top: -20px !important;}","%_wpml_media_featured%":"1","%_wpml_media_duplicate%":"1","%_wpml_word_count%":"{\"total\":596,\"to_translate\":{\"en\":596}}","%_wpml_location_migration_done%":"1","%_wp_page_template%":"default","%_wpgmp_location_address%":"02047 Poggio Mirteto RI, Italia","%_wpgmp_location_city%":"Poggio Mirteto","%_wpgmp_location_state%":"Lazio","%_wpgmp_location_country%":"Italia","%_wpgmp_metabox_latitude%":"42.2752902","%_wpgmp_metabox_longitude%":"12.6922343","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"3\";i:1;s:2:\"16\";i:2;s:2:\"17\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;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","%_wpb_post_custom_css%":".itinerari {\r\n    width:100%;\r\n    max-width:300px;\r\n}","%_dp_original%":"6930","%_edit_lock%":"1713541379:6","%_edit_last%":"6","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_thumbnail_id%":"9195","%_yoast_wpseo_focuskw%":"Colle Cosimo, Colle Capanne e Monte Morrone","%_yoast_wpseo_metadesc%":"La natura della sabina \u00e8 una natura meravigliosa, a tratti selvaggia e incontaminata, i piccoli paesi che circondano le campagne e i monti, incorniciano la fastosit\u00e0 del paesaggio","%_yoast_wpseo_linkdex%":"61","taxonomy=translation_priority":"Opzionale"},"icon":"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/04\/itinerari_sito.png"},"id":6945,"infowindow_disable":false,"categories":[{"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":"ITINERARIO | Toffia, Abbazia di Farfa, Montopoli di Sabina, 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=\"ITINERARIO | Toffia, Abbazia di Farfa, Montopoli di Sabina, Poggio Mirteto\" width=\"300\" height=\"191\" src=\"https:\/\/geosabina.it\/wp-content\/uploads\/2022\/07\/itinerari-logo-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\/itinerari\/toffia-abbazia-di-farfa-montopoli-di-sabina-poggio-mirteto-2\/\" class=\"fc-post-link\">ITINERARIO | Toffia, Abbazia di Farfa, Montopoli di Sabina, 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":"02039 Toffia RI, Italia","location":{"lat":"42.2124537","city":"Toffia","state":"Lazio","country":"Italia","lng":"12.753571","onclick_action":"marker","redirect_permalink":"https:\/\/geosabina.it\/itinerari\/toffia-abbazia-di-farfa-montopoli-di-sabina-poggio-mirteto-2\/","zoom":18,"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 percorso che vi proponiamo \u00e8 un affascinante itinerario attraverso suggestivi borghi e paesaggi incantevoli, immersi nella pittoresca campagna della Sabina medievale.[\/vc_column_text][\/vc_column][\/vc_row][vc_row full_width=\"stretch_row_content_no_spaces\"][vc_column][\/vc_column][\/vc_row][vc_row][vc_column][vc_empty_space height=\"40px\"][vc_column_text]\r\n<h2>Toffia, Abbazia di Farfa, <strong>Montopoli di Sabina, Poggio Mirteto<\/strong><\/h2>\r\n[\/vc_column_text][vc_column_text css=\".vc_custom_1696332855438{margin-top: -20px !important;}\"]\r\n<h5>Itinerario Artistico<\/h5>\r\n[\/vc_column_text][vc_empty_space height=\"20px\"][\/vc_column][\/vc_row][vc_row gap=\"20\" css_animation=\"fadeIn\"][vc_column css_animation=\"fadeIn\" width=\"1\/4\"][vc_row_inner][vc_column_inner offset=\"vc_hidden-xs\"][vc_single_image image=\"9145\" img_size=\"full\" alignment=\"center\" onclick=\"custom_link\" el_class=\"itinerari\" link=\"https:\/\/geosabina.it\/itinerari\/\"][vc_empty_space height=\"25px\"][\/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.com%2Fmaps%2Fdir%2F42.2042993%2C12.7535648%2FToffia%2C%2B02039%2BRI%2F%4042.2043629%2C12.7125377%2C13z%2Fdata%3D!4m8!4m7!1m0!1m5!1m1!1s0x132f0a4b528ab3c1%3A0x4094f9ab239b6b0!2m2!1d12.7537372!2d42.2043067%3Fhl%3Dit%26entry%3Dttu\" el_id=\"bottoneindicazioni\"][vc_empty_space height=\"25px\"][\/vc_column_inner][\/vc_row_inner][vc_row_inner el_class=\"info_app\" css=\".vc_custom_1696325961236{padding: 20p