【Python実践】GPS位置情報で車両の軌跡を分析しよう！

import pandas as pd
import numpy as np

def calc_gps_features(df, timestamp_col, lat_col, lon_col):
    """
    GPSデータから特徴量（距離、速度、加速度、角度）を計算する関数

    :param df: GPSデータを含むDataFrame
    :param timestamp_col: タイムスタンプのカラム名
    :param lat_col: 緯度のカラム名
    :param lon_col: 経度のカラム名
    :return: 特徴量を計算したDataFrame
    """
    # Haversine 公式による2つのGPS座標間の距離計算関数
    def haversine(lat1, lon1, lat2, lon2):
        R = 6371  # 地球の半径（km）
        d_lat = np.radians(lat2 - lat1)
        d_lon = np.radians(lon2 - lon1)
        a = np.sin(d_lat / 2) ** 2 + np.cos(np.radians(lat1)) * np.cos(np.radians(lat2)) * np.sin(d_lon / 2) ** 2
        c = 2 * np.arctan2(np.sqrt(a), np.sqrt(1 - a))
        return R * c

    # 2点間の角度を計算する関数
    def calculate_angle(lat1, lon1, lat2, lon2):
        return np.arctan2(lat2 - lat1, lon2 - lon1) * 180 / np.pi

    # 各ポイント間の距離を計算
    df['shifted_latitude'] = df[lat_col].shift(-1)
    df['shifted_longitude'] = df[lon_col].shift(-1)
    df['distance'] = df.apply(lambda row: haversine(row[lat_col], row[lon_col],
                                                    row['shifted_latitude'], row['shifted_longitude']), axis=1)

    # 各ポイント間の時間差（秒）を計算
    df['shifted_timestamp'] = df[timestamp_col].shift(-1)
    df['time_diff'] = (df['shifted_timestamp'] - df[timestamp_col]).dt.total_seconds()

    # 各ポイント間の速度（km/h）を計算
    df['speed'] = df['distance'] / (df['time_diff'] / 3600)  # km/h

    # 各ポイント間の加速度（km/h^2）を計算
    df['shifted_speed'] = df['speed'].shift(-1)
    df['acceleration'] = (df['shifted_speed'] - df['speed']) / (df['time_diff'] / 3600)  # km/h^2

    # 各ポイント間の角度を計算
    df['angle'] = df.apply(lambda row: calculate_angle(row[lat_col], row[lon_col],
                                                       row['shifted_latitude'], row['shifted_longitude']), axis=1)

    # 無効な値を含む最後の行を削除
    df = df.dropna()

    return df[[timestamp_col, 'distance', 'speed', 'acceleration', 'angle']]

#====================================================================================
# 使用例
#====================================================================================
data = {
    'timestamp': ['2022-11-25 08:00', '2022-11-25 08:05', '2022-11-25 08:10',
                  '2022-11-25 09:30', '2022-11-25 09:35', '2022-11-25 12:00',
                  '2022-11-25 12:05', '2022-11-25 14:30', '2022-11-25 14:35', '2022-11-25 17:00'],
    'latitude': [35.6899, 35.6895, 35.6898, 35.6902, 35.6904, 35.6902, 35.6906, 35.6909, 35.6910, 35.6913],
    'longitude': [139.6917, 139.6919, 139.6921, 139.6923, 139.6925, 139.6927, 139.6929, 139.6931, 139.6933, 139.6935]
}
df = pd.DataFrame(data)
df['timestamp'] = pd.to_datetime(df['timestamp'])

# 特徴量を計算
features_df = calc_gps_features(df, 'timestamp', 'latitude', 'longitude')
print(features_df)

#====================================================================================
# GPS の可視化
#====================================================================================
import folium
import webbrowser
import os

