GPS data processing in Drone Programming - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Calculate distance between two GPS points

What is the output of this code that calculates the distance between two GPS coordinates using the Haversine formula?

Drone Programming

import math

def haversine(lat1, lon1, lat2, lon2):
    R = 6371  # Earth radius in km
    phi1 = math.radians(lat1)
    phi2 = math.radians(lat2)
    dphi = math.radians(lat2 - lat1)
    dlambda = math.radians(lon2 - lon1)

    a = math.sin(dphi/2)**2 + math.cos(phi1)*math.cos(phi2)*math.sin(dlambda/2)**2
    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))

    return R * c

print(round(haversine(52.2296756, 21.0122287, 41.8919300, 12.5113300), 2))

A 1150.25

B 1317.53

C 2890.12

D 980.45

💡 Hint

Remember the Haversine formula calculates great-circle distance between two points on a sphere.

The code uses the Haversine formula correctly and calculates the distance between Warsaw (52.2296756, 21.0122287) and Rome (41.8919300, 12.5113300) as approximately 1317.53 km.

🧠 Conceptual

intermediate

Understanding GPS coordinate formats

Which option correctly converts GPS coordinates from degrees, minutes, seconds (DMS) to decimal degrees?

A decimal = degrees + minutes/60 + seconds/3600

B decimal = degrees + minutes*60 + seconds*3600

C decimal = degrees * 60 + minutes + seconds/60

D decimal = degrees + minutes/3600 + seconds/60

💡 Hint

Think about how many minutes are in a degree and how many seconds are in a minute.

To convert DMS to decimal degrees, minutes are divided by 60 and seconds by 3600, then added to degrees.

🔧 Debug

advanced

Fix the GPS coordinate parsing error

What error does this code raise when parsing GPS coordinates from a string?

gps_str = "48°51'29.6\"N, 2°17'40.2\"E"
lat, lon = gps_str.split(",")
lat_deg, lat_min, lat_sec = map(float, lat[:-1].split("°"))
lon_deg, lon_min, lon_sec = map(float, lon[:-1].split("°"))

A ValueError: too many values to unpack

B AttributeError: 'float' object has no attribute 'split'

C ValueError: could not convert string to float

D IndexError: string index out of range

💡 Hint

Check how the string is split and converted to float.

The code tries to convert strings like "51'29.6\"N" directly to float, which fails because of non-numeric characters like ' and ".

📝 Syntax

advanced

Identify the syntax error in GPS data filtering

Which option contains the correct syntax to filter GPS points with latitude greater than 40 using a dictionary comprehension?

Drone Programming

gps_points = {"p1": (39.9, -75.2), "p2": (41.1, -74.9), "p3": (40.5, -73.9)}

A {k: v for k, v in gps_points.items() if v[0] => 40}

B {k: v if v[0] > 40 for k, v in gps_points.items()}

C {k: v for k, v in gps_points.items() v[0] > 40}

D {k: v for k, v in gps_points.items() if v[0] > 40}

💡 Hint

Remember the correct order of clauses in a dictionary comprehension.

Option D correctly uses 'if' after the 'for' clause. Other options have syntax errors or wrong operators.

🚀 Application

expert

Calculate average GPS speed from timestamped points

Given a list of GPS points with timestamps, which option correctly calculates the average speed in km/h between the first and last points?

points = [
    {"lat": 52.0, "lon": 21.0, "time": 0},
    {"lat": 52.1, "lon": 21.1, "time": 1800},  # 30 minutes later
    {"lat": 52.2, "lon": 21.2, "time": 3600}   # 60 minutes later
]

A

from math import radians, sin, cos, sqrt, atan2
R = 6371
p1, p2 = points[0], points[-1]
dlat = radians(p2['lat'] - p1['lat'])
dlon = radians(p2['lon'] - p1['lon'])
phi1 = radians(p1['lat'])
phi2 = radians(p2['lat'])
a = sin(dlat/2)**2 + cos(phi1)*cos(phi2)*sin(dlon/2)**2
c = 2*atan2(sqrt(a), sqrt(1-a))
distance = R * c
elapsed_hours = (p2['time'] - p1['time']) / 3600
speed = distance / elapsed_hours
print(round(speed, 2))

B

p1, p2 = points[0], points[-1]
distance = ((p2['lat'] - p1['lat'])**2 + (p2['lon'] - p1['lon'])**2)**0.5
elapsed_hours = (p2['time'] - p1['time']) / 3600
speed = distance / elapsed_hours
print(round(speed, 2))

C

from math import radians, sin, cos, sqrt, atan2
R = 6371
p1, p2 = points[0], points[-1]
dlat = radians(p2['lat'] - p1['lat'])
dlon = radians(p2['lon'] - p1['lon'])
phi1 = radians(p1['lat'])
phi2 = radians(p2['lat'])
a = sin(dlat/2)**2 + cos(phi1)*cos(phi2)*sin(dlon/2)**2
c = 2*atan2(sqrt(a), sqrt(1-a))
distance = R * c
elapsed_hours = (p2['time'] - p1['time'])
speed = distance / elapsed_hours
print(round(speed, 2))

D

from math import radians, sin, cos, sqrt, atan2
R = 6371
p1, p2 = points[0], points[-1]
dlat = radians(p2['lat'] - p1['lat'])
dlon = radians(p2['lon'] - p1['lon'])
phi1 = radians(p1['lat'])
phi2 = radians(p2['lat'])
a = sin(dlat/2)**2 + cos(phi1)*cos(phi2)*sin(dlon/2)**2
c = 2*atan2(sqrt(a), sqrt(1-a))
distance = R * c
elapsed_hours = (p2['time'] - p1['time']) / 60
speed = distance / elapsed_hours
print(round(speed, 2))

