DEVELOPER BLOG

1. In the Browser panel, right-click XYZ Tiles > New Connection
   
   
2. Enter a name like "Google StreetView Coverage" and the URL: https://mts2.google.com/mapslt?lyrs=svv&x={x}&y={y}&z={z}&w=256&h=256&hl=en&style=40,18
   
   
3. Double-click the new XYZ Tile to add it to the map
   

Step 1: Identify Adjacent Buildings

1. Buffer the Buildings: Create a small buffer around each building to ensure that touching walls are detected. Go to Vector > Geoprocessing Tools > Buffer. Set a small buffer distance (like 0.5 meters) to account for minor inaccuracies in the building outlines.
   
   
2. Select Adjacent Buildings: Use the   Select by  Location  tool (Vector > Research Tools > Select by Location) to select buildings that intersect the buffered layer. This will identify buildings that are adjacent.

Step 2: Create Points on Joint Edges

1. Intersection of Buffers: Use the  Intersection   tool (Vector > Geoprocessing Tools > Intersection) on the buffer layer to find intersections between buffers of adjacent buildings. This will give you the lines where the buildings are adjacent.
   
   
2. Convert Intersection Lines to Points: Use the   Extract vertices  tool (Vector > Geometry Tools > Extract vertices) on the intersection lines. This will create points at the vertices of the intersection lines, which includes the points where the buildings' walls meet.

Step 3: Save or Export the Refined Layer as a CSV Table

1. Open Attribute Table: Right-click on the layer and select 'Open Attribute Table'.
   
   
2. Add Latitude and Longitude Columns: Use the Field Calculator to create new fields for latitude and longitude. Use expressions like   y($geometry)  for latitude and     x($geometry)  for longitude. Make sure to set the output field type to 'Decimal number'.
   
   
3. Export Data: Once the new fields are populated, you can export this data. Right-click on the layer, select 'Export', and then 'Save Features As'. Choose 'CSV' as the format to easily use the data in other applications.

Step 4: Querying Google StreetView API

1. Google Street View API Key: You'll need an API key to use the Google Street View API. You can get this from the Google Cloud Console.
   
   
2. Prepare Your Query: Using the exported CSV file, you can prepare your queries for the Google Street View API. Each query will require the latitude and longitude values. You might use a programming language like Python to automate this process.
   
   
3. API Query Structure: A typical Street View API query looks like this:
   
   <https://maps.googleapis.com/maps/api/streetview/metadata?location=LAT,LON&key=YOUR_API_KEY>
   Replace LAT and LON with your latitude and longitude values, and YOUR_API_KEY with your actual API key.
   
   
4. Extract panoIDs: The response from the Street View API will include metadata about the nearest Street View image, including the panoID. You can parse this response to extract the panoID.
   
   
5. Handle API Limits and Quotas: Google StreetView API has
   
   
6. Storing and Using panoIDs: Once you have the panoIDs, you can store them for further use or analysis. Depending on your end goal, you might use these IDs to retrieve specific Street View images or other related tasks.

1. Fetch a session token.
2. Get panorama IDs for given locations.
3. Fetch latitude and longitude for each panorama ID.
4. Process locations from a CSV file in chunks, fetching panoIDs and their corresponding latitude and longitude.
5. Write the results to a new CSV file.

import requests
import pandas as pd# Function to get a session token
def get_session_token(api_key):
 url = "<https://tile.googleapis.com/v1/createSession?key=>" + api_key
 headers = {'Content-Type': 'application/json'}
 payload = {
 "mapType": "streetview",
 "language": "en-US",
 "region": "US"
 }
 response = requests.post(url, json=payload, headers=headers)
 if response.status_code == 200:
 return response.json().get('session')
 else:
 print("Error getting session token:", response.status_code, response.text)
 return None# Function to get a single panorama ID
def get_panorama_id(session_token, api_key, location):
 url = f"<https://tile.googleapis.com/v1/streetview/panoIds?session={session_token}&key={api_key}>"
 headers = {'Content-Type': 'application/json'}
 payload = {"locations": [location], "radius": 50}
 response = requests.post(url, json=payload, headers=headers)
 if response.status_code == 200 and 'panoIds' in response.json():
 pano_ids = response.json()['panoIds']
 return pano_ids[0] if pano_ids else None
 else:
 return None# Function to get latitude and longitude for a given panorama ID
def get_pano_lat_lon(api_key, pano_id):
 url = f"<https://maps.googleapis.com/maps/api/streetview/metadata?pano={pano_id}&key={api_key}>"
 response = requests.get(url)
 if response.status_code == 200 and 'location' in response.json():
 data = response.json()
 return data['location']['lat'], data['location']['lng']
 else:
 return None, None# Function to process a chunk and fetch panoIDs and their lat-lon