def mapping(df,lat_col,long_col,temp_file='gps_track.html'):  
    map = folium.Map(location=[df[lat_col].mean(), df[long_col].mean()],zoom_start=18,
                     tiles='https://cyberjapandata.gsi.go.jp/xyz/seamlessphoto/{z}/{x}/{y}.jpg',
                     attr='世界衛星モザイク画像')
    folium.PolyLine(df[[lat_col, long_col]].values, color='blue').add_to(map)
    map.save(temp_file) 
    webbrowser.open('file://' + os.path.realpath(temp_file))

# GPSの軌跡を地図にマッピング
mapping(df,'latitude','longitude')

import pandas as pd
import numpy as np

def calc_gps_features(df, timestamp_col, lat_col, lon_col,angle_threshold=10):
    """
    GPSデータから特徴量（距離、速度、加速度、角度）を計算する関数

    :param df: GPSデータを含むDataFrame
    :param timestamp_col: タイムスタンプのカラム名
    :param lat_col: 緯度のカラム名
    :param lon_col: 経度のカラム名
    :param angle_threshold: 直線と見なす角度の変化の閾値（度）
    :return: 特徴量を計算したDataFrame
    """
    # Haversine 公式による2つのGPS座標間の距離計算関数
    def haversine(lat1, lon1, lat2, lon2):
        R = 6371  # 地球の半径（km）
        d_lat = np.radians(lat2 - lat1)
        d_lon = np.radians(lon2 - lon1)
        a = np.sin(d_lat / 2) ** 2 + np.cos(np.radians(lat1)) * np.cos(np.radians(lat2)) * np.sin(d_lon / 2) ** 2
        c = 2 * np.arctan2(np.sqrt(a), np.sqrt(1 - a))
        return R * c * 1000

    # 2点間の角度を計算する関数
    def calculate_angle(lat1, lon1, lat2, lon2):
        """
        2点間の角度を計算する

        :param lat1: 最初の地点の緯度
        :param lon1: 最初の地点の経度
        :param lat2: 2番目の地点の緯度
        :param lon2: 2番目の地点の経度
        :return: 角度（度数法）
        """
        d_lon = np.radians(lon2 - lon1)
        lat1 = np.radians(lat1)
        lat2 = np.radians(lat2)
        
        x = np.sin(d_lon) * np.cos(lat2)
        y = np.cos(lat1) * np.sin(lat2) - np.sin(lat1) * np.cos(lat2) * np.cos(d_lon)
        
        bearing = np.degrees(np.arctan2(x, y))
        return (bearing + 360) % 360

    # 各ポイント間の距離を計算
    df['shifted_latitude'] = df[lat_col].shift(-1)
    df['shifted_longitude'] = df[lon_col].shift(-1)
    df['distance'] = df.apply(lambda row: haversine(row[lat_col], row[lon_col],
                                                    row['shifted_latitude'], row['shifted_longitude']), axis=1)   

    # 各ポイント間の時間差（秒）を計算
    df['shifted_timestamp'] = df[timestamp_col].shift(-1)
    df['time_diff'] = (df['shifted_timestamp'] - df[timestamp_col]).dt.total_seconds()

    # 各ポイント間の速度（km/h）を計算
    df['speed'] = (df['distance'] / df['time_diff'] ) * 3600 / 1000
    # 各ポイント間の加速度（km/h^2）を計算
    df['shifted_speed'] = df['speed'].shift(-1)
    df['acceleration'] = (df['shifted_speed'] - df['speed']) / (df['time_diff'] / 3600)  # km/h^2

    # 各ポイント間の角度を計算
    df['angle'] = df.apply(lambda row: calculate_angle(row[lat_col], row[lon_col],
                                                       row['shifted_latitude'], row['shifted_longitude']), axis=1)
    
    # 角度の変化を計算する
    relative_angle = np.diff(df['angle'])
    relative_angle = np.insert(relative_angle, 0, 0)  # 最初の要素を0で補完
    df['diff_angle'] = relative_angle

    # DataFrameの長さに合わせて補正
    df['relative_angle'] = relative_angle

    # プラスの変化があれば 360 を引く
    df['relative_angle'] = np.where(df['diff_angle'] > 270, df['diff_angle'] - 270, 
                                np.where(df['diff_angle'] > 180, df['diff_angle'] - 180, df['diff_angle'] * -1))

    # 直線の連番を付与する
    line_number = []
    current_line = 0
    for i in range(len(df)):
        if abs(df['diff_angle'].iloc[i]) <= angle_threshold:
            line_number.append(current_line)
        else:
            current_line += 1
            line_number.append(current_line)

    df['line_number'] = line_number

    # 無効な値を含む最後の行を削除
    df = df.iloc[:-1]

    return df[['timestamp', 'latitude','longitude','time_diff','distance', 'speed', 'acceleration', 'angle', 'diff_angle','relative_angle','line_number']]


