{"map_options":{"center_lat":"51.915363","center_lng":"4.557430","zoom":14,"map_type_id":"SATELLITE","center_by_nearest":false,"fit_bounds":true,"center_circle_fillcolor":"#8CAEF2","center_circle_strokecolor":"#8CAEF2","show_center_circle":false,"show_center_marker":false,"center_marker_icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images//default_marker.png","draggable":true,"scroll_wheel":"false","gesture":"auto","infowindow_setting":"<div class=\"fc-item-box fc-item-no-padding\">\n<div class=\"fc-infowindow3\">\n<div class=\"fc-item-title fc-item-primary-text-color\">{marker_title}</div>\n<div class=\"fc-item-meta fc-item-secondary-text-color\">{marker_category}</div>\n<div class=\"fc-feature-image\">{marker_image}</div>\n</p></div>\n</div>\n","infowindow_geotags_setting":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\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-meta fc-item-secondary-text-color\">{post_categories}</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"{post_link}\" class=\"fc-post-link\">{post_featured_image}</a></div>\r\n    </div>\r\n</div>","infowindow_skin":{"name":"fano","type":"infowindow","sourcecode":"&lt;div class=&quot;fc-item-box fc-item-no-padding&quot;&gt;\r\n    &lt;div class=&quot;fc-infowindow3&quot;&gt;\r\n        &lt;div class=&quot;fc-item-title fc-item-primary-text-color&quot;&gt;{marker_title}&lt;/div&gt;\r\n        &lt;div class=&quot;fc-item-meta fc-item-secondary-text-color&quot;&gt;{marker_category}&lt;/div&gt;\r\n        &lt;div class=&quot;fc-feature-image&quot;&gt;{marker_image}&lt;/div&gt;\r\n    &lt;/div&gt;\r\n&lt;/div&gt;"},"infowindow_post_skin":{"name":"fano","type":"post","sourcecode":"&lt;div class=&quot;fc-item-box fc-item-no-padding&quot;&gt;\r\n    &lt;div class=&quot;fc-infowindow3&quot;&gt;\r\n        &lt;div class=&quot;fc-item-title fc-item-primary-text-color&quot;&gt;&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-meta fc-item-secondary-text-color&quot;&gt;{post_categories}&lt;/div&gt;\r\n        &lt;div class=&quot;fc-feature-image&quot;&gt;&lt;a target=&quot;_self&quot; href=&quot;{post_link}&quot; class=&quot;fc-post-link&quot;&gt;{post_featured_image}&lt;/a&gt;&lt;/div&gt;\r\n    &lt;/div&gt;\r\n&lt;/div&gt;"},"infowindow_drop_animation":false,"close_infowindow_on_map_click":true,"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":false,"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":"RIGHT_BOTTOM","zoom_control_position":"TOP_LEFT","map_type_control_position":"TOP_LEFT","map_type_control_style":"DROPDOWN_MENU","street_view_control_position":"TOP_LEFT","map_control":false,"screens":{"smartphones":{"map_zoom_level_mobile":"5"},"ipads":{"map_zoom_level_mobile":"5"},"grote-schermen":{"map_zoom_level_mobile":"5"}},"map_infowindow_customisations":true,"infowindow_width":"350px","infowindow_border_color":"rgba(0, 0, 0, 0.0980392)","infowindow_bg_color":"#fff","show_infowindow_header":false,"min_zoom":"11","max_zoom":"19","zoom_level_after_search":"19","url_filters":false,"doubleclickzoom":true,"current_post_only":false,"bound_map_after_filter":false,"display_reset_button":false,"map_reset_button_text":"Reset","height":"700","google_fonts":["\"Roboto Condensed\"","Roboto"]},"places":[{"source":"post","title":"\u2018s-Graventower II (13)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-13/\" class=\"fc-post-link\">\u2018s-Graventower II (13)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-13/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (13)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20231217_145559.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","content":"","address":"","location":{"lat":"51.912819","lng":"4.543678","redirect_custom_link":"","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/s-graventower-ii-13/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20231217_145559/20231217_145559.htm\" preview=\"previews/20231217_145559.jpg\"]\n<!-- /wp:shortcode -->","post_title":"\u2018s-Graventower II (13)","post_link":"https://www.panoramaview.nl/s-graventower-ii-13/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (13)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20231217_145559.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"'s-Graventower II, 360\u00b0 Panorama, Interieur, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20231217_145559.jpg","%fifu_image_alt%":"\u2018s-Graventower II (13)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.912819","%_wpgmp_metabox_longitude%":"4.543678","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"14\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_wp_old_date%":"2022-03-19","%_aioseo_title%":null,"%_aioseo_description%":null,"%_aioseo_keywords%":"","%_aioseo_og_title%":null,"%_aioseo_og_description%":null,"%_aioseo_og_article_section%":"","%_aioseo_og_article_tags%":"","%_aioseo_twitter_title%":null,"%_aioseo_twitter_description%":null,"%_dp_original%":"14992","%_edit_last%":"1","%_edit_lock%":"1705508778:1","%_thumbnail_id%":"15000","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"'s-Graventower II, 360\u00b0 Panorama, Interieur, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png"},"id":14997,"custom_filters":[],"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png","name":"Gebouwen","id":"1","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Sloopwerken","id":"14","type":"category","extension_fields":{"cat_order":"6"}}]},{"source":"post","title":"\u2018s-Graventower II (12)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-12/\" class=\"fc-post-link\">\u2018s-Graventower II (12)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-12/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (12)\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20231217_145159.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.912794","lng":"4.543453","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/s-graventower-ii-12/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20231217_145159/20231217_145159.htm\" preview=\"previews/20231217_145159.jpg\"]\n<!-- /wp:shortcode -->","post_title":"\u2018s-Graventower II (12)","post_link":"https://www.panoramaview.nl/s-graventower-ii-12/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (12)\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20231217_145159.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"'s-Graventower II, 360\u00b0 Panorama, Interieur, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20231217_145159.jpg","%fifu_image_alt%":"\u2018s-Graventower II (12)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.912794","%_wpgmp_metabox_longitude%":"4.543453","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"14\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_wp_old_date%":"2022-03-19","%_aioseo_title%":null,"%_aioseo_description%":null,"%_aioseo_keywords%":"","%_aioseo_og_title%":null,"%_aioseo_og_description%":null,"%_aioseo_og_article_section%":"","%_aioseo_og_article_tags%":"","%_aioseo_twitter_title%":null,"%_aioseo_twitter_description%":null,"%_dp_original%":"14976","%_edit_last%":"1","%_edit_lock%":"1704541248:1","%_thumbnail_id%":"14995","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"'s-Graventower II, 360\u00b0 Panorama, Interieur, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png"},"id":14992,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png","name":"Gebouwen","id":"1","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Sloopwerken","id":"14","type":"category","extension_fields":{"cat_order":"6"}}]},{"source":"post","title":"\u2018s-Graventower II (11)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-11/\" class=\"fc-post-link\">\u2018s-Graventower II (11)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-11/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (11)\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20231217_144907.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.912771","lng":"4.543661","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/s-graventower-ii-11/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20231217_144907/20231217_144907.htm\" preview=\"previews/20231217_144907.jpg\"]\n<!-- /wp:shortcode -->","post_title":"\u2018s-Graventower II (11)","post_link":"https://www.panoramaview.nl/s-graventower-ii-11/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (11)\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20231217_144907.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20231217_144907.jpg","%fifu_image_alt%":"\u2018s-Graventower II (11)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.912771","%_wpgmp_metabox_longitude%":"4.543661","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"14\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_wp_old_date%":"2022-03-19","%_aioseo_title%":null,"%_aioseo_description%":null,"%_aioseo_keywords%":"","%_aioseo_og_title%":null,"%_aioseo_og_description%":null,"%_aioseo_og_article_section%":"","%_aioseo_og_article_tags%":"","%_aioseo_twitter_title%":null,"%_aioseo_twitter_description%":null,"%_dp_original%":"14976","%_edit_last%":"1","%_edit_lock%":"1704112823:1","%_thumbnail_id%":"14983","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png"},"id":14980,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png","name":"Gebouwen","id":"1","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Sloopwerken","id":"14","type":"category","extension_fields":{"cat_order":"6"}}]},{"source":"post","title":"\u2018s-Graventower II (10)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-10/\" class=\"fc-post-link\">\u2018s-Graventower II (10)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-10/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (10)\" width=\"500\" height=\"250\" src=\"https://i2.wp.com/www.panoramaview.nl/panoramas/previews/20231217_144717.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.912684","lng":"4.543596","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/s-graventower-ii-10/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20231217_144717/20231217_144717.htm\" preview=\"previews/20231217_144717.jpg\"]\n<!-- /wp:shortcode -->","post_title":"\u2018s-Graventower II (10)","post_link":"https://www.panoramaview.nl/s-graventower-ii-10/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (10)\" width=\"500\" height=\"250\" src=\"https://i2.wp.com/www.panoramaview.nl/panoramas/previews/20231217_144717.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20231217_144717.jpg","%fifu_image_alt%":"\u2018s-Graventower II (10)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.912684","%_wpgmp_metabox_longitude%":"4.543596","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"14\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_wp_old_date%":"2022-03-19","%_dp_original%":"13096","%_edit_last%":"1","%_edit_lock%":"1704099995:1","%_aioseo_title%":null,"%_aioseo_description%":null,"%_aioseo_keywords%":"","%_aioseo_og_title%":null,"%_aioseo_og_description%":null,"%_aioseo_og_article_section%":"","%_aioseo_og_article_tags%":"","%_aioseo_twitter_title%":null,"%_aioseo_twitter_description%":null,"%_thumbnail_id%":"14979","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png"},"id":14976,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png","name":"Gebouwen","id":"1","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Sloopwerken","id":"14","type":"category","extension_fields":{"cat_order":"6"}}]},{"source":"post","title":"\u2018s-Graventower II (09)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-9/\" class=\"fc-post-link\">\u2018s-Graventower II (09)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-9/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (9)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20231217_144601.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.912745","lng":"4.543487","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/s-graventower-ii-9/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20231217_144601/20231217_144601.htm\" preview=\"previews/20231217_144601.jpg\"]\n<!-- /wp:shortcode -->","post_title":"\u2018s-Graventower II (09)","post_link":"https://www.panoramaview.nl/s-graventower-ii-9/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (9)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20231217_144601.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"'s-Graventower II, 360\u00b0 Panorama, Interieur, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20231217_144601.jpg","%fifu_image_alt%":"\u2018s-Graventower II (9)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.912745","%_wpgmp_metabox_longitude%":"4.543487","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"14\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_wp_old_date%":"2022-03-19","%_dp_original%":"13100","%_edit_last%":"1","%_edit_lock%":"1704541234:1","%_aioseo_title%":null,"%_aioseo_description%":null,"%_aioseo_keywords%":"","%_aioseo_og_title%":null,"%_aioseo_og_description%":null,"%_aioseo_og_article_section%":"","%_aioseo_og_article_tags%":"","%_aioseo_twitter_title%":null,"%_aioseo_twitter_description%":null,"%_thumbnail_id%":"14970","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"'s-Graventower II, 360\u00b0 Panorama, Interieur, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png"},"id":14967,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png","name":"Gebouwen","id":"1","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Sloopwerken","id":"14","type":"category","extension_fields":{"cat_order":"6"}}]},{"source":"post","title":"Hollandsche IJsselkering (08)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/hollandsche-ijsselkering-8/\" class=\"fc-post-link\">Hollandsche IJsselkering (08)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/hollandsche-ijsselkering-8/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hollandsche IJsselkering (08)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20230909_134251.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.916988","lng":"4.578228","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/hollandsche-ijsselkering-8/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20230909_134251/20230909_134251.htm\" preview=\"previews/20230909_134251.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Hollandsche IJsselkering (08)","post_link":"https://www.panoramaview.nl/hollandsche-ijsselkering-8/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hollandsche IJsselkering (08)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20230909_134251.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Brug, Hollandsche IJsselkering","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20230909_134251.jpg","%fifu_image_alt%":"Hollandsche IJsselkering (08)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.916988","%_wpgmp_metabox_longitude%":"4.578228","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wp_old_date%":"2020-06-22","%ssso_post_override%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_aioseo_title%":null,"%_aioseo_description%":null,"%_aioseo_keywords%":"","%_aioseo_og_title%":null,"%_aioseo_og_description%":null,"%_aioseo_og_article_section%":"","%_aioseo_og_article_tags%":"","%_aioseo_twitter_title%":null,"%_aioseo_twitter_description%":null,"%_dp_original%":"14851","%_edit_last%":"1","%_edit_lock%":"1702909451:1","%_thumbnail_id%":"14898","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Brug, Hollandsche IJsselkering","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png"},"id":14895,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png","name":"Bruggen","id":"8","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Hollandsche IJsselkering (07)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/hollandsche-ijsselkering-7/\" class=\"fc-post-link\">Hollandsche IJsselkering (07)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/hollandsche-ijsselkering-7/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hollandsche IJsselkering (07)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20230909_133948.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.917100","lng":"4.578173","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/hollandsche-ijsselkering-7/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20230909_133948/20230909_133948.htm\" preview=\"previews/20230909_133948.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Hollandsche IJsselkering (07)","post_link":"https://www.panoramaview.nl/hollandsche-ijsselkering-7/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hollandsche IJsselkering (07)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20230909_133948.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Basculekelder, Brug, Hollandsche IJsselkering, Interieur","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20230909_133948.jpg","%fifu_image_alt%":"Hollandsche IJsselkering (07)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.917100","%_wpgmp_metabox_longitude%":"4.578173","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wp_old_date%":"2020-06-22","%ssso_post_override%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_aioseo_title%":null,"%_aioseo_description%":null,"%_aioseo_keywords%":"","%_aioseo_og_title%":null,"%_aioseo_og_description%":null,"%_aioseo_og_article_section%":"","%_aioseo_og_article_tags%":"","%_aioseo_twitter_title%":null,"%_aioseo_twitter_description%":null,"%_dp_original%":"14851","%_edit_last%":"1","%_edit_lock%":"1702801493:1","%_thumbnail_id%":"14890","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Basculekelder, Brug, Hollandsche IJsselkering, Interieur","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png"},"id":14887,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png","name":"Bruggen","id":"8","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Hollandsche IJsselkering (06)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/hollandsche-ijsselkering-6/\" class=\"fc-post-link\">Hollandsche IJsselkering (06)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/hollandsche-ijsselkering-6/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hollandsche IJsselkering (06)\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20230909_133544.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.916756","lng":"4.578668","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/hollandsche-ijsselkering-6/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20230909_133544/20230909_133544.htm\" preview=\"previews/20230909_133544.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Hollandsche IJsselkering (06)","post_link":"https://www.panoramaview.nl/hollandsche-ijsselkering-6/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hollandsche IJsselkering (06)\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20230909_133544.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Brug, Hollandsche IJsselkering","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20230909_133544.jpg","%fifu_image_alt%":"Hollandsche IJsselkering (06)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.916756","%_wpgmp_metabox_longitude%":"4.578668","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wp_old_date%":"2020-06-22","%ssso_post_override%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_aioseo_title%":null,"%_aioseo_description%":null,"%_aioseo_keywords%":"","%_aioseo_og_title%":null,"%_aioseo_og_description%":null,"%_aioseo_og_article_section%":"","%_aioseo_og_article_tags%":"","%_aioseo_twitter_title%":null,"%_aioseo_twitter_description%":null,"%_dp_original%":"14847","%_edit_last%":"1","%_edit_lock%":"1702576114:1","%_thumbnail_id%":"14854","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Brug, Hollandsche IJsselkering","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png"},"id":14851,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png","name":"Bruggen","id":"8","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Hollandsche IJsselkering (05)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/hollandsche-ijsselkering-5/\" class=\"fc-post-link\">Hollandsche IJsselkering (05)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/hollandsche-ijsselkering-5/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hollandsche IJsselkering (05)\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20230909_132944.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.916860","lng":"4.578592","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/hollandsche-ijsselkering-5/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20230909_132944/20230909_132944.htm\" preview=\"previews/20230909_132944.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Hollandsche IJsselkering (05)","post_link":"https://www.panoramaview.nl/hollandsche-ijsselkering-5/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hollandsche IJsselkering (05)\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20230909_132944.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Brug, Hollandsche IJsselkering","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20230909_132944.jpg","%fifu_image_alt%":"Hollandsche IJsselkering (05)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.916860","%_wpgmp_metabox_longitude%":"4.578592","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wp_old_date%":"2020-06-22","%ssso_post_override%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_aioseo_title%":null,"%_aioseo_description%":null,"%_aioseo_keywords%":"","%_aioseo_og_title%":null,"%_aioseo_og_description%":null,"%_aioseo_og_article_section%":"","%_aioseo_og_article_tags%":"","%_aioseo_twitter_title%":null,"%_aioseo_twitter_description%":null,"%_dp_original%":"14809","%_edit_last%":"1","%_edit_lock%":"1702575739:1","%_thumbnail_id%":"14850","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Brug, Hollandsche IJsselkering","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png"},"id":14847,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png","name":"Bruggen","id":"8","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Hollandsche IJsselkering (04)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/hollandsche-ijsselkering-4/\" class=\"fc-post-link\">Hollandsche IJsselkering (04)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/hollandsche-ijsselkering-4/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hollandsche IJsselkering (04)\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20230909_132331.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91680739","lng":"4.57861028","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/hollandsche-ijsselkering-4/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20230909_132331/20230909_132331.htm\" preview=\"previews/20230909_132331.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Hollandsche IJsselkering (04)","post_link":"https://www.panoramaview.nl/hollandsche-ijsselkering-4/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hollandsche IJsselkering (04)\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20230909_132331.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Brug, Hollandsche IJsselkering, Interieur","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20230909_132331.jpg","%fifu_image_alt%":"Hollandsche IJsselkering (04)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91680739","%_wpgmp_metabox_longitude%":"4.57861028","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wp_old_date%":"2020-06-22","%ssso_post_override%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_dp_original%":"14767","%_edit_last%":"1","%_edit_lock%":"1702801512:1","%_aioseo_title%":null,"%_aioseo_description%":null,"%_aioseo_keywords%":"","%_aioseo_og_title%":null,"%_aioseo_og_description%":null,"%_aioseo_og_article_section%":"","%_aioseo_og_article_tags%":"","%_aioseo_twitter_title%":null,"%_aioseo_twitter_description%":null,"%_thumbnail_id%":"14812","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Brug, Hollandsche IJsselkering, Interieur","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png"},"id":14809,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png","name":"Bruggen","id":"8","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Hollandsche IJsselkering (03)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/hollandsche-ijsselkering-3/\" class=\"fc-post-link\">Hollandsche IJsselkering (03)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/hollandsche-ijsselkering-3/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hollandsche IJsselkering (03)\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20230909_131705.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91681511","lng":"4.57856467","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/hollandsche-ijsselkering-3/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20230909_131705/20230909_131705.htm\" preview=\"previews/20230909_131705.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Hollandsche IJsselkering (03)","post_link":"https://www.panoramaview.nl/hollandsche-ijsselkering-3/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hollandsche IJsselkering (03)\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20230909_131705.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Brug, Hollandsche IJsselkering","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20230909_131705.jpg","%fifu_image_alt%":"Hollandsche IJsselkering (03)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91681511","%_wpgmp_metabox_longitude%":"4.57856467","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wp_old_date%":"2020-06-22","%ssso_post_override%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_dp_original%":"14729","%_edit_last%":"1","%_edit_lock%":"1702314128:1","%_thumbnail_id%":"14770","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Brug, Hollandsche IJsselkering","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png"},"id":14767,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png","name":"Bruggen","id":"8","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Hollandsche IJsselkering (02)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/hollandsche-ijsselkering-2/\" class=\"fc-post-link\">Hollandsche IJsselkering (02)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/hollandsche-ijsselkering-2/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hollandsche IJsselkering (02)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20230909_131407.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91681675","lng":"4.57869878","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/hollandsche-ijsselkering-2/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20230909_131407/20230909_131407.htm\" preview=\"previews/20230909_131407.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Hollandsche IJsselkering (02)","post_link":"https://www.panoramaview.nl/hollandsche-ijsselkering-2/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hollandsche IJsselkering (02)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20230909_131407.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Brug, Hollandsche IJsselkering","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20230909_131407.jpg","%fifu_image_alt%":"Hollandsche IJsselkering (02)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91681675","%_wpgmp_metabox_longitude%":"4.57869878","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wp_old_date%":"2020-06-22","%ssso_post_override%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_dp_original%":"13749","%_edit_last%":"1","%_edit_lock%":"1702222668:1","%_thumbnail_id%":"14732","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Brug, Hollandsche IJsselkering","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png"},"id":14729,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png","name":"Bruggen","id":"8","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Hollandsche IJsselkering","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/hollandsche-ijsselkering/\" class=\"fc-post-link\">Hollandsche IJsselkering</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/hollandsche-ijsselkering/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hollandsche IJsselkering\" width=\"500\" height=\"250\" src=\"https://i2.wp.com/www.panoramaview.nl/panoramas/previews/20230909_131214.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91683331","lng":"4.57860222","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/hollandsche-ijsselkering/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20230909_131214/20230909_131214.htm\" preview=\"previews/20230909_131214.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Hollandsche IJsselkering","post_link":"https://www.panoramaview.nl/hollandsche-ijsselkering/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hollandsche IJsselkering\" width=\"500\" height=\"250\" src=\"https://i2.wp.com/www.panoramaview.nl/panoramas/previews/20230909_131214.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Brug, Hollandsche IJsselkering","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20230909_131214.jpg","%fifu_image_alt%":"Hollandsche IJsselkering","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91683331","%_wpgmp_metabox_longitude%":"4.57860222","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wp_old_date%":"2020-06-22","%_dp_original%":"9110","%_edit_last%":"1","%_edit_lock%":"1702222161:1","%_thumbnail_id%":"13752","%ssso_post_override%":"","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Brug, Hollandsche IJsselkering","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png"},"id":13749,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png","name":"Bruggen","id":"8","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"\u2018s-Graventower II (08)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-8/\" class=\"fc-post-link\">\u2018s-Graventower II (08)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-8/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (8)\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20230707_155656.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91261467","lng":"4.54345869","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/s-graventower-ii-8/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20230707_155656/20230707_155656.htm\" preview=\"previews/20230707_155656.jpg\"]\n<!-- /wp:shortcode -->","post_title":"\u2018s-Graventower II (08)","post_link":"https://www.panoramaview.nl/s-graventower-ii-8/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (8)\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20230707_155656.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20230707_155656.jpg","%fifu_image_alt%":"\u2018s-Graventower II (8)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91261467","%_wpgmp_metabox_longitude%":"4.54345869","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"14\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_wp_old_date%":"2022-03-19","%_dp_original%":"13096","%_edit_last%":"1","%_edit_lock%":"1691919624:1","%_thumbnail_id%":"13103","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png"},"id":13100,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png","name":"Gebouwen","id":"1","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Sloopwerken","id":"14","type":"category","extension_fields":{"cat_order":"6"}}]},{"source":"post","title":"\u2018s-Graventower II (07)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-7/\" class=\"fc-post-link\">\u2018s-Graventower II (07)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-7/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (7)\" width=\"500\" height=\"250\" src=\"https://i2.wp.com/www.panoramaview.nl/panoramas/previews/20230707_155219.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91306003","lng":"4.54320611","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/s-graventower-ii-7/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20230707_155219/20230707_155219.htm\" preview=\"previews/20230707_155219.jpg\"]\n<!-- /wp:shortcode -->","post_title":"\u2018s-Graventower II (07)","post_link":"https://www.panoramaview.nl/s-graventower-ii-7/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (7)\" width=\"500\" height=\"250\" src=\"https://i2.wp.com/www.panoramaview.nl/panoramas/previews/20230707_155219.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20230707_155219.jpg","%fifu_image_alt%":"\u2018s-Graventower II (7)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91306003","%_wpgmp_metabox_longitude%":"4.54320611","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"14\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_wp_old_date%":"2022-03-19","%_dp_original%":"13091","%_edit_last%":"1","%_edit_lock%":"1691919430:1","%_thumbnail_id%":"13099","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png"},"id":13096,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png","name":"Gebouwen","id":"1","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Sloopwerken","id":"14","type":"category","extension_fields":{"cat_order":"6"}}]},{"source":"post","title":"\u2018s-Graventower II (06)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-6/\" class=\"fc-post-link\">\u2018s-Graventower II (06)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-6/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (6)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20230707_154935.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91262103","lng":"4.54379933","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/s-graventower-ii-6/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20230707_154935/20230707_154935.htm\" preview=\"previews/20230707_154935.jpg\"]\n<!-- /wp:shortcode -->","post_title":"\u2018s-Graventower II (06)","post_link":"https://www.panoramaview.nl/s-graventower-ii-6/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (6)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20230707_154935.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20230707_154935.jpg","%fifu_image_alt%":"\u2018s-Graventower II (6)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91262103","%_wpgmp_metabox_longitude%":"4.54379933","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"14\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_dp_original%":"11547","%_edit_last%":"1","%_edit_lock%":"1691919146:1","%_thumbnail_id%":"13095","%_yoast_wpseo_wordproof_timestamp%":"","%_wp_old_date%":"2022-03-19","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png"},"id":13091,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png","name":"Gebouwen","id":"1","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Sloopwerken","id":"14","type":"category","extension_fields":{"cat_order":"6"}}]},{"source":"post","title":"Waterbushalte Rivium","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/waterbushalte-rivium/\" class=\"fc-post-link\">Waterbushalte Rivium</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/waterbushalte-rivium/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Waterbushalte Rivium\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20230624_115854.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.90679825","lng":"4.54767678","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/waterbushalte-rivium/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20230624_115854/20230624_115854.htm\" preview=\"previews/20230624_115854.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Waterbushalte Rivium","post_link":"https://www.panoramaview.nl/waterbushalte-rivium/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Waterbushalte Rivium\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20230624_115854.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Rivium, Schaardijk, Van Brienenoordbrug, Zalmhuis","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20230624_115854.jpg","%fifu_image_alt%":"Waterbushalte Rivium","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.90679825","%_wpgmp_metabox_longitude%":"4.54767678","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"7906","%_edit_last%":"1","%_edit_lock%":"1688204812:1","%_thumbnail_id%":"12554","%_yoast_wpseo_estimated-reading-time-minutes%":"","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Rivium, Schaardijk, Van Brienenoordbrug, Zalmhuis","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png"},"id":12551,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}}]},{"source":"post","title":"\u2018s-Graventower II (05)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-5/\" class=\"fc-post-link\">\u2018s-Graventower II (05)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-5/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (5)\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20220319_123555.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91313519","lng":"4.54359736","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/s-graventower-ii-5/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20220319_123555/20220319_123555.htm\" preview=\"previews/20220319_123555.jpg\"]\n<!-- /wp:shortcode -->","post_title":"\u2018s-Graventower II (05)","post_link":"https://www.panoramaview.nl/s-graventower-ii-5/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (5)\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20220319_123555.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20220319_123555.jpg","%fifu_image_alt%":"\u2018s-Graventower II (5)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91313519","%_wpgmp_metabox_longitude%":"4.54359736","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"14\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_dp_original%":"11543","%_edit_last%":"1","%_edit_lock%":"1701269225:1","%_thumbnail_id%":"11550","%_wp_old_slug%":"s-graventower-ii-05","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png"},"id":11547,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png","name":"Gebouwen","id":"1","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Sloopwerken","id":"14","type":"category","extension_fields":{"cat_order":"6"}}]},{"source":"post","title":"\u2018s-Graventower II (04)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-4/\" class=\"fc-post-link\">\u2018s-Graventower II (04)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-4/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (4)\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20220319_123229.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91275464","lng":"4.54333272","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/s-graventower-ii-4/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20220319_123229/20220319_123229.htm\" preview=\"previews/20220319_123229.jpg\"]\n<!-- /wp:shortcode -->","post_title":"\u2018s-Graventower II (04)","post_link":"https://www.panoramaview.nl/s-graventower-ii-4/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (4)\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20220319_123229.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20220319_123229.jpg","%fifu_image_alt%":"\u2018s-Graventower II (4)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91275464","%_wpgmp_metabox_longitude%":"4.54333272","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"14\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_dp_original%":"11526","%_edit_last%":"1","%_edit_lock%":"1701269217:1","%_thumbnail_id%":"11546","%_wp_old_slug%":"s-graventower-ii-04","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png"},"id":11543,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png","name":"Gebouwen","id":"1","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Sloopwerken","id":"14","type":"category","extension_fields":{"cat_order":"6"}}]},{"source":"post","title":"\u2018s-Graventower II (03)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-3/\" class=\"fc-post-link\">\u2018s-Graventower II (03)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-3/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (3)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20220319_122925.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91267964","lng":"4.54377975","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/s-graventower-ii-3/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20220319_122925/20220319_122925.htm\" preview=\"previews/20220319_122925.jpg\"]\n<!-- /wp:shortcode -->","post_title":"\u2018s-Graventower II (03)","post_link":"https://www.panoramaview.nl/s-graventower-ii-3/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (3)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20220319_122925.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20220319_122925.jpg","%fifu_image_alt%":"\u2018s-Graventower II (3)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91267964","%_wpgmp_metabox_longitude%":"4.54377975","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"14\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"8015","%_edit_last%":"1","%_edit_lock%":"1701269210:1","%_thumbnail_id%":"11529","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wp_old_slug%":"rivium-1e-straat-47-3","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png"},"id":11526,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png","name":"Gebouwen","id":"1","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Sloopwerken","id":"14","type":"category","extension_fields":{"cat_order":"6"}}]},{"source":"post","title":"Parkshuttlebrug","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/parkshuttlebrug/\" class=\"fc-post-link\">Parkshuttlebrug</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/parkshuttlebrug/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Parkshuttlebrug\" width=\"500\" height=\"250\" src=\"https://i2.wp.com/www.panoramaview.nl/panoramas/previews/20220319_122235.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91486592","lng":"4.54090628","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/parkshuttlebrug/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20220319_122235/20220319_122235.htm\" preview=\"previews/20220319_122235.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Parkshuttlebrug","post_link":"https://www.panoramaview.nl/parkshuttlebrug/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Parkshuttlebrug\" width=\"500\" height=\"250\" src=\"https://i2.wp.com/www.panoramaview.nl/panoramas/previews/20220319_122235.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Openbaar Vervoer, Parkshuttle, Parkshuttlebrug, Riviaduct","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20220319_122235.jpg","%fifu_image_alt%":"Parkshuttlebrug","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91486592","%_wpgmp_metabox_longitude%":"4.54090628","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_dp_original%":"11446","%_edit_last%":"1","%_edit_lock%":"1660222544:1","%_thumbnail_id%":"11499","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Openbaar Vervoer, Parkshuttle, Parkshuttlebrug, Riviaduct","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png"},"id":11496,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png","name":"Bruggen","id":"8","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Rivium Westlaan (03)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-westlaan-3/\" class=\"fc-post-link\">Rivium Westlaan (03)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-westlaan-3/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Westlaan (3)\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20220319_121644.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91267208","lng":"4.54178300","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/rivium-westlaan-3/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20220319_121644/20220319_121644.htm\" preview=\"previews/20220319_121644.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Rivium Westlaan (03)","post_link":"https://www.panoramaview.nl/rivium-westlaan-3/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Westlaan (3)\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20220319_121644.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Koepel, Openbaar Vervoer, Parkshuttle, Paviljoen, Rivium 1e Straat, Rivium Westlaan","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20220319_121644.jpg","%fifu_image_alt%":"Rivium Westlaan (3)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91267208","%_wpgmp_metabox_longitude%":"4.54178300","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"7970","%_edit_last%":"1","%_edit_lock%":"1648541342:1","%_thumbnail_id%":"11449","%_yoast_wpseo_estimated-reading-time-minutes%":"1","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Koepel, Openbaar Vervoer, Parkshuttle, Paviljoen, Rivium 1e Straat, Rivium Westlaan","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png"},"id":11446,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}}]},{"source":"post","title":"Fascinatio Boulevard (04)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/fascinatio-boulevard-4/\" class=\"fc-post-link\">Fascinatio Boulevard (04)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/fascinatio-boulevard-4/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Fascinatio Boulevard (4)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20220319_120630.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91713986","lng":"4.55357411","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/fascinatio-boulevard-4/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20220319_120630/20220319_120630.htm\" preview=\"previews/20220319_120630.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Fascinatio Boulevard (04)","post_link":"https://www.panoramaview.nl/fascinatio-boulevard-4/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Fascinatio Boulevard (4)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20220319_120630.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Fascinatio Boulevard, Kunstwerk, Onackpad, Riviaduct","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20220319_120630.jpg","%fifu_image_alt%":"Fascinatio Boulevard (4)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91713986","%_wpgmp_metabox_longitude%":"4.55357411","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_dp_original%":"11405","%_edit_last%":"1","%_edit_lock%":"1688211280:1","%_thumbnail_id%":"11417","%_wp_old_slug%":"speeltuin-fascinatio-boulevard","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Fascinatio Boulevard, Kunstwerk, Onackpad, Riviaduct","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png"},"id":11414,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}}]},{"source":"post","title":"Fascinatio Boulevard (03)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/fascinatio-boulevard-3/\" class=\"fc-post-link\">Fascinatio Boulevard (03)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/fascinatio-boulevard-3/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Fascinatio Boulevard (3)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20220319_115750.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91762844","lng":"4.53779522","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/fascinatio-boulevard-3/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20220319_115750/20220319_115750.htm\" preview=\"previews/20220319_115750.jpg\"]\n<!-- /wp:shortcode -->","post_title":"Fascinatio Boulevard (03)","post_link":"https://www.panoramaview.nl/fascinatio-boulevard-3/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Fascinatio Boulevard (3)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20220319_115750.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Brug, Fascinatio Boulevard","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20220319_115750.jpg","%fifu_image_alt%":"Fascinatio Boulevard (3)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91762844","%_wpgmp_metabox_longitude%":"4.53779522","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_dp_original%":"11367","%_edit_last%":"1","%_edit_lock%":"1648298110:1","%_thumbnail_id%":"11409","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Brug, Fascinatio Boulevard","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png"},"id":11405,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}}]},{"source":"post","title":"Fascinatio Boulevard (02)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/fascinatio-boulevard-2/\" class=\"fc-post-link\">Fascinatio Boulevard (02)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/fascinatio-boulevard-2/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Fascinatio Boulevard (2)\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20220319_115548.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91725314","lng":"4.53804750","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/fascinatio-boulevard-2/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20220319_115548/20220319_115548.htm\" preview=\"previews/20220319_115548.jpg\"]\n<!-- /wp:shortcode -->","post_title":"Fascinatio Boulevard (02)","post_link":"https://www.panoramaview.nl/fascinatio-boulevard-2/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Fascinatio Boulevard (2)\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20220319_115548.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Fascinatio Boulevard, IT, Kunstwerk, Marcel Kronenburg","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20220319_115548.jpg","%fifu_image_alt%":"Fascinatio Boulevard (2)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91725314","%_wpgmp_metabox_longitude%":"4.53804750","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"498","%_edit_last%":"1","%_edit_lock%":"1648298080:1","%_thumbnail_id%":"11370","%_yoast_wpseo_estimated-reading-time-minutes%":"1","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Fascinatio Boulevard, IT, Kunstwerk, Marcel Kronenburg","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png"},"id":11367,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}}]},{"source":"post","title":"Algerabrug (02)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/algerabrug-2/\" class=\"fc-post-link\">Algerabrug (02)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/algerabrug-2/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Algerabrug (2)\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20210622_113433.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91693414","lng":"4.57887917","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/algerabrug-2/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20210622_113433/20210622_113433.htm\" preview=\"previews/20210622_113433.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Algerabrug (02)","post_link":"https://www.panoramaview.nl/algerabrug-2/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Algerabrug (2)\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20210622_113433.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Brug","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20210622_113433.jpg","%fifu_image_alt%":"Algerabrug (2)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91693414","%_wpgmp_metabox_longitude%":"4.57887917","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"8071","%_edit_last%":"1","%_edit_lock%":"1626712753:1","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_wp_old_date%":"2020-06-22","%_thumbnail_id%":"11089","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Brug","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png"},"id":9110,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png","name":"Bruggen","id":"8","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Algerabrug","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/algerabrug/\" class=\"fc-post-link\">Algerabrug</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/algerabrug/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Algerabrug\" width=\"500\" height=\"250\" src=\"https://i2.wp.com/www.panoramaview.nl/panoramas/previews/20200911_124203.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91685075","lng":"4.57930672","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/algerabrug/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20200911_124203/20200911_124203.htm\" preview=\"previews/20200911_124203.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Algerabrug","post_link":"https://www.panoramaview.nl/algerabrug/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Algerabrug\" width=\"500\" height=\"250\" src=\"https://i2.wp.com/www.panoramaview.nl/panoramas/previews/20200911_124203.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Brug","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20200911_124203.jpg","%fifu_image_alt%":"Algerabrug","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91685075","%_wpgmp_metabox_longitude%":"4.57930672","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"7817","%_edit_last%":"1","%_edit_lock%":"1619021856:1","%_thumbnail_id%":"10952","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Algerabrug, Algeracorridor, Brug","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png"},"id":8071,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png","name":"Bruggen","id":"8","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Hangplek Sibeliuspad","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/hangplek-sibeliuspad/\" class=\"fc-post-link\">Hangplek Sibeliuspad</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/hangplek-sibeliuspad/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hangplek Sibeliuspad\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20200911_123628.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91717006","lng":"4.57571794","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/hangplek-sibeliuspad/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20200911_123628/20200911_123628.htm\" preview=\"previews/20200911_123628.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Hangplek Sibeliuspad","post_link":"https://www.panoramaview.nl/hangplek-sibeliuspad/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Hangplek Sibeliuspad\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20200911_123628.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Kars-Wegeling Pad, Muurschildering, Sibeliuspad","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20200911_123628.jpg","%fifu_image_alt%":"Hangplek Sibeliuspad","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91717006","%_wpgmp_metabox_longitude%":"4.57571794","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"9\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"7804","%_edit_last%":"1","%_edit_lock%":"1621535112:1","%_thumbnail_id%":"10922","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Kars-Wegeling Pad, Muurschildering, Sibeliuspad","taxonomy=post_format":""}},"id":7817,"infowindow_disable":false},{"source":"post","title":"&#8217;t Kraaienest","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/t-kraaienest/\" class=\"fc-post-link\">&#8217;t Kraaienest</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/t-kraaienest/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"&#8217;t Kraaienest\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20200911_123034.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91659989","lng":"4.57402011","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/t-kraaienest/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20200911_123034/20200911_123034.htm\" preview=\"previews/20200911_123034.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"&#8217;t Kraaienest","post_link":"https://www.panoramaview.nl/t-kraaienest/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"&#8217;t Kraaienest\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20200911_123034.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"'t Kraaienest, 360\u00b0 Panorama, Brug, Concerto, Sibeliusweg","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20200911_123034.jpg","%fifu_image_alt%":"&#8217;t Kraaienest","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91659989","%_wpgmp_metabox_longitude%":"4.57402011","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"7817","%_edit_last%":"1","%_edit_lock%":"1648299413:1","%_thumbnail_id%":"10950","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"'t Kraaienest, 360\u00b0 Panorama, Brug, Concerto, Sibeliusweg","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png"},"id":8063,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png","name":"Bruggen","id":"8","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Rivium Oostlaan (02)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-oostlaan-2/\" class=\"fc-post-link\">Rivium Oostlaan (02)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-oostlaan-2/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Oostlaan (2)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20200625_131404.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91243789","lng":"4.54968722","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/rivium-oostlaan-2/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20200625_131404/20200625_131404.htm\" preview=\"previews/20200625_131404.jpg\"]\n<!-- /wp:shortcode -->","post_title":"Rivium Oostlaan (02)","post_link":"https://www.panoramaview.nl/rivium-oostlaan-2/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Oostlaan (2)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20200625_131404.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Brug, Rivium 1e Straat, Rivium Oostlaan","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20200625_131404.jpg","%fifu_image_alt%":"Rivium Oostlaan (2)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91243789","%_wpgmp_metabox_longitude%":"4.54968722","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"6\";i:1;s:1:\"8\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"8019","%_edit_last%":"1","%_edit_lock%":"1607361934:1","%_thumbnail_id%":"10943","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Brug, Rivium 1e Straat, Rivium Oostlaan","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png"},"id":8023,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}},{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png","name":"Bruggen","id":"8","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Rivium Oostlaan","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-oostlaan/\" class=\"fc-post-link\">Rivium Oostlaan</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-oostlaan/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Oostlaan\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20200625_131226.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91236011","lng":"4.54903814","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/rivium-oostlaan/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20200625_131226/20200625_131226.htm\" preview=\"previews/20200625_131226.jpg\"]\n<!-- /wp:shortcode -->","post_title":"Rivium Oostlaan","post_link":"https://www.panoramaview.nl/rivium-oostlaan/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Oostlaan\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20200625_131226.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Rivium 1e Straat, Rivium Oostlaan","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20200625_131226.jpg","%fifu_image_alt%":"Rivium Oostlaan","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91236011","%_wpgmp_metabox_longitude%":"4.54903814","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"8015","%_edit_last%":"1","%_edit_lock%":"1602344114:1","%_thumbnail_id%":"10942","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Rivium 1e Straat, Rivium Oostlaan","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png"},"id":8019,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}}]},{"source":"post","title":"\u2018s-Graventower II (02)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-2/\" class=\"fc-post-link\">\u2018s-Graventower II (02)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii-2/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (2)\" width=\"500\" height=\"250\" src=\"https://i2.wp.com/www.panoramaview.nl/panoramas/previews/20200625_130642.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91259539","lng":"4.54382075","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/s-graventower-ii-2/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20200625_130642/20200625_130642.htm\" preview=\"previews/20200625_130642.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"\u2018s-Graventower II (02)","post_link":"https://www.panoramaview.nl/s-graventower-ii-2/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II (2)\" width=\"500\" height=\"250\" src=\"https://i2.wp.com/www.panoramaview.nl/panoramas/previews/20200625_130642.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20200625_130642.jpg","%fifu_image_alt%":"\u2018s-Graventower II (2)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91259539","%_wpgmp_metabox_longitude%":"4.54382075","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"14\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"7999","%_edit_last%":"1","%_edit_lock%":"1701269195:1","%_thumbnail_id%":"10941","%_wp_old_slug%":"rivium-1e-straat-2","%_yoast_wpseo_estimated-reading-time-minutes%":"1","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png"},"id":8015,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png","name":"Gebouwen","id":"1","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Sloopwerken","id":"14","type":"category","extension_fields":{"cat_order":"6"}}]},{"source":"post","title":"\u2018s-Graventower II","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii/\" class=\"fc-post-link\">\u2018s-Graventower II</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/s-graventower-ii/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20200625_130457.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91262019","lng":"4.54334600","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/s-graventower-ii/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20200625_130457/20200625_130457.htm\" preview=\"previews/20200625_130457.jpg\"]\n<!-- /wp:shortcode -->","post_title":"\u2018s-Graventower II","post_link":"https://www.panoramaview.nl/s-graventower-ii/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"\u2018s-Graventower II\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20200625_130457.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20200625_130457.jpg","%fifu_image_alt%":"\u2018s-Graventower II","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91262019","%_wpgmp_metabox_longitude%":"4.54334600","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:2:\"14\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"7628","%_edit_last%":"1","%_edit_lock%":"1701269175:1","%_thumbnail_id%":"10939","%_wp_old_slug%":"rivium-1e-straat","%_yoast_wpseo_estimated-reading-time-minutes%":"1","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"'s-Graventower II, 360\u00b0 Panorama, Rive Tower I, Rivium 1e Straat, Rivium 1e Straat 47, Sloopwerk, Waterford","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png"},"id":7999,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png","name":"Gebouwen","id":"1","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Sloopwerken","id":"14","type":"category","extension_fields":{"cat_order":"6"}}]},{"source":"post","title":"Rivium Westlaan (02)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-westlaan-2/\" class=\"fc-post-link\">Rivium Westlaan (02)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-westlaan-2/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Westlaan (2)\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20200625_130255.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91246131","lng":"4.54235139","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/rivium-westlaan-2/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20200625_130255/20200625_130255.htm\" preview=\"previews/20200625_130255.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Rivium Westlaan (02)","post_link":"https://www.panoramaview.nl/rivium-westlaan-2/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Westlaan (2)\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20200625_130255.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Openbaar Vervoer, Parkshuttle, Rivium 1e Straat, Rivium Westlaan","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20200625_130255.jpg","%fifu_image_alt%":"Rivium Westlaan (2)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91246131","%_wpgmp_metabox_longitude%":"4.54235139","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"7933","%_edit_last%":"1","%_edit_lock%":"1607361900:1","%_thumbnail_id%":"10936","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Openbaar Vervoer, Parkshuttle, Rivium 1e Straat, Rivium Westlaan","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png"},"id":7970,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}}]},{"source":"post","title":"Rivium Westlaan","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-westlaan/\" class=\"fc-post-link\">Rivium Westlaan</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-westlaan/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Westlaan\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20200625_125946.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91102864","lng":"4.54310664","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/rivium-westlaan/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20200625_125946/20200625_125946.htm\" preview=\"previews/20200625_125946.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Rivium Westlaan","post_link":"https://www.panoramaview.nl/rivium-westlaan/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Westlaan\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20200625_125946.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Openbaar Vervoer, Parkshuttle, Rivium 2e Straat, Rivium Westlaan","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20200625_125946.jpg","%fifu_image_alt%":"Rivium Westlaan","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91102864","%_wpgmp_metabox_longitude%":"4.54310664","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"7906","%_edit_last%":"1","%_edit_lock%":"1601719991:1","%_thumbnail_id%":"10933","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Openbaar Vervoer, Parkshuttle, Rivium 2e Straat, Rivium Westlaan","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png"},"id":7933,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}}]},{"source":"post","title":"Rivium Promenade","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-promenade/\" class=\"fc-post-link\">Rivium Promenade</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-promenade/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Promenade\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20200625_125024.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.9078604","lng":"4.54608433","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/rivium-promenade/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20200625_125024/20200625_125024.htm\" preview=\"previews/20200625_125024.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Rivium Promenade","post_link":"https://www.panoramaview.nl/rivium-promenade/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Promenade\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20200625_125024.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Riviaduct, Rivium Boulevard, Rivium Promenade, Zalmhuis","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20200625_125024.jpg","%fifu_image_alt%":"Rivium Promenade","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.9078604","%_wpgmp_metabox_longitude%":"4.54608433","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"7883","%_edit_last%":"1","%_edit_lock%":"1601471322:1","%_thumbnail_id%":"10930","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Riviaduct, Rivium Boulevard, Rivium Promenade, Zalmhuis","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png"},"id":7906,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}}]},{"source":"post","title":"Rivium Boulevard (05)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-boulevard-5/\" class=\"fc-post-link\">Rivium Boulevard (05)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-boulevard-5/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Boulevard (5)\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20200625_124633.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.90896583","lng":"4.54611650","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/rivium-boulevard-5/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20200625_124633/20200625_124633.htm\" preview=\"previews/20200625_124633.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Rivium Boulevard (05)","post_link":"https://www.panoramaview.nl/rivium-boulevard-5/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Boulevard (5)\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20200625_124633.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Rivium 3e Straat, Rivium 4e Straat, Rivium Boulevard","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20200625_124633.jpg","%fifu_image_alt%":"Rivium Boulevard (5)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.90896583","%_wpgmp_metabox_longitude%":"4.54611650","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"7866","%_edit_last%":"1","%_edit_lock%":"1607361884:1","%_thumbnail_id%":"10928","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Rivium 3e Straat, Rivium 4e Straat, Rivium Boulevard","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png"},"id":7883,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}}]},{"source":"post","title":"Rivium Boulevard (04)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-boulevard-4/\" class=\"fc-post-link\">Rivium Boulevard (04)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-boulevard-4/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Boulevard (04)\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20200625_124253.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.90992731","lng":"4.54618219","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/rivium-boulevard-4/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20200625_124253/20200625_124253.htm\" preview=\"previews/20200625_124253.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Rivium Boulevard (04)","post_link":"https://www.panoramaview.nl/rivium-boulevard-4/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Boulevard (04)\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20200625_124253.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Rivium 3e Straat, Rivium Boulevard","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20200625_124253.jpg","%fifu_image_alt%":"Rivium Boulevard (04)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.90992731","%_wpgmp_metabox_longitude%":"4.54618219","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"7769","%_edit_last%":"1","%_edit_lock%":"1601195736:1","%_thumbnail_id%":"10925","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Rivium 3e Straat, Rivium Boulevard","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png"},"id":7866,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}}]},{"source":"post","title":"Fascinatio Boulevard","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/fascinatio-boulevard/\" class=\"fc-post-link\">Fascinatio Boulevard</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/fascinatio-boulevard/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Fascinatio Boulevard\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20200625_123424.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91510111","lng":"4.54789067","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/fascinatio-boulevard/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20200625_123424/20200625_123424.htm\" preview=\"previews/20200625_123424.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Fascinatio Boulevard","post_link":"https://www.panoramaview.nl/fascinatio-boulevard/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Fascinatio Boulevard\" width=\"500\" height=\"250\" src=\"https://i3.wp.com/www.panoramaview.nl/panoramas/previews/20200625_123424.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, All Save, Braingate, Fascinatio Boulevard, Rivium Boulevard","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20200625_123424.jpg","%fifu_image_alt%":"Fascinatio Boulevard","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91510111","%_wpgmp_metabox_longitude%":"4.54789067","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"7769","%_edit_last%":"1","%_edit_lock%":"1600790011:1","%_thumbnail_id%":"10919","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, All Save, Braingate, Fascinatio Boulevard, Rivium Boulevard","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png"},"id":7804,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}}]},{"source":"post","title":"Rivium Boulevard (03)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-boulevard-3/\" class=\"fc-post-link\">Rivium Boulevard (03)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-boulevard-3/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Boulevard (3)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20200625_123220.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91530131","lng":"4.54652203","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/rivium-boulevard-3/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20200625_123220/20200625_123220.htm\" preview=\"previews/20200625_123220.jpg\"]\n<!-- /wp:shortcode -->\n\n<!-- wp:paragraph -->\n<p></p>\n<!-- /wp:paragraph -->","post_title":"Rivium Boulevard (03)","post_link":"https://www.panoramaview.nl/rivium-boulevard-3/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Boulevard (3)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20200625_123220.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Braingate, Fascinatio Boulevard, Riviaduct, Rivium Boulevard","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20200625_123220.jpg","%fifu_image_alt%":"Rivium Boulevard (3)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91530131","%_wpgmp_metabox_longitude%":"4.54652203","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"7628","%_edit_last%":"1","%_edit_lock%":"1607361869:1","%_thumbnail_id%":"10915","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Braingate, Fascinatio Boulevard, Riviaduct, Rivium Boulevard","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png"},"id":7769,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}}]},{"source":"post","title":"Braingate","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/braingate/\" class=\"fc-post-link\">Braingate</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/braingate/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Boulevard (03)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20200625_122849.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91401908","lng":"4.54644156","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/braingate/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20200625_122849/20200625_122849.htm\" preview=\"previews/20200625_122849.jpg\"]\n<!-- /wp:shortcode -->","post_title":"Braingate","post_link":"https://www.panoramaview.nl/braingate/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Boulevard (03)\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20200625_122849.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Abram van Rijckevorselweg, Braingate, Riviaduct, Rivium Boulevard","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20200625_122849.jpg","%fifu_image_alt%":"Rivium Boulevard (03)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91401908","%_wpgmp_metabox_longitude%":"4.54644156","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"7628","%_edit_last%":"1","%_edit_lock%":"1660222510:1","%_wp_old_slug%":"rivium-boulevard-3","%_thumbnail_id%":"10910","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Abram van Rijckevorselweg, Braingate, Riviaduct, Rivium Boulevard","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png"},"id":7645,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png","name":"Gebouwen","id":"1","type":"category","extension_fields":{"cat_order":"4"}}]},{"source":"post","title":"Rivium Boulevard (02)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-boulevard-2/\" class=\"fc-post-link\">Rivium Boulevard (02)</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-boulevard-2/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Boulevard (2)\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20200625_122441.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91252172","lng":"4.54633428","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/rivium-boulevard-2/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20200625_122441/20200625_122441.htm\" preview=\"previews/20200625_122441.jpg\"]\n<!-- /wp:shortcode -->","post_title":"Rivium Boulevard (02)","post_link":"https://www.panoramaview.nl/rivium-boulevard-2/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Boulevard (2)\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20200625_122441.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Rivium 1e Straat, Rivium Boulevard","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20200625_122441.jpg","%fifu_image_alt%":"Rivium Boulevard (2)","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91252172","%_wpgmp_metabox_longitude%":"4.54633428","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_dp_original%":"7072","%_edit_last%":"1","%_edit_lock%":"1607361855:1","%_thumbnail_id%":"10906","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Rivium 1e Straat, Rivium Boulevard","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png"},"id":7628,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}}]},{"source":"post","title":"Rivium Boulevard","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-boulevard/\" class=\"fc-post-link\">Rivium Boulevard</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-boulevard/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Boulevard\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20200625_122107.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.91136386","lng":"4.54627464","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/rivium-boulevard/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20200625_122107/20200625_122107.htm\" preview=\"previews/20200625_122107.jpg\"]\n<!-- /wp:shortcode -->","post_title":"Rivium Boulevard","post_link":"https://www.panoramaview.nl/rivium-boulevard/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Boulevard\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20200625_122107.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Rivium 2e Straat, Rivium Boulevard","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20200625_122107.jpg","%fifu_image_alt%":"Rivium Boulevard","%_dp_original%":"498","%_edit_last%":"1","%_edit_lock%":"1598693926:1","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.91136386","%_wpgmp_metabox_longitude%":"4.54627464","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_thumbnail_id%":"10866","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Rivium 2e Straat, Rivium Boulevard","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png"},"id":7072,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}}]},{"source":"post","title":"Groenedijk","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/groenedijk/\" class=\"fc-post-link\">Groenedijk</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/groenedijk/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Groenedijk\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20100417_131904.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.931798449018","lng":"4.6156518164783","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/groenedijk/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20100417_131904/20100417_131904.htm\" preview=\"previews/20100417_131904.jpg\"]\n<!-- /wp:shortcode -->","post_title":"Groenedijk","post_link":"https://www.panoramaview.nl/groenedijk/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Groenedijk\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20100417_131904.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Groenedijk, Hollandsche IJssel","%_edit_last%":"1","%_edit_lock%":"1598693948:1","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%_wp_rp_image%":"empty","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20100417_131904.jpg","%fifu_image_alt%":"Groenedijk","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.931798449018","%_wpgmp_metabox_longitude%":"4.6156518164783","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_thumbnail_id%":"10738","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Groenedijk, Hollandsche IJssel","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png"},"id":216,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}}]},{"source":"post","title":"Rivium Quadrant","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-quadrant/\" class=\"fc-post-link\">Rivium Quadrant</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/rivium-quadrant/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Quadrant\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20090405_154500.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.913458999327","lng":"4.5389177335433","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/rivium-quadrant/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20090405_154500/20090405_154500.htm\" preview=\"previews/20090405_154500.jpg\"]\n<!-- /wp:shortcode -->","post_title":"Rivium Quadrant","post_link":"https://www.panoramaview.nl/rivium-quadrant/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rivium Quadrant\" width=\"500\" height=\"250\" src=\"https://i1.wp.com/www.panoramaview.nl/panoramas/previews/20090405_154500.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"360\u00b0 Panorama, Rivium Quadrant","%_edit_last%":"1","%_edit_lock%":"1598693964:1","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20090405_154500.jpg","%fifu_image_alt%":"Rivium Quadrant","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.913458999327","%_wpgmp_metabox_longitude%":"4.5389177335433","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_thumbnail_id%":"10781","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"360\u00b0 Panorama, Rivium Quadrant","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png"},"id":498,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}}]},{"source":"post","title":"Sibeliusweg","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-infowindow3\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_self\" href=\"https://www.panoramaview.nl/sibeliusweg/\" class=\"fc-post-link\">Sibeliusweg</a></div>\r\n        <div class=\"fc-item-meta fc-item-secondary-text-color\">Capelle aan den IJssel</div>\r\n        <div class=\"fc-feature-image\"><a target=\"_self\" href=\"https://www.panoramaview.nl/sibeliusweg/\" class=\"fc-post-link\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sibeliusweg\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20080503_103525.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div></a></div>\r\n    </div>\r\n</div>","location":{"lat":"51.917202129418","lng":"4.5642072952417","onclick_action":"marker","redirect_permalink":"https://www.panoramaview.nl/sibeliusweg/","zoom":14,"extra_fields":{"post_excerpt":"","post_content":"<!-- wp:shortcode -->\n[pano file=\"20080503_103525/20080503_103525.htm\" preview=\"previews/20080503_103525.jpg\"]\n<!-- /wp:shortcode -->","post_title":"Sibeliusweg","post_link":"https://www.panoramaview.nl/sibeliusweg/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sibeliusweg\" width=\"500\" height=\"250\" src=\"https://i0.wp.com/www.panoramaview.nl/panoramas/previews/20080503_103525.jpg?w=500&resize=500,250\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Capelle aan den IJssel","post_tags":"Sibeliusweg","%_edit_last%":"1","%_edit_lock%":"1598693978:1","%music_auto%":"NO","%music_controls%":"NO","%music%":"NO","%fifu_image_url%":"https://www.panoramaview.nl/panoramas/previews/20080503_103525.jpg","%fifu_image_alt%":"Sibeliusweg","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"51.917202129418","%_wpgmp_metabox_longitude%":"4.5642072952417","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_primary_category%":"49","%_thumbnail_id%":"10798","taxonomy=category":"Capelle aan den IJssel","taxonomy=post_tag":"Sibeliusweg","taxonomy=post_format":""},"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png"},"id":814,"infowindow_disable":false,"categories":[{"icon":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","name":"Straten","id":"6","type":"category","extension_fields":{"cat_order":"8"}}]}],"styles":[{"featureType":"poi","elementType":"all","stylers":[{"visibility":"off"}]},{"featureType":"transit","elementType":"all","stylers":[{"visibility":"off"}]}],"listing":{"listing_header":" ","display_search_form":false,"search_field_autosuggest":false,"display_category_filter":true,"display_sorting_filter":false,"display_radius_filter":false,"radius_dimension":"km","radius_options":"1","apply_default_radius":false,"default_radius_dimension":"miles","display_location_per_page_filter":false,"display_print_option":false,"display_grid_option":false,"filters":["place_category"],"sorting_options":{"category__asc":"AZ-categorie","category__desc":"ZA-categorie","title__asc":"AZ-titel","title__desc":"VOOR Titel","address__asc":"AZ-adres","address__desc":"ZA-adres"},"default_sorting":{"orderby":"title","inorder":"asc"},"listing_container":".location_listing6","tabs_container":".location_listing6","hide_locations":true,"filters_position":"default","hide_map":false,"pagination":{"listing_per_page":10},"list_grid":"wpgmp_listing_grid","listing_placeholder":"<div class=\"fc-item-box fc-component-2 wpgmp_locations \">\r\n    <div class=\"fc-component-block\">\r\n        <div class=\"fc-component-content\">\r\n            <ul>\r\n                <li class=\"fc-item-featured fc-component-thumb fc-item-top_space\">\r\n                    <div class=\"fc-featured-hoverdiv\">\r\n                        <div class=\"fc-featured-hoverinner \"><a {onclick_action}=\"\" class=\"map\"></a></div>\r\n                        {marker_image}\r\n                    </div>\r\n                </li>\r\n\r\n                <li class=\"fc-component-text\">\r\n                    <div class=\"fc-itemcontent-padding\">\r\n                        <div class=\"fc-item-title fc-item-primary-text-color \">{marker_title}</div>\r\n                        <div class=\"fc-item-content fc-item-body-text-color\">\r\n                            {marker_message}\r\n                        </div>\r\n                        <a {onclick_action}=\"\" class=\"read-more fc-item-primary-text-color fc-css\">Beleef de 360\u00b0 panorama >></a>\r\n                    </div>\r\n                </li>\r\n            </ul>\r\n        </div>\r\n    </div>\r\n</div>","list_item_skin":{"name":"aare","type":"item","sourcecode":"&lt;div class=&quot;fc-item-box fc-component-2 wpgmp_locations &quot;&gt;\r\n    &lt;div class=&quot;fc-component-block&quot;&gt;\r\n        &lt;div class=&quot;fc-component-content&quot;&gt;\r\n            &lt;ul&gt;\r\n                &lt;li class=&quot;fc-item-featured fc-component-thumb fc-item-top_space&quot;&gt;\r\n                    &lt;div class=&quot;fc-featured-hoverdiv&quot;&gt;\r\n                        &lt;div class=&quot;fc-featured-hoverinner &quot;&gt;&lt;a {onclick_action}=&quot;&quot; class=&quot;map&quot;&gt;&lt;/a&gt;&lt;/div&gt;\r\n                        {marker_image}\r\n                    &lt;/div&gt;\r\n                &lt;/li&gt;\r\n\r\n                &lt;li class=&quot;fc-component-text&quot;&gt;\r\n                    &lt;div class=&quot;fc-itemcontent-padding&quot;&gt;\r\n                        &lt;div class=&quot;fc-item-title fc-item-primary-text-color &quot;&gt;{marker_title}&lt;/div&gt;\r\n                        &lt;div class=&quot;fc-item-content fc-item-body-text-color&quot;&gt;\r\n                            {marker_message}\r\n                        &lt;/div&gt;\r\n                        &lt;a {onclick_action}=&quot;&quot; class=&quot;read-more fc-item-primary-text-color fc-css&quot;&gt;Beleef de 360\u00b0 panorama &gt;&gt;&lt;/a&gt;\r\n                    &lt;/div&gt;\r\n                &lt;/li&gt;\r\n            &lt;/ul&gt;\r\n        &lt;/div&gt;\r\n    &lt;/div&gt;\r\n&lt;/div&gt;"}},"map_property":{"map_id":"6","debug_mode":true},"map_marker_spiderfier_setting":{"minimum_markers":"0"},"shapes":{"drawing_editable":false},"filters":{"filters_container":"[data-container=\"wpgmp-filters-container\"]"},"marker_category_icons":{"1":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/14-generic.png","2":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/13-generic.png","6":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/10-generic.png","7":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/15-generic.png","8":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/1-generic.png","10":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/23-generic.png","11":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/4-generic.png","14":"https://www.panoramaview.nl/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"}}