Experiment

No. 1
Date:
Maps and Navigation
Aim:
AI has drastically improved traveling. Instead of having to rely on printed maps or directions, you can now
use Google Maps on your phone and type in your destination. So how does the application know where to
go? And what’s more, the optimal route, road barriers, and traffic congestions? Not too long ago, only
satellite-based GPS was available, but now, artificial intelligence is being incorporated to give users a much
more enhanced experience.

DESCRIPTION:

1. Maps and Navigation:

Maps and Navigation refer to the technology used to locate and guide a person or a vehicle from one place to
another. With the help of Maps and Navigation, we can quickly get directions to a specific location, avoid
traffic congestion, and find nearby points of interest such as restaurants, gas stations, and more.

2. Machine Learning Algorithms:

Machine Learning Algorithms are a subset of Artificial Intelligence that allows computers to learn and
improve without being explicitly programmed. These algorithms enable applications to analyze data, identify
patterns, and make predictions. In the context of Maps and Navigation, machine learning algorithms can be
used to analyze traffic patterns, identify roadblocks, and suggest optimal routes based on real-time data.

3. Computer Vision:

Computer Vision refers to the ability of a computer to interpret and understand visual information from the
world around it. In the context of Maps and Navigation, computer vision can be used to recognize buildings,
street signs, and other visual features of a city or town. This information can then be used to create accurate
maps and navigation directions.

4. Building Edges:

Building Edges refer to the outline or boundary of a building. By using computer vision and machine
learning algorithms, we can train an application to recognize the edges of buildings and use this information
to create more detailed and accurate maps. This can help improve navigation and provide more relevant
information about the area.

5. Traffic Flow:

Traffic Flow refers to the movement of vehicles on a road network. By using machine learning algorithms,
we can analyze traffic patterns and identify changes in flow. This information can then be used to suggest
alternate routes to avoid roadblocks and congestion. This can help users save time and reach their destination
more quickly.

6. House and Building Numbers:

House and Building Numbers refer to the numerical identifiers assigned to homes and buildings in a city or
town. By using computer vision, we can train an application to recognize these numbers and use them to
provide more accurate directions and information. This can help users find specific buildings or homes more
easily, especially in large or complex cities.

PROCEDURE:

1. Data Collection:

The first step in implementing this project is to collect data. We need to gather satellite images of the city or
town we want to map. This can be done using publicly available resources like Google Maps or Open Street
Map. We also need to collect traffic data, such as traffic flow, speed, and road closures, which can be
obtained from traffic sensors or publicly available traffic data sources.

Data cleaning and preparation:

In order to use the data collected for the project, it may be necessary to clean and preprocess the data. This
can involve removing duplicates, correcting errors, or transforming the data into a format that can be used by
the machine learning models.

2. Feature Engineering:

Feature engineering is the process of selecting and creating relevant features from the data that can be used
by the machine learning models. This may involve extracting features like building edges, house numbers, or
traffic flow patterns from the data or creating new features based on domain knowledge.

3. Model Selection and Tuning:

Depending on the specific requirements of the project, it may be necessary to experiment with different
machine learning models and algorithms to find the best model for the task at hand. This may involve
evaluating different model architectures, selecting appropriate hyperparameters, or using techniques like
cross-validation to optimize model performance.

4. Image Processing:

Once we have the data, we need to preprocess the satellite images. This involves removing noise, enhancing
contrast, and applying filters to improve the quality of the images. We can use image processing techniques
like Convolutional neural networks (CNNs) to analyze the images and extract features such as building edges
and house and building numbers.

5. Building Edge Detection:

Next, we need to train a machine learning model to recognize building edges. This involves using a CNN to
analyze the satellite images and identify the boundaries of buildings. The model can be trained on a large
dataset of images that have been annotated with building edges. The output of this step is a model that can
recognize building edges in new images.
6. House and Building Number Recognition:

After building edge detection, we can train another machine learning model to recognize house and building
numbers. This involves using a CNN to analyze the satellite images and identify the numerical identifiers
assigned to homes and buildings. The model can be trained on a large dataset of images that have been
annotated with house and building numbers. The output of this step is a model that can recognize house and
building numbers in new images.