#====================================================================================
# 使用例
#====================================================================================
data = {
    'timestamp': ['2022-11-25 08:00', '2022-11-25 08:05', '2022-11-25 08:10',
                  '2022-11-25 09:30', '2022-11-25 09:35', '2022-11-25 12:00',
                  '2022-11-25 12:05', '2022-11-25 14:30', '2022-11-25 14:35', 
                  '2022-11-25 17:00', '2022-11-25 17:50','2022-11-25 18:10'],
    'latitude': [35.6900, 35.6894, 35.6891, 35.6902, 35.6902, 35.6895, 35.6904, 35.6907, 35.6910, 35.6914, 35.6912, 35.6915],
    'longitude': [139.6920, 139.6919, 139.6921, 139.6923, 139.6925, 139.6928, 139.6929, 139.6930, 139.6935, 139.6935, 139.6933, 139.6930]
}
df = pd.DataFrame(data)
df['timestamp'] = pd.to_datetime(df['timestamp'])

# 特徴量を計算
features_df = calc_gps_features(df, 'timestamp', 'latitude', 'longitude')
print(features_df)

#====================================================================================
# GPS の可視化
#====================================================================================
import folium
from folium import plugins
import webbrowser
import os

def mapping(df,lat_col,long_col,temp_file='gps_track.html'):  
    map = folium.Map(location=[df[lat_col].mean(), df[long_col].mean()],zoom_start=18,
                     tiles='https://cyberjapandata.gsi.go.jp/xyz/seamlessphoto/{z}/{x}/{y}.jpg',
                     attr='全国最新写真（シームレス')
    layer = folium.FeatureGroup()
    polyline = folium.PolyLine(df[[lat_col, long_col]].values, color='blue').add_to(map)
    plugins.PolyLineTextPath(polyline, '   ►   ', repeat=True, attributes={'fill':'#FF0'}).add_to(layer)
    layer.add_to(map)
    map.save(temp_file) 
    webbrowser.open('file://' + os.path.realpath(temp_file))

# GPSの軌跡を地図にマッピング
mapping(df,'latitude','longitude')

import pandas as pd
import numpy as np

