计算出行OD表和绘制城市热点区域
一、实验目的
1. 计算出租车出行OD表
2. 绘制城市热点区域
二、实验步骤
2.1 提取出租车的出行行程
1. 提取出租车轨迹
先将实验2处理好的出租车数据，按照出租车ID从小到大进行分组，再按照日期DATE、时间TIME进行升序排序，就可以得到某辆出租车的轨迹了。具体实现步骤：
（1）首先创建一个数据表test3_trace，与traffic_data结构一样，用于存储出租车轨迹，SQL代码：
use traffic_data;
CREATE TABLE `test3_trace` (
`GPS_ID` int AUTO_INCREMENT,
`DATE` date ,
`TIME` time ,
`ID` varchar(15) ,
`LONGTITUDE` DECIMAL(9, 6) ,
`LATITUDE` DECIMAL(8, 6) ,
`SPEED` float,
`ALTITUDE` int ,
`PASSENGER` bit(1),
PRIMARY KEY (`GPS_ID`)
);（2）其次从整个数据表中获取所有出租车的ID，并从小到大排列，存储在ids列表中。然后用for循环遍历ids列表，对于每一个出租车ID再遍历整个数据表，找到该ID对应的所有数据记录，并按日期DATE、时间TIME从小到大进行排列。最后将这些数据记录依次插入到test3_trace表中，因为在该表中GPS_ID是从1开始自增的序列，不需要插入数据，当每插入一条数据记录，其就会自增，这里用executemany() 批量插入，加快速度。因此在数据表test3_trace中就提取出了出租车轨迹，即所有GPS记录依次按照车牌号ID、日期DATE和时间TIME从小到大进行排序。Python代码：
import pymysql
# 数据库连接配置
db_config = {
'host': 'localhost',
'user': '数据库用户名',
'password': '密码',
'db': 'traffic_data',
'charset': 'utf8',
'cursorclass': pymysql.cursors.DictCursor
}
# 连接数据库
try:
db = pymysql.connect(**db_config)
cursor = db.cursor()
# 获取所有唯一的 ID 列表
cursor.execute("SELECT DISTINCT `ID` FROM `traffic_data` ORDER BY `ID`")
ids = [row['ID'] for row in cursor.fetchall()]
# 遍历每个 ID
for current_id in ids:
# 获取当前 ID 的所有记录，并按 DATE 和 TIME 排序
cursor.execute("""
SELECT `DATE`, `TIME`, `ID`, `LONGTITUDE`, `LATITUDE`, `SPEED`, `ALTITUDE`, `PASSENGER`
FROM `traffic_data`
WHERE `ID` = %s
ORDER BY `DATE`, `TIME`
""", (current_id,))
# 获取排序后的数据
sorted_records = cursor.fetchall()
# 构建用于 executemany() 的参数列表
# 不包括 GPS_ID，因为这是自增的，可以表示整个排序
insert_values = [(row['DATE'], row['TIME'], row['ID'], row['LONGTITUDE'], row['LATITUDE'], row['SPEED'],
row['ALTITUDE'], row['PASSENGER']) for row in sorted_records]
# 构建插入语句
insert_query = "INSERT INTO test3_trace (DATE, TIME, ID, LONGTITUDE, LATITUDE, SPEED, ALTITUDE, PASSENGER)" \
" VALUES (%s, %s, %s, %s, %s, %s, %s, %s)"
# 使用 executemany() 执行批量插入
cursor.executemany(insert_query, insert_values)
db.commit() # 提交事务
print(current_id + "出租车的数据已经复制完成")
print("所有数据已成功复制。")
except Exception as e:
print("更新失败:", e)
db.rollback()
finally:
cursor.close()
db.close()执行程序结果：
test3_trace表结果部分数据展示：
2. 提取出租车的乘客行程
出租车出现需求通常指出出租车乘客出行需求。在出租车数据记录中，字段PASSENGER记录了该出租车的载客状态，当载客状态字段PASSENGER为0时，表示没有乘客；当载客状态字段PASSENGER为1时，表示有乘客。因此根据该字段信息状态的变换，来提取乘客的上下车点。
将上面提取出来的出租车轨迹数据，检测每一辆出租车载客状态字段PASSENGER的变化，当其由0变为1，表示乘客上车点，再由1变为0时，表示乘客下车点，将这样一组变化定义为该辆出租车的一条出行行程数据。将其输出格式为<出租车车牌号，上车位置经度，上车位置纬度，上车时间，下车位置经度，下车位置纬度，下车时间>的数据记录。具体步骤：
（1）先在test3_trace表新建一列DATE_TIME，用于将表中的日期DATE和时间TIME合并成一列DATE_TIME，python代码：
# 合并日期和时间
import pymysql
from pymysql import cursors
# 数据库连接配置
db_config = {
'host': 'localhost',
'user': 'root',
'password': '123456',
'db': 'traffic_data',
'charset': 'utf8',
'cursorclass': pymysql.cursors.DictCursor
}
# 分批处理的批大小
batch_size = 1000 # 你可以根据实际情况调整这个值
# 连接到数据库
try:
db = pymysql.connect(**db_config)
cursor = db.cursor()
# 添加 DATE_TIME 列
cursor.execute("ALTER TABLE `test3_trace` ADD COLUMN `DATE_TIME` DATETIME NULL DEFAULT NULL;")
# 获取表中的所有记录的ID
cursor.execute("SELECT GPS_ID FROM test3_trace")
ids = cursor.fetchall()
# 分批更新数据
for i in range(0, len(ids), batch_size):
batch_ids = ids[i:i + batch_size]
# 构建SQL语句
update_query = """
UPDATE test3_trace
SET DATE_TIME = CONCAT(DATE, ' ', TIME)
WHERE GPS_ID IN ({})
""".format(', '.join(['%s'] * len(batch_ids)))
# 准备参数
params = tuple(id['GPS_ID'] for id in batch_ids)
# 执行更新操作
cursor.execute(update_query, params)
db.commit() # 提交事务
print("所有数据已成功更新。")
except Exception as e:
print("数据更新失败:", e)
db.rollback()
finally:
cursor.close()
db.close()运行结果，部分数据展示：
（2）创建表test3_travel_running，用于存储出租车的乘客行程数据，SQL代码：
use traffic_data;
CREATE TABLE `test3_travel_running` (
`travel_ID` int AUTO_INCREMENT,
`ID` varchar(15) , #出租车ID
`LONGTITUDE1` DECIMAL(9, 6) , #上车位置
`LATITUDE1` DECIMAL(8, 6) ,
`DATE_TIME1` datetime ,
`LONGTITUDE0` DECIMAL(9, 6) , #下车位置
`LATITUDE0` DECIMAL(8, 6) ,
`DATE_TIME0` datetime ,
PRIMARY KEY (`travel_ID`)
);表test3_travel_running展示：
（3）然后将提取出来的乘客行程轨迹，插入到数据表test3_travel_running中：
import pymysql
from pymysql import cursors
from decimal import Decimal
# 数据库连接配置
db_config = {
'host': 'localhost',
'user': 'root',
'password': '123456',
'db': 'traffic_data',
'charset': 'utf8mb4',
'cursorclass': cursors.SSDictCursor # 使用服务器端游标
}
# 定义插入查询
insert_query = """
INSERT INTO test3_travel_running (ID, LONGTITUDE1, LATITUDE1, DATE_TIME1, LONGTITUDE0, LATITUDE0, DATE_TIME0)
VALUES (%s, %s, %s, %s, %s, %s, %s)
"""
try:
# 连接到数据库
db = pymysql.connect(**db_config)
cursor = db.cursor()
# 初始化变量
batch_size = 1000 # 设置每批处理的记录数
insert_data = []
previous_record = None
start_trip = None # 存储上车记录
current_id = None # 当前记录的ID
# 从test3_trace表中按顺序获取数据
cursor.execute(
"SELECT `ID`, `LONGTITUDE`, `LATITUDE`, `DATE_TIME`, `PASSENGER` "
"FROM `test3_trace` "
"ORDER BY `ID`, `GPS_ID`"
)
# 分批处理数据
more_results = True
while more_results:
records = cursor.fetchmany(batch_size) # 获取一批数据
if not records:
more_results = cursor.nextset() # 检查是否还有其他结果集
if more_results:
continue
break # 如果没有更多的数据，结束循环
for record in records:
record_id = record['ID']
passenger_status = record['PASSENGER']
is_passenger_on = passenger_status == b'\x01'
# 上车逻辑
if is_passenger_on and (previous_record is None or previous_record['PASSENGER'] == b'\x00'):
start_trip = record # 记录上车信息
current_id = record_id # 更新当前ID
# 下车逻辑
if start_trip and (start_trip['ID'] == record_id):
if not is_passenger_on:
# 如果当前记录与上车记录ID相同，且乘客下车
insert_data.append((
record_id,
start_trip['LONGTITUDE'],
start_trip['LATITUDE'],
start_trip['DATE_TIME'],
record['LONGTITUDE'],
record['LATITUDE'],
record['DATE_TIME']
))
start_trip = None # 重置上车记录
current_id = None # 重置当前ID
elif start_trip and (start_trip['ID'] != record_id):
# 如果当前记录与上车记录ID不同，将上一条记录视为下车记录
insert_data.append((
previous_record['ID'],
start_trip['LONGTITUDE'],
start_trip['LATITUDE'],
start_trip['DATE_TIME'],
previous_record['LONGTITUDE'],
previous_record['LATITUDE'],
previous_record['DATE_TIME']
))
start_trip = None # 更新上车记录为当前记录
current_id = None # 重置当前ID
previous_record = record # 更新previous_record为当前记录
# 执行批量插入，如果insert_data列表满了
if len(insert_data) >= batch_size:
cursor.executemany(insert_query, insert_data)
db.commit()
print(f"Batch inserted {len(insert_data)} records.")
insert_data = [] # 清空列表为下一批数据做准备
# 最后一批插入，如果insert_data非空
if insert_data:
cursor.executemany(insert_query, insert_data)
db.commit()
print(f"Inserted remaining {len(insert_data)} records.")
print("Data processing complete.")
except Exception as e:
print("Error occurred, rolling back transaction:", e)
db.rollback()
finally:
cursor.close()
db.close()运行结果部分展示：
共提取出220594条乘客行程轨迹
2.2 城市交通小区划分
利用网格划分的划分交通小区。首先获得所有出租车轨迹的最大经纬度与最小经纬度坐标，（latmax, lngmax）与（latmin, lngmin）
SELECT
MAX(LONGTITUDE1) AS max_start_lng,MAX(LONGTITUDE0) AS max_end_lng,
MIN(LONGTITUDE1) AS min_start_lng,MIN(LONGTITUDE0) AS min_end_lng,
MAX(LATITUDE1) AS max_start_lat,MAX(LATITUDE0) AS max_end_lat,
MIN(LATITUDE1) AS min_start_lat,MIN(LATITUDE0) AS min_end_lat
FROM test3_travel_running;结果：
从结果来看出租车（latmax, lngmax）=（34.067192，118.86900），（latmin, lngmin）=（0.970307，0.132128），经度的跨度为117.899493，纬度的跨度为33.935064，明显可知经度的跨度大于纬度的跨度。因此将经度划分为10份，纬度划分成3份，将所有出租车所到达的面积划分为30份，即小区编号可以定义从01L01到03L10，前两位数字表示网格的纬度坐标，后两位数字表示网格的经度坐标。
2.3 出租车行程分配到对应交通小区
设出租车上车点为（lat1,lng1）与下车点（lat0,lng0）,假设通过计算得到上车点对应的交通小区为01L02、下车点对应的交通小区为03L05，那么将该行程分配给交通小区对[01L02，03L05]。
2.4 并计算出行OD表
利用pandas对OD表数据进行存储，表的横纵坐标名分别为小区的编号。对表A进行初始化，表中的所有数据都为0，读取一条行程数据，并找到其所对应的交通小区对，在表中对应交通小区对的数值上加1，对所有行程执行该操作。Python代码：
import pandas as pd
import pymysql
import pymysql.cursors
# 数据库连接配置
db_config = {
'host': 'localhost',
'user': 'root',
'password': '123456',
'db': 'traffic_data',
'charset': 'utf8mb4',
'cursorclass': pymysql.cursors.DictCursor
}
# 连接数据库
connection = pymysql.connect(**db_config)
# 划分网格
lng_min = 0.132128 # 经度
lng_max = 118.86900
lat_min = 0.970307
lat_max = 34.067192
lng_interval = (lng_max - lng_min) / 10
lat_interval = (lat_max - lat_min) / 3
grid_bounds = {}
for lat_idx in range(1, 4):
for lng_idx in range(1, 11):
grid_id = f"{lat_idx:02d}L{lng_idx:02d}"
grid_bounds[grid_id] = {
'min_lng': lng_min + (lng_idx - 1) * lng_interval,
'max_lng': lng_min + lng_idx * lng_interval,
'min_lat': lat_min + (lat_idx - 1) * lat_interval,
'max_lat': lat_min + lat_idx * lat_interval
}
print(f"交通小区编号: {grid_id}, 边界: ({grid_bounds[grid_id]['min_lng']}, {grid_bounds[grid_id]['min_lat']}) to ({grid_bounds[grid_id]['max_lng']}, {grid_bounds[grid_id]['max_lat']})")
# 获取行程数据
query = "SELECT LONGTITUDE1, LATITUDE1, LONGTITUDE0, LATITUDE0 FROM test3_travel_running"
cursor = connection.cursor()
cursor.execute(query)
trips = cursor.fetchall()
# 初始化OD矩阵
od_matrix = pd.DataFrame(0, index=grid_bounds.keys(), columns=grid_bounds.keys())
# 分配行程到网格
def get_traffic_zone(lng, lat):
for zone, bounds in grid_bounds.items():
if bounds['min_lng'] <= lng <= bounds['max_lng'] and bounds['min_lat'] <= lat <= bounds['max_lat']:
return zone
return None
for trip in trips:
pickup_zone = get_traffic_zone(trip['LONGTITUDE1'], trip['LATITUDE1'])
dropoff_zone = get_traffic_zone(trip['LONGTITUDE0'], trip['LATITUDE0'])
if pickup_zone and dropoff_zone:
od_matrix.at[pickup_zone, dropoff_zone] += 1
# 保存到Excel
with pd.ExcelWriter('traffic_zones_and_od_matrix.xlsx') as writer:
od_matrix.to_excel(writer, sheet_name='OD_Matrix')
pd.DataFrame(grid_bounds).T.to_excel(writer, sheet_name='Grid_Bounds')
cursor.close()
connection.close()运行结果：
划分的结果并不理想，有出租车行程数据的为[01L01，01L01]，[02L10，02L10]，[03L09，03L09]，[03L10，03L09]，[03L10，03L10]，查看其经纬度范围：
出租车行程数据主要集中在的经度范围为[106.9953，95.12163]，纬度范围为[34.06719，23.0349]，在将这个经纬度范围进行细划分网格，代码：
import pymysql
import pandas as pd
import pymysql.cursors
# 数据库连接配置
db_config = {
'host': 'localhost',
'user': 'root',
'password': '123456',
'db': 'traffic_data',
'charset': 'utf8mb4',
'cursorclass': pymysql.cursors.DictCursor
}
# 连接数据库
connection = pymysql.connect(**db_config)
# 获取行程数据
query = "SELECT LONGTITUDE1, LATITUDE1, LONGTITUDE0, LATITUDE0 FROM test3_travel_running"
cursor = connection.cursor()
cursor.execute(query)
trips = cursor.fetchall()
# 原始网格边界03L09
grid_bounds = {
'03L09': {'min_lng': 95.1216256, 'max_lng': 106.99531280000001, 'min_lat': 23.034897, 'max_lat': 34.067192}
}
# 细分特定网格
def subdivide_grid(grid_id, bounds, subdivisions=6):
"""细分特定网格"""
lat_range = bounds['max_lat'] - bounds['min_lat']
lng_range = bounds['max_lng'] - bounds['min_lng']
lat_step = lat_range / subdivisions
lng_step = lng_range / subdivisions
new_bounds = {}
for i in range(subdivisions):
print(i)
for j in range(subdivisions):
new_id = f"{grid_id}_{i + 1:02d}{j + 1:02d}"
new_bounds[new_id] = {
'min_lat': bounds['min_lat'] + i * lat_step,
'max_lat': bounds['min_lat'] + (i + 1) * lat_step,
'min_lng': bounds['min_lng'] + j * lng_step,
'max_lng': bounds['min_lng'] + (j + 1) * lng_step
}
return new_bounds
# 更新网格边界信息
new_grids = subdivide_grid('03L09', grid_bounds['03L09'])
grid_bounds.update(new_grids)
# 重新计算行程对应的网格
def get_traffic_zone(lng, lat, grid_bounds):
"""计算给定经纬度对应的网格"""
for grid_id, bounds in grid_bounds.items():
if bounds['min_lng'] <= lng <= bounds['max_lng'] and bounds['min_lat'] <= lat <= bounds['max_lat']:
return grid_id
return None
# 初始化新的OD矩阵
od_matrix = pd.DataFrame(0, index=new_grids.keys(), columns=new_grids.keys())
print("OD")
# 分配行程到网格
for trip in trips:
pickup_zone = get_traffic_zone(trip['LONGTITUDE1'], trip['LATITUDE1'], new_grids)
dropoff_zone = get_traffic_zone(trip['LONGTITUDE0'], trip['LATITUDE0'], new_grids)
if pickup_zone and dropoff_zone:
od_matrix.at[pickup_zone, dropoff_zone] += 1
# 保存到Excel
with pd.ExcelWriter('subdivided_traffic_zones_and_od_matrix.xlsx') as writer:
od_matrix.to_excel(writer, sheet_name='Subdivided_OD_Matrix')
pd.DataFrame(new_grids).T.to_excel(writer, sheet_name='Subdivided_Grid_Bounds')
cursor.close()
connection.close()这里出来的结果也不理想，于是我又尝试一次，每次缩小范围，运行结果：
从上面的结果来看，可以将整个行程数据划分到几个交通小区中。
2.5 绘制聚类图和热力图
本实验使用K-Means聚类方法提取出租车的出行热点区域，即对出租车行程的起点和终点进行聚类分析，并通过百度地图或者python中的地图可视化工具对热点区域进行可视化展示。将上面的路径的起点、终点转换成百度坐标系，并输出到point.js文件中，代码：
import pymysql
import json
import urllib.request
# 数据库连接配置
db_config = {
'host': 'localhost',
'user': 'root',
'password': '123456',
'db': 'traffic_data',
'charset': 'utf8',
'cursorclass': pymysql.cursors.DictCursor
}
# 百度API密钥
baidu_ak = 'XNeLiUBdjxiq7miI5pB7nzZqLvqdSFAy'
# 定义坐标转换函数
def convert_to_baidu(lat, lng):
url = f"http://api.map.baidu.com/geoconv/v1/?coords={lng},{lat}&from=1&to=5&ak={baidu_ak}"
try:
response = urllib.request.urlopen(url)
data = json.loads(response.read())
if data['status'] == 0:
return data['result'][0]['x'], data['result'][0]['y']
else:
print(f"坐标转换失败: {lat}, {lng}")
return None, None
except Exception as e:
print(f"坐标转换异常: {e}")
return None, None
# 连接数据库
db = pymysql.connect(**db_config)
cursor = db.cursor()
# 查询坐标点
cursor.execute("SELECT LONGTITUDE1, LATITUDE1 FROM test3_travel_running")
results = cursor.fetchall()
# 准备热力图数据
points = []
for coord in results:
converted_lng, converted_lat = convert_to_baidu(coord['LATITUDE1'], coord['LONGTITUDE1'])
if converted_lng is not None and converted_lat is not None:
points.append({"lng": converted_lng, "lat": converted_lat, "count": 1})
print(converted_lng)
else:
print(f"Skipping coordinate conversion failed: {coord}")
# 将坐标点写入 JavaScript 文件
with open('points.js', 'w', encoding='utf-8') as js_file:
js_content = "var points = " + json.dumps(points, ensure_ascii=False) + ";"
js_file.write(js_content)
# 关闭数据库连接
cursor.close()
db.close()将出租车出行路径的起点、终点提取出来，然后使用K-Means聚类方法提取出租车的出行热点区域，代码：
import numpy as np
import pandas as pd
import folium
from folium.plugins import HeatMap
import pymysql
from pymysql import cursors
from sklearn.cluster import KMeans
# 数据库连接配置
db_config = {
'host': 'localhost',
'user': 'root',
'password': '123456',
'db': 'traffic_data',
'charset': 'utf8mb4',
'cursorclass': cursors.SSDictCursor # 使用服务器端游标
}
db = pymysql.connect(**db_config)
cursor = db.cursor()
cursor.execute("SELECT LONGTITUDE1, LATITUDE1, LONGTITUDE0, LATITUDE0 FROM test3_travel_running")
results = cursor.fetchall()
df = pd.DataFrame(results, columns=['LONGTITUDE1', 'LATITUDE1', 'LONGTITUDE0', 'LATITUDE0'])
# 提取起点和终点坐标，并合并到一个数组中
pickup_coords = df[['LONGTITUDE1', 'LATITUDE1']].values
dropoff_coords = df[['LONGTITUDE0', 'LATITUDE0']].values
X = np.concatenate((pickup_coords, dropoff_coords), axis=0)
# 使用K-Means聚类
'''
kmeans = KMeans(n_clusters=10, n_init=10, random_state=0) # 显式设置n_init的值
kmeans.fit(X)
labels = kmeans.labels_
# 可视化聚类结果
plt.figure(figsize=(10, 8))
sns.scatterplot(x=X[:, 0], y=X[:, 1], hue=labels, palette='viridis', s=50, edgecolor='none')
plt.title('K-Means Clustering of Taxi Trips with 10 Clusters')
plt.xlabel('Longitude')
plt.ylabel('Latitude')
plt.legend(title='Cluster', loc='upper left')
plt.grid(False)
plt.show()
'''
cursor.close()
db.close()运行代码，得到聚类结果：
聚类的结果通过散点图可视化，不同的聚类用不同的颜色表示，以便直观地查看哪些区域的出租车活动较为密集。从聚类结果来看，出租车行程密集在经度范围为（103，116）之间，纬度范围在（25,32）之间。
利用上面得到的出租车百度地图的轨迹点，绘制出租车出行轨迹热力图，HTML代码：
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta name="viewport" content="initial-scale=1.0, user-scalable=no" />
<style type="text/css">
body, html {width: 100%;height: 100%;margin:0;font-family:"微软雅黑";}
#allmap{width:700px;height:100%;}
p{margin-left:5px; font-size:14px;}
</style>
<script type="text/javascript" src="http://api.map.baidu.com/api?v=2.0&ak=XNeLiUBdjxiq7miI5pB7nzZqLvqdSFAy"></script>
<script type="text/javascript" src="point.js"></script>
<title>个性化地图设置页</title>
</head>
<body>
<div id="allmap"></div>
<div style="width:70px;height:280px;border:#ccc solid 0px;position:absolute; top:420px; left:630px" >
<img src="tu.png" width="64" height="276" />
</div>
</body>
</html>
<script type="text/javascript">
var map = new BMap.Map('allmap');
map.centerAndZoom(new BMap.Point(106.568056104,28.5432091717), 12);
map.addControl(new BMap.NavigationControl()); // 添加平移缩放控件
map.addControl(new BMap.ScaleControl()); // 添加比例尺控件
map.addControl(new BMap.OverviewMapControl()); //添加缩略地图控件
map.enableScrollWheelZoom(); //启用滚轮放大缩小
map.disable3DBuilding();
//个性化在线编辑器地址：http://lbsyun.baidu.com/custom/
var styleJson = [
{
"featureType": "land",
"elementType": "all",
"stylers": {
"lightness": 100,
"saturation": -100}
},
{
"featureType": "water",
"elementType": "all",
"stylers": {
"lightness": 47}
},
{
"featureType": "manmade",
"elementType": "geometry",
"stylers": {
"lightness": 28}
},
{
"featureType": "road",
"elementType": "geometry.fill",
"stylers": {
"lightness": 82}
},
{
"featureType": "road",
"elementType": "geometry.stroke",
"stylers": {
"lightness": -76}
},
{
"featureType": "green",
"elementType": "all",
"stylers": {
"lightness": 63,
"saturation": -100}
},
{
"featureType": "boundary",
"elementType": "geometry.fill",
"stylers": {
"lightness": 80,
"saturation": 1}
},
{
"featureType": "boundary",
"elementType": "geometry.stroke",
"stylers": {
"lightness": -75,
"saturation": -100}
}
]
map.setMapStyle({styleJson:styleJson});
//添加覆盖物
function add_overlay(){
for( var i=0;i<data_set1.length;i++){
var d_temp=data_set1[i].point;
var point_set=new Array();
for (var j=0;j<d_temp.length;j++){
point_set[j]=new BMap.Point(d_temp[j].split(",")[0],d_temp[j].split(",")[1]);
}
var rectangle = new BMap.Polygon(point_set, {strokeColor:"none", fillColor:"green", strokeWeight:1,fillOpacity:0.7, strokeOpacity:0.3}); //创建矩形
map.addOverlay(rectangle);
//增加矩形
}
for( var i=0;i<data_set2.length;i++){
var d_temp=data_set2[i].point;
var point_set=new Array();
for (var j=0;j<d_temp.length;j++){
point_set[j]=new BMap.Point(d_temp[j].split(",")[0],d_temp[j].split(",")[1]);
}
var rectangle = new BMap.Polygon(point_set, {strokeColor:"none", fillColor:"orange", strokeWeight:1,fillOpacity:0.7, strokeOpacity:0.3}); //创建矩形
map.addOverlay(rectangle);
//增加矩形
}
for( var i=0;i<data_set3.length;i++){
var d_temp=data_set3[i].point;
var point_set=new Array();
for (var j=0;j<d_temp.length;j++){
point_set[j]=new BMap.Point(d_temp[j].split(",")[0],d_temp[j].split(",")[1]);
}
var rectangle = new BMap.Polygon(point_set, {strokeColor:"none", fillColor:"red", strokeWeight:1,fillOpacity:0.7, strokeOpacity:0.3}); //创建矩形
map.addOverlay(rectangle);
//增加矩形
}
}
add_overlay()
</script>运行，得到热力图：
从上面的热力图可以看出，哪些地方的交通流量比较大，哪些相对比较少，有利于相关部门对交通进行监管。