7. Traffic Flow Analysis:

To analyze traffic flow, we can use machine learning algorithms to identify patterns in the traffic data. This
involves using techniques like clustering and regression analysis to analyze the data and identify changes in
flow. We can then use this information to suggest optimal routes to avoid congestion and roadblocks.

8. Integration:

The final step is to integrate all of the components of the project into a single application. We can create a
user interface that allows users to input their destination and receive directions. The application can use the
building edge detection and house and building number recognition.

Testing and evaluation:

Once the models have been trained, it is important to evaluate their performance on a separate test set to
ensure that they are generalizing well to new data. This may involve using metrics like accuracy, precision,
recall, or F1-score to measure model performance.

Integration and deployment:

Once the machine learning models and user interface have been developed, it is important to integrate them
into a single application and test the application in a real-world setting. This may involve deploying the
application on a cloud platform, testing it with real users, or monitoring the application to ensure that it is
performing as expected.
Source Code:

import heapq # Import heapq to use a priority queue (min-heap) for Dijkstra's algorithm.
class Graph:
def __init__(self):
# Dictionary to store graph nodes and their adjacent nodes with distances
self.nodes = {}
def add_edge(self, from_node, to_node, distance, traffic=1):
"""
Adds a bidirectional edge between 'from_node' and 'to_node' with a given distance.
The 'traffic' parameter adjusts the effective distance based on traffic conditions.
"""
if from_node not in self.nodes:
self.nodes[from_node] = []
if to_node not in self.nodes:
self.nodes[to_node] = []

# Store the neighboring node and its weighted distance

self.nodes[from_node].append((to_node, distance * traffic))
self.nodes[to_node].append((from_node, distance * traffic)) # Assuming bidirectional roads

def dijkstra(self, start, end):

"""
Implements Dijkstra's algorithm to find the shortest path from 'start' to 'end'.
Returns the optimal path and total distance.
"""
# Priority queue to store (distance, node) tuples
queue = [(0, start)]

# Dictionary to track the minimum distance from 'start' to each node

distances = {node: float('inf') for node in self.nodes}
distances[start] = 0 # Start node has a distance of 0

# Dictionary to keep track of the previous node in the shortest path

previous_nodes = {node: None for node in self.nodes}

while queue:
# Pop the node with the smallest distance
current_distance, current_node = heapq.heappop(queue)
# If we reached the destination, reconstruct the path
if current_node == end:
path = []
while current_node is not None:
path.append(current_node)
current_node = previous_nodes[current_node]
return path[::-1], distances[end] # Reverse path for correct order

# Explore neighboring nodes

for neighbor, weight in self.nodes[current_node]:
distance = current_distance + weight # Calculate new possible distance
if distance < distances[neighbor]: # If a shorter path is found
distances[neighbor] = distance
previous_nodes[neighbor] = current_node # Update previous node
heapq.heappush(queue, (distance, neighbor)) # Push updated distance to queue

return None, float('inf') # Return if no path exists

# Example usage
graph = Graph()

# Adding edges with distances (some affected by traffic)

graph.add_edge("A", "B", 4)
graph.add_edge("A", "C", 2)
graph.add_edge("B", "C", 1)
graph.add_edge("B", "D", 5)
graph.add_edge("C", "D", 8)
graph.add_edge("C", "E", 10)
graph.add_edge("D", "E", 2)

# Define start and destination nodes

start, end = "A", "E"

# Find the shortest path using Dijkstra's algorithm

path, distance = graph.dijkstra(start, end)

# Print the optimal path and total distance

print(f"Optimal path from {start} to {end}: {path} with total distance: {distance}")
INPUT:

OUTPUT:

Optimal path from A to E: ['A', 'C', 'B', 'D', 'E'] with total distance: 9

Result:
________________________________________________________________________________________
________________________________________________________________________________________
____________________________________________________
__________________________________________________________________________________
____________________________________