class GPSAnalyzer:
    def __init__(self, df):
        """
        GPSAnalyzerクラスの初期化

        :param df: GPSデータが含まれるDataFrame
        """
        self.df = df

    def haversine(self, lat1, lon1, lat2, lon2):
        """
        Haversine公式を使用して2つのGPS座標間の距離を計算する

        :param lat1: 最初の地点の緯度
        :param lon1: 最初の地点の経度
        :param lat2: 2番目の地点の緯度
        :param lon2: 2番目の地点の経度
        :return: 距離（キロメートル）
        """
        R = 6371  # 地球の半径（km）
        d_lat = np.radians(lat2 - lat1)
        d_lon = np.radians(lon2 - lon1)
        a = np.sin(d_lat / 2) ** 2 + np.cos(np.radians(lat1)) * np.cos(np.radians(lat2)) * np.sin(d_lon / 2) ** 2
        c = 2 * np.arctan2(np.sqrt(a), np.sqrt(1 - a))
        return R * c

    def calculate_angle(self, lat1, lon1, lat2, lon2):
        """
        2点間の角度を計算する

        :param lat1: 最初の地点の緯度
        :param lon1: 最初の地点の経度
        :param lat2: 2番目の地点の緯度
        :param lon2: 2番目の地点の経度
        :return: 角度（度数法）
        """
        d_lon = np.radians(lon2 - lon1)
        lat1 = np.radians(lat1)
        lat2 = np.radians(lat2)
        
        x = np.sin(d_lon) * np.cos(lat2)
        y = np.cos(lat1) * np.sin(lat2) - np.sin(lat1) * np.cos(lat2) * np.cos(d_lon)
        
        bearing = np.degrees(np.arctan2(x, y))
        return (bearing + 360) % 360


    def do_lines_intersect(self, p1, p2, p3, p4):
        """
        2つの線分が交差するかどうかを判定する

        :param p1: 線分1の始点
        :param p2: 線分1の終点
        :param p3: 線分2の始点
        :param p4: 線分2の終点
        :return: 交差する場合はTrue、そうでない場合はFalse
        """
        def ccw(A, B, C):
            return (C[1] - A[1]) * (B[0] - A[0]) > (B[1] - A[1]) * (C[0] - A[0])
        return ccw(p1, p3, p4) != ccw(p2, p3, p4) and ccw(p1, p2, p3) != ccw(p1, p2, p4)

    def count_intersections(self, gps_data):
        """
        GPSデータから交差点の数をカウントする
        :param gps_data: (latitude, longitude)のタプルのリスト
        :return: 交差点の数
        """
        lines = list(zip(gps_data[:-1], gps_data[1:]))
        intersect_count = 0
        for i in range(len(lines)):
            for j in range(i + 2, len(lines)):  # i+1の線分は隣接するのでスキップ
                if self.do_lines_intersect(lines[i][0], lines[i][1], lines[j][0], lines[j][1]):
                    intersect_count += 1
        return intersect_count


    def calculate_angle_rad(self, lat1, lon1, lat2, lon2):
        """
        2点間の角度をラジアンで計算する

        :param lat1: 最初の地点の緯度
        :param lon1: 最初の地点の経度
        :param lat2: 2番目の地点の緯度
        :param lon2: 2番目の地点の経度
        :return: 角度（ラジアン）
        """
        return np.arctan2(lat2 - lat1, lon2 - lon1)

    def count_parallel_segments(self, angles, tolerance=np.radians(5)):
        """
        平行線の数をカウントする

        :param angles: 各セグメントの角度のリスト
        :param tolerance: 平行と見なす角度の許容範囲（ラジアン）
        :return: 平行線の数
        """
        parallel_count = 0
        n = len(angles)

        for i in range(n):
            for j in range(i + 1, n):
                if np.abs((angles[i] - angles[j] + np.pi) % (2 * np.pi) - np.pi) < tolerance:
                    parallel_count += 1
        return parallel_count

    def count_straight_segments(self, angles, lengths, straight_tolerance=np.radians(5)):
        """
        直線の最大・最小・平均の長さを計算する

        :param angles: 各セグメントの角度のリスト
        :param lengths: 各セグメントの長さのリスト
        :param straight_tolerance: 直線と見なす角度の許容範囲（ラジアン）
        :return: (直線の数, 最大長, 最小長, 平均長)
        """
        if len(angles) == 0 or len(lengths) == 0:
            return 0, 0, 0, 0

        straight_count = 1
        current_length = lengths[0]
        segment_lengths = []

        for i in range(1, len(angles)):
            # 角度差が許容範囲内なら同じ直線のセグメントとして加算
            if np.abs(angles[i] - angles[i - 1]) < straight_tolerance:
                current_length += lengths[i]
            else:
                # 角度差が許容範囲を超えたら直線が切り替わる
                segment_lengths.append(current_length)
                straight_count += 1
                current_length = lengths[i]

        # 最後の直線を追加
        segment_lengths.append(current_length)

        # 最大・最小・平均を計算
        max_length = np.max(segment_lengths)
        min_length = np.min(segment_lengths)
        avg_length = np.mean(segment_lengths)

        return straight_count, max_length, min_length, avg_length

    def count_bent_segments(self, angles, bent_tolerance=np.radians(30)):
        """
        曲がった線の数をカウントする

        :param angles: 各セグメントの角度のリスト
        :param bent_tolerance: 曲がった線と見なす角度の許容範囲（ラジアン）
        :return: 曲がった線の数
        """
        bent_count = 0
        for i in range(1, len(angles)):
            if np.abs(angles[i] - angles[i - 1]) > bent_tolerance:
                bent_count += 1
        return bent_count

    def analyze_gps(self, df,time_col,lat_col,long_col):
        """
        グループ内のGPSデータを分析する
        :param df: GPSデータを格納したDataFrame
        :param time_col: 時刻のカラム名
        :param lat_col: 緯度のカラム名
        :param long_col: 経度のカラム名
        :return: 特徴量を含むDataFrame
        """
        df = df.sort_values(by=time_col)
        df['shifted_latitude'] = df[lat_col].shift(-1)
        df['shifted_longitude'] = df[long_col].shift(-1)
        df['距離'] = df.apply(lambda row: self.haversine(row[lat_col], row[long_col],
                                                               row['shifted_latitude'], row['shifted_longitude']), axis=1)
        df['shifted_timestamp'] = df[time_col].shift(-1)
        df['時間差'] = (df['shifted_timestamp'] - df[time_col]).dt.total_seconds()
        df['速度'] = np.where(df['時間差'] > 0, (df['距離'] / (df['時間差']) * 3600 / 1000), 0)
        df['shifted_speed'] = df['速度'].shift(-1)
        df['加速度'] = np.where(df['時間差'] > 0, (df['shifted_speed'] - df['速度']) / (df['時間差'] / 3600), 0)
        df['角度'] = df.apply(lambda row: self.calculate_angle(row[lat_col], row[long_col],
                                                                      row['shifted_latitude'], row['shifted_longitude']), axis=1)
        move_threshold = 0.01
        df['移動中'] = df['距離'] > move_threshold
        total_move_time = df[df['移動中']]['時間差'].sum()
        total_stop_time = df[~df['移動中']]['時間差'].sum()

        gps_data = list(zip(df[lat_col], df[long_col]))
        intersect_count = self.count_intersections(gps_data)
        angles_rad = [self.calculate_angle_rad(gps_data[i][0], gps_data[i][1], gps_data[i+1][0], gps_data[i+1][1]) for i in range(len(gps_data) - 1)]
        parallel_count = self.count_parallel_segments(angles_rad)
        straight_count,straight_max,straight_min,straight_ave = self.count_straight_segments(angles_rad,df['距離'])
        bent_count = self.count_bent_segments(angles_rad)

        stats = {
            '速度': {
                '平均': df['速度'].mean(),
                '最小': df['速度'].min(),
                '最大': df['速度'].max(),
                '標準偏差': df['速度'].std(),
                '分散': df['速度'].var()
            },
            '距離': {
                '平均': df['距離'].mean(),
                '最小': df['距離'].min(),
                '最大': df['距離'].max(),
                '標準偏差': df['距離'].std(),
                '分散': df['距離'].var()
            },
            '加速度': {
                '平均': df['加速度'].mean(),
                '最小': df['加速度'].min(),
                '最大': df['加速度'].max(),
                '標準偏差': df['加速度'].std(),
                '分散': df['加速度'].var()
            },
            '角度': {
                '平均': df['角度'].mean(),
                '最小': df['角度'].min(),
                '最大': df['角度'].max(),
                '標準偏差': df['角度'].std(),
                '分散': df['角度'].var()
            }
        }

        feature_data = {
            'データ件数': len(df),
            '停止時間合計': total_stop_time,
            '移動時間合計': total_move_time,
            '平行線数': parallel_count,
            '曲がった回数': bent_count,
            '交差線数': intersect_count,
            '直線の数': straight_count,
            '直線の数(最小)': straight_max,
            '直線の数(最大)': straight_min,
            '直線の数(平均)': straight_ave,
            '速度平均': stats['速度']['平均'],
            '速度最小': stats['速度']['最小'],
            '速度最大': stats['速度']['最大'],
            '速度標準偏差': stats['速度']['標準偏差'],
            '速度分散': stats['速度']['分散'],
            '距離平均': stats['距離']['平均'],
            '距離最小': stats['距離']['最小'],
            '距離最大': stats['距離']['最大'],
            '距離標準偏差': stats['距離']['標準偏差'],
            '距離分散': stats['距離']['分散'],
            '加速度平均': stats['加速度']['平均'],
            '加速度最小': stats['加速度']['最小'],
            '加速度最大': stats['加速度']['最大'],
            '加速度標準偏差': stats['加速度']['標準偏差'],
            '加速度分散': stats['加速度']['分散'],
            '角度平均': stats['角度']['平均'],
            '角度最小': stats['角度']['最小'],
            '角度最大': stats['角度']['最大'],
            '角度標準偏差': stats['角度']['標準偏差'],
            '角度分散': stats['角度']['分散']
        }

        return pd.DataFrame([feature_data])

    def analyze(self,group_keys,time_col,lat_col,long_col):
        """
        車両番号と日付でグルーピングし、各グループに対して特徴量を計算する

        :param group_keys: グルーピングのカラムリスト [key1,key2,･･･]        
        :param time_col: 時刻のカラム名
        :param lat_col: 緯度のカラム名
        :param long_col: 経度のカラム名
        :return: 各グループの特徴量を含むDataFrame
        """
        results = self.df.groupby(group_keys, as_index=False, group_keys=False).apply(lambda x:self.analyze_gps(x,time_col,lat_col,long_col),include_groups=False).reset_index(drop=True)
        return results