💡 Hint

Use the Haversine formula for distance and convert time difference to hours correctly.

Option A correctly calculates the great-circle distance and divides by elapsed time in hours. Option A uses Euclidean distance which is inaccurate for GPS. Option A divides time by 60 (minutes) instead of 3600 (seconds to hours). Option A uses raw seconds as hours.

Practice

1. What is the main purpose of processing GPS data in drone programming?

easy

A. To convert raw GPS signals into usable location information

B. To increase the drone's battery life

C. To improve the drone's camera resolution

D. To control the drone's speed manually

Solution

1. Step 1: Understand GPS data role

   GPS data provides raw signals that need to be processed to get location info.

2. Step 2: Identify main purpose in drone programming

   Processing GPS data helps the drone know where it is to navigate safely.

3. Final Answer:

   To convert raw GPS signals into usable location information -> Option A

4. Quick Check:

   GPS data processing = usable location info [OK]

Hint: GPS data processing means turning signals into location [OK]

Common Mistakes:

• Confusing GPS data processing with battery or camera functions
• Thinking GPS controls speed directly
• Assuming GPS data is already usable without processing

2. Which of the following is the correct syntax to extract latitude from a GPS data dictionary named gps_data in Python?

easy

A. latitude = gps_data.latitude

B. latitude = gps_data['latitude']

C. latitude = gps_data(latitude)

D. latitude = gps_data->latitude

Solution

1. Step 1: Recall Python dictionary access syntax

   Python dictionaries use square brackets and keys as strings to access values.

2. Step 2: Match syntax to gps_data dictionary

   Correct way is gps_data['latitude'], not dot or parentheses or arrow.

3. Final Answer:

   latitude = gps_data['latitude'] -> Option B

4. Quick Check:

   Dictionary key access = gps_data['key'] [OK]

Hint: Use square brackets with key string for dictionary access [OK]

Common Mistakes:

• Using dot notation for dictionary keys
• Using parentheses instead of brackets
• Using arrow notation which is not Python syntax

3. What will be the output of this Python code snippet processing GPS coordinates?

gps_points = [{'lat': 40.7128, 'lon': -74.0060}, {'lat': 34.0522, 'lon': -118.2437}]
latitudes = [point['lat'] for point in gps_points]
print(latitudes)

medium

A. [40.7128, 34.0522]

B. ['lat', 'lat']

C. [{'lat': 40.7128}, {'lat': 34.0522}]

D. [40.7128, -74.0060, 34.0522, -118.2437]

Solution

1. Step 1: Understand list comprehension extracting 'lat'

   The code loops over gps_points and picks the 'lat' value from each dictionary.

2. Step 2: Evaluate the resulting list

   It creates a list of latitudes: [40.7128, 34.0522].

3. Final Answer:

   [40.7128, 34.0522] -> Option A

4. Quick Check:

   List comprehension extracts latitudes = [40.7128, 34.0522] [OK]

Hint: List comprehension extracts values by key from each dict [OK]

Common Mistakes:

• Confusing keys with values
• Expecting full dictionaries instead of values
• Mixing latitude and longitude in one list

4. Identify the error in this Python code that processes GPS data:

gps_data = {'lat': 51.5074, 'lon': -0.1278}
print(gps_data.lat)

medium

A. The print statement syntax is incorrect

B. The dictionary keys are misspelled

C. The dictionary is missing required keys

D. Using dot notation to access dictionary keys causes an AttributeError

Solution

1. Step 1: Check dictionary access method

   Python dictionaries do not support dot notation; keys must be accessed with brackets.

2. Step 2: Identify the error type

   Using gps_data.lat will cause an AttributeError because 'dict' object has no attribute 'lat'.

3. Final Answer:

   Using dot notation to access dictionary keys causes an AttributeError -> Option D

4. Quick Check:

   Dictionary keys need brackets, not dot notation [OK]

Hint: Use brackets, not dot, to access dictionary keys [OK]

Common Mistakes:

• Trying to access dict keys with dot notation
• Assuming print syntax is wrong
• Thinking dictionary keys are missing

5. You have a list of GPS data points with possible missing longitude values represented as None:

gps_points = [
  {'lat': 35.6895, 'lon': 139.6917},
  {'lat': 48.8566, 'lon': None},
  {'lat': 55.7558, 'lon': 37.6173}
]

Which Python code correctly creates a new list of only points with valid longitude values?

hard

A. valid_points = [p for p in gps_points if p['lon'] != 0]

B. valid_points = [p for p in gps_points if p['lat'] > 0]

C. valid_points = [p for p in gps_points if p['lon'] is not None]

D. valid_points = [p for p in gps_points if p['lon']]

Solution

1. Step 1: Understand filtering condition for valid longitude

   Longitude is valid if it is not None; zero is a valid longitude value.

2. Step 2: Check each option's condition

   valid_points = [p for p in gps_points if p['lon'] is not None] correctly filters points where 'lon' is not None. valid_points = [p for p in gps_points if p['lon'] != 0] wrongly excludes zero longitude. valid_points = [p for p in gps_points if p['lat'] > 0] filters by latitude, not longitude. valid_points = [p for p in gps_points if p['lon']] excludes zero longitude because zero is falsy.

3. Final Answer:

   valid_points = [p for p in gps_points if p['lon'] is not None] -> Option C

4. Quick Check:

   Filter with 'is not None' to keep valid longitude [OK]

Hint: Use 'is not None' to filter out missing GPS values [OK]

Common Mistakes:

• Filtering out zero longitude by mistake
• Filtering by latitude instead of longitude
• Using truthy check that excludes zero