def process_locations_and_fetch_pano_ids(session_token, api_key, chunk):
 chunk['panoID'] = None
 chunk['panoLat'] = None
 chunk['panoLon'] = None for i, row in chunk.iterrows():
 location = {"lat": row["LAT"], "lng": row["LON"]}
 pano_id = get_panorama_id(session_token, api_key, location)
 chunk.at[i, 'panoID'] = pano_id if pano_id:
 pano_lat, pano_lon = get_pano_lat_lon(api_key, pano_id)
 chunk.at[i, 'panoLat'] = pano_lat
 chunk.at[i, 'panoLon'] = pano_lon return chunk# Main execution
api_key = 'YOUR_API_KEY' # Replace with your actual API key
csv_file = 'sirinevler.csv'
output_csv_file = 'sirinevler_with_panoID_and_LatLon.csv'session_token = get_session_token(api_key)
if session_token:
 all_chunks = []
 for chunk in pd.read_csv(csv_file, chunksize=100):
 updated_chunk = process_locations_and_fetch_pano_ids(session_token, api_key, chunk)
 all_chunks.append(updated_chunk) # Concatenate all chunks and write to a new CSV file
 updated_data = pd.concat(all_chunks)
 updated_data.to_csv(output_csv_file, index=False)

Step 5: Calculating the Camera Angle

Step 1: Find the Closest PanoID Point for Each Location

1. Open the QGIS Field Calculator:
   • Select the layer that contains your locations.
   • Open the attribute table and click on the "Open Field Calculator" icon.
2. Create a New Field:
   • Check the "Create a new field" option.
   • Name the field (e.g., closest_panoID).
3. Use an Expression to Find Closest PanoID:
   • In the expression box, use a function to find the closest feature in the panoID layer. QGIS doesn't have a direct function for this, but you can use a combination of functions like aggregate to calculate the minimum distance and then find the corresponding panoID. This can be complex and might require custom scripting.

Step 2: Calculate the Heading Values

1. Open the Field Calculator Again:
   • Still in the attribute table for your location layer, open the Field Calculator.
     
     
2. Create a New Field for Bearing:
   • Check "Create a new field."
   • Name the field (e.g.,  bearing .)
     
     
3. Use an Expression to Calculate the Bearing:
   • Use a QGIS expression to calculate the bearing. The basic formula for bearing between two points (lat1, lon1 and lat2, lon2) is as follows:
     
     
   • degrees(atan2(sin(lon2-lon1)*cos(lat2), cos(lat1)*sin(lat2)-sin(lat1)*cos(lat2)*cos(lon2-lon1)))
   • You'll need to replace  lat1 ,  lon1 ,  lat1 ,  lon2 with the respective field names of your datasets.

1. Open Your Layer in QGIS:
   
   • Load your layer that contains both the reference points and their matched  panoLat  and  panoLon  values.
     
     
2. Open the Field Calculator:
   
   • Open the attribute table for your layer.
   • Click on the "Open Field Calculator" icon.
     
     
3. Create a New Field for Heading:
   
   • Check the option "Create a new field".
   • Name the field (e.g.,  heading ).
   • Set the field type to Decimal number (real).
     
     
4. Calculate the Heading:
   
   • In the expression box, use the following expression to calculate the bearing:
     

     degrees(atan2(sin(radians("panoLon" - "longitude")) * cos(radians("panoLat")),
     cos(radians("latitude")) * sin(radians("panoLat")) -
     sin(radians("latitude")) * cos(radians("panoLat")) * cos(radians("panoLon" - "longitude"))))

   • Here, replace " latitute " and " longitude " with the field names of your original point's coordinates, and " panoLat " and " panoLon " with the field names of your panorama point's coordinates.
     
     
5. Adjust the Result to 0-360 Degrees Range:
   
   • The above formula might return negative values. To adjust all bearings to a 0-360 range, which is what Google StreetView API uses, you can modify the expression:
     

     (degrees(atan2(sin(radians("panoLon" - "longitude")) * cos(radians("panoLat")),
     cos(radians("latitude")) * sin(radians("panoLat")) -
     sin(radians("latitude")) * cos(radians("panoLat")) *
     cos(radians("panoLon" - "longitude")))) + 360) % 360

6. Run the Field Calculator:
   
   • Click "OK" to add the  heading values to your layer.
     
     
7. Save the Changes:
   
   • If your layer is editable, save these changes.

Step 3: Querying the Images

1. Read the CSV File:
   • Use the  pandas library to read your CSV file and iterate through each row.
     
     
2. Generate API Request URL:
   • For each row, construct the Google Street View API URL using the  panoId and  heading values.
     
     
3. Request and Save the Image:
   • Use the  requests library to fetch the image from the constructed URL.
   • Save the image to a file, using the  index column value for the filename.