#========================================================================
# 使用例
#========================================================================
# データをリスト形式で格納
data = [
    ["A01","2024-01-01 08:00:00", 35.689500, 139.692806],
    ["A01","2024-01-01 08:10:00", 35.688641, 139.692806],
    ["A01","2024-01-01 08:25:00", 35.688641, 139.691811],
    ["A01","2024-01-01 08:30:00", 35.689410, 139.691811],
    ["A01","2024-01-01 08:40:00", 35.689410, 139.692695],
    ["A01","2024-01-01 08:50:00", 35.688731, 139.692695],
    ["A01","2024-01-01 09:10:00", 35.688731, 139.691921],
    ["A01","2024-01-01 09:20:00", 35.689319, 139.691921],
    ["A01","2024-01-01 09:35:00", 35.689319, 139.692585],
    ["A01","2024-01-01 09:40:00", 35.688822, 139.692585],
    ["A01","2024-01-01 09:50:00", 35.688370, 139.692585]
]

# DataFrameに変換
df = pd.DataFrame(data, columns=['id','timestamp', 'latitude', 'longitude'])
df['timestamp'] = pd.to_datetime(df['timestamp'])
df['date'] = df['timestamp'].dt.date

analyzer = GPSAnalyzer(df)
result_df = analyzer.analyze(['id', 'date'],"timestamp","latitude","longitude")

print(result_df)


#====================================================================================
# GPS の可視化
#====================================================================================
import folium
from folium import plugins
import webbrowser
import os

def mapping(df,lat_col,long_col,temp_file='gps_track.html'):  
    map = folium.Map(location=[df[lat_col].mean(), df[long_col].mean()],zoom_start=18,
                     tiles='https://cyberjapandata.gsi.go.jp/xyz/seamlessphoto/{z}/{x}/{y}.jpg',
                     attr='世界衛星モザイク画像')
    layer = folium.FeatureGroup()
    polyline = folium.PolyLine(df[[lat_col, long_col]].values, color='blue').add_to(map)
    plugins.PolyLineTextPath(polyline, '   ►   ', repeat=True, attributes={'fill':'#FF0'}).add_to(layer)
    layer.add_to(map)
    map.save(temp_file) 
    webbrowser.open('file://' + os.path.realpath(temp_file))

# GPSの軌跡を地図にマッピング
mapping(df,'latitude','longitude')

# pip install folium
# pip install celenium
# https://storage.googleapis.com/chrome-for-testing-public/128.0.6613.119/win64/chromedriver-win64.zip
import time
import folium
from folium import plugins
import webbrowser
import pandas as pd

class GpsPlot:
    def __init__(self,tiles = 0):
        """
        GpsPlotクラスの初期化
        :param tiles: タイルの種類（0: openstreetmap, 1: 全国最新写真（シームレス））
        """   
        self.gps_data = []
        self.map = None
        if tiles == 1:
            self.tiles = "https://cyberjapandata.gsi.go.jp/xyz/seamlessphoto/{z}/{x}/{y}.jpg"
            self.attr = "全国最新写真（シームレス）"
        else:
           self.tiles = "https://tile.openstreetmap.org/{z}/{x}/{y}.png"
           self.attr = "openstreetmap"

    def read_gps_file(self,file_name):
        """
        GPSデータをファイルから読み込む
        :param file_name: GPSデータが格納されたファイルの名前
        :return: (latitude, longitude)のタプルのリスト
        """
        gps_data = []
        with open(file_name, 'r') as file:
            for line in file:
                # 行をトリムして、カンマで分割
                lat, lon = map(float, line.strip().split(','))
                gps_data.append((lat, lon))
            self.gps_data = gps_data
        return gps_data

    def read_dataframe(self,df, lat_col, lon_col):
        """
        GPSデータをDataFrameから読み込む

        :param df: GPSデータが格納されたDataFrame
        :param lat_col: 緯度データを含むカラムの名前
        :param lon_col: 経度データを含むカラムの名前
        :return: (latitude, longitude)のタプルのリスト
        """
        self.gps_data = list(df[[lat_col, lon_col]].itertuples(index=False, name=None))
        return self.gps_data
    
    def calculate_center_and_zoom(self,gps_data):
        """
        中心座標とズームレベルを計算する
        :param gps_data: (latitude, longitude)のタプルのリスト
        :return: (中心緯度, 中心経度, ズームレベル)
        """
        # 緯度と経度のリストに分解
        latitudes = [lat for lat, lon in gps_data]
        longitudes = [lon for lat, lon in gps_data]

        # 中心座標を計算
        center_lat = sum(latitudes) / len(latitudes)
        center_lon = sum(longitudes) / len(longitudes)
        
        # 緯度と経度の範囲を計算
        lat_range = (min(latitudes), max(latitudes))
        lon_range = (min(longitudes), max(longitudes))

        # 緯度と経度の範囲からズームレベルを計算
        lat_diff = lat_range[1] - lat_range[0]
        lon_diff = lon_range[1] - lon_range[0]

        # ズームレベルの計算（適宜調整が必要）
        zoom_level = 14  # デフォルトのズームレベル
        if lat_diff > 5 or lon_diff > 5:
            zoom_level = 10  # 広範囲の場合
        elif lat_diff > 1 or lon_diff > 1:
            zoom_level = 12  # 中程度の範囲

        return center_lat,center_lon,zoom_level

    def plot_gps(self,gps_data = None):
        """
        GPSデータを地図にプロットする
        :param gps_data: (latitude, longitude)のタプルのリスト
        """
        if gps_data is None:
            gps_data = self.gps_data

        # 無効なGPSデータを除外する
        gps_data = [coord for coord in gps_data if coord != (0.0, 0.0)]

        # ズームレベルを計算
        center_lat,center_lon,zoom_start = self.calculate_center_and_zoom(gps_data)

        # 地図の初期化
        self.map = folium.Map(location=[center_lat, center_lon], zoom_start=zoom_start,
                        tiles=self.tiles,attr=self.attr)
        layer = folium.FeatureGroup()

        # ポリラインを地図に追加
        polyline = folium.PolyLine(gps_data, popup='GPS Data', color="blue", weight=3).add_to(layer)
        polyline_text = plugins.PolyLineTextPath(polyline, '   ►   ', repeat=True, attributes={'fill':'#FF0'}).add_to(layer)

        layer.add_to(self.map)
        self.map.fit_bounds(layer.get_bounds())

    def plot_marker(self,locations,color="red"):
        """
        地図にマーカーを追加する
        :param locations: {"name": (latitude, longitude)} の辞書
        :param color: マーカーの色
        """
        for name,location in locations.items():
            folium.Marker(
                location=location,
                
                popup=name,
                icon=folium.Icon(color=color, icon="info-sign")
                ).add_to(self.map)

    def plot_circle(self,location,radius=80,color="bule",fill_color="#ffff00"):
        """
        地図にサークルマーカーを追加する
        :param location: (latitude, longitude) のタプル
        :param radius: サークルの半径
        :param color: サークルの色
        :param fill_color: サークルの塗りつぶし色
        """
        folium.CircleMarker(
        location=location,
        radius=radius,
        color=color, #カラーコード
        fill_color=fill_color #カラーコード
        ).add_to(self.map)

    def show(self,filename = None):
        """
        地図を表示する
        :param filename: 保存するファイル名（指定しない場合は 'map.html'）
        """
        if filename is None:
            self.map.save('map.html')
            webbrowser.open('map.html')
        else:
            webbrowser.open(filename)

    def save(self,filename):
        """
        地図を保存する
        :param filename: 保存するファイル名
        """
        self.map.save(filename)

import time
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager

def save_screenshot(html, image_file):
    # ChromeDriverのパスを指定してブラウザオプションを設定
    options = webdriver.ChromeOptions()
    options.add_argument('--headless')  # ヘッドレスモードで実行
    options.add_argument('--disable-gpu')  # Windowsでの描画バグを避けるため
    options.add_argument('--no-sandbox')  # サンドボックスを無効化（Linux用）
    
    # WebDriverの設定
    service = Service(ChromeDriverManager().install())
    driver = webdriver.Chrome(service=service, options=options)
    
    # 指定されたHTMLファイルを開く
    driver.get('file://' + html)
    
    # ページが完全に読み込まれるのを待つ
    time.sleep(2)
    
    # スクリーンショットを保存
    driver.save_screenshot(image_file)
    
    # ブラウザを終了
    driver.quit()


#====================================================================================
# 使用例
#====================================================================================
data = {
    'timestamp': ['2022-11-25 08:00', '2022-11-25 08:05', '2022-11-25 08:10',
                  '2022-11-25 09:30', '2022-11-25 09:35', '2022-11-25 12:00',
                  '2022-11-25 12:05', '2022-11-25 14:30', '2022-11-25 14:35', '2022-11-25 17:00'],
    'latitude': [35.6899, 35.6895, 35.6898, 35.6902, 35.6904, 35.6902, 35.6906, 35.6909, 35.6910, 35.6913],
    'longitude': [139.6917, 139.6919, 139.6921, 139.6923, 139.6925, 139.6927, 139.6929, 139.6931, 139.6933, 139.6935]
}
df = pd.DataFrame(data)
df['timestamp'] = pd.to_datetime(df['timestamp'])


gp = GpsPlot(0)
gp.read_dataframe(df,'latitude','longitude')
gp.plot_gps()
gp.plot_marker({'開始':(35.6899, 139.6917),'終了':(35.6913,  139.6935)})
gp.plot_circle([35.6899, 139.6917],color='red',fill_color='red')
gp.plot_circle([35.6913,  139.6935],color='blue',fill_color='blue')
gp.show()

#gp.save("p:/gps.html")
#save_screenshot("p:/gps.html",'p:/map.png')