轨迹预测相关图片

# 地图可视化脚本 - 用于显示Waymo场景的地图和轨迹🤓
![scenario_1abcfdd308a41e50.png](https://blog.everyreach.wiki/static/img/be5b3520f2562526a5f711c54c6e8d4c.scenario_1abcfdd308a41e50.webp)



```js
"""
地图可视化脚本 - 用于显示Waymo场景的地图和轨迹
"""
import os
import pickle
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from waymo_open_dataset.protos import scenario_pb2

# 使用相对导入
import sys
sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
from src.utils.config import DATA_CONFIG

def visualize_scenario(scenario_id: str, split: str = 'train'):
    """
    可视化单个场景的地图和轨迹
    
    Args:
        scenario_id: 场景ID
        split: 数据集划分 ('train', 'valid', 'test')
    """
    # 创建图形
    plt.figure(figsize=(30, 30))
    plt.rcParams['axes.facecolor'] = 'grey'
    
    # 加载场景数据
    processed_file = os.path.join(DATA_CONFIG['waymo_path'], 'processed', split, f'sample_{scenario_id}.pkl')
    if not os.path.exists(processed_file):
        print(f"场景 {scenario_id} 不存在")
        return
    
    with open(processed_file, 'rb') as f:
        scenario_data = pickle.load(f)
    
    # 画地图线
    for map_feature in scenario_data['map_features']:
        # 车道线
        if hasattr(map_feature, 'lane') and map_feature.lane:
            line_x = [point.x for point in map_feature.lane.polyline]
            line_y = [point.y for point in map_feature.lane.polyline]
            plt.scatter(line_x, line_y, c='g', s=5)
        
        # 边界线
        if hasattr(map_feature, 'road_edge') and map_feature.road_edge:
            road_edge_x = [point.x for point in map_feature.road_edge.polyline]
            road_edge_y = [point.y for point in map_feature.road_edge.polyline]
            
            if map_feature.road_edge.type == 2:  # 道路边界
                plt.scatter(road_edge_x, road_edge_y, c='k')
            elif map_feature.road_edge.type == 3:  # 道路边界（特殊类型）
                plt.scatter(road_edge_x, road_edge_y, c='purple')
            else:
                plt.scatter(road_edge_x, road_edge_y, c='k')
        
        # 道路标线
        if hasattr(map_feature, 'road_line') and map_feature.road_line:
            road_line_x = [point.x for point in map_feature.road_line.polyline]
            road_line_y = [point.y for point in map_feature.road_line.polyline]
            
            if map_feature.road_line.type == 7:  # 双实黄线
                plt.plot(road_line_x, road_line_y, c='y')
            elif map_feature.road_line.type == 8:  # 双虚实黄线
                plt.plot(road_line_x, road_line_y, c='y')
            elif map_feature.road_line.type == 6:  # 单实黄线
                plt.plot(road_line_x, road_line_y, c='y')
            elif map_feature.road_line.type == 1:  # 单虚白线
                for i in range(int(len(road_line_x)/7)):
                    plt.plot(road_line_x[i*7:5+i*7], road_line_y[i*7:5+i*7], color='w')
            elif map_feature.road_line.type == 2:  # 单实白线
                plt.plot(road_line_x, road_line_y, c='w')
            else:
                plt.plot(road_line_x, road_line_y, c='w')
    
    # 画车辆轨迹
    for track in scenario_data['tracks']:
        # 提取轨迹点
        traj_x = [state.center_x for state in track.states if state.valid]
        traj_y = [state.center_y for state in track.states if state.valid]
        
        if not traj_x or not traj_y:
            continue
            
        # 如果是自动驾驶车辆
        if track.id == scenario_data['sdc_track_index']:
            plt.scatter(traj_x[0], traj_y[0], s=140, c='r', marker='s')  # 起始点
            plt.scatter(traj_x, traj_y, s=14, c='r')  # 轨迹
        else:
            plt.scatter(traj_x[0], traj_y[0], s=140, c='k', marker='s')  # 起始点
            plt.scatter(traj_x, traj_y, s=14, c='b')  # 轨迹
    
    # 设置标题和坐标轴
    plt.title(f'Scenario {scenario_id}', fontsize=20)
    plt.xlabel('X (meters)', fontsize=16)
    plt.ylabel('Y (meters)', fontsize=16)
    
    # 保存图像
    output_dir = os.path.join(DATA_CONFIG['waymo_path'], 'visualizations', split)
    os.makedirs(output_dir, exist_ok=True)
    plt.savefig(os.path.join(output_dir, f'scenario_{scenario_id}.png'))
    plt.close()

def visualize_random_scenarios(split: str = 'train', num_scenarios: int = 5):
    """
    随机可视化多个场景
    
    Args:
        split: 数据集划分 ('train', 'valid', 'test')
        num_scenarios: 要可视化的场景数量
    """
    processed_dir = os.path.join(DATA_CONFIG['waymo_path'], 'processed', split)
    scenario_files = [f for f in os.listdir(processed_dir) if f.startswith('sample_')]
    
    # 随机选择场景
    selected_scenarios = np.random.choice(scenario_files, min(num_scenarios, len(scenario_files)), replace=False)
    
    for scenario_file in selected_scenarios:
        scenario_id = scenario_file.replace('sample_', '').replace('.pkl', '')
        print(f"正在可视化场景: {scenario_id}")
        visualize_scenario(scenario_id, split)

if __name__ == "__main__":
    # 可视化训练集中的指定个随机场景
    visualize_random_scenarios('train', 20) 
```
# 其中DATA_CONFIG配置为地址即可，参考如下：
```
# 数据集配置
DATA_CONFIG = {
    'waymo_path': '/mnt/f/waymoMotion/motionData/waymo_data',  # Waymo数据集根目录
    'train_path': '/mnt/f/waymoMotion/motionData/waymo_data/train',  # 训练集路径
    'valid_path': '/mnt/f/waymoMotion/motionData/waymo_data/valid',  # 验证集路径
    'test_path': '/mnt/f/waymoMotion/motionData/waymo_data/test',  # 测试集路径
}

```

# 最后展示效果随机选择展示如下：

![scenario_2bc9a54a3e0ea7f.png](https://blog.everyreach.wiki/static/img/ef7bfefad40d3678eccc7caec81a06fc.scenario_2bc9a54a3e0ea7f.webp)

![scenario_5ebe8cf3e58f7575.png](https://blog.everyreach.wiki/static/img/d77a0d220d0e86ce8a1116f8e89ea16c.scenario_5ebe8cf3e58f7575.webp)

![scenario_27b332c95da0792c.png](https://blog.everyreach.wiki/static/img/3bd90595bd9c0b2cc448fd8bf0d2e468.scenario_27b332c95da0792c.webp)

![scenario_12523c13c5c44ecb.png](https://blog.everyreach.wiki/static/img/67697549174adf48b2f6661f01bc8799.scenario_12523c13c5c44ecb.webp)



![scenario_aa47c21dd66359f7.png](https://blog.everyreach.wiki/static/img/33dab5d3667b495f50e63b8b7b5279a8.scenario_aa47c21dd66359f7.webp)

![scenario_b93cf98ad34ffa3a.png](https://blog.everyreach.wiki/static/img/25b2dc94d93a94f3815c79db687b4933.scenario_b93cf98ad34ffa3a.webp)

![scenario_d2830c5c4b02fe38.png](https://blog.everyreach.wiki/static/img/5003124234a74ef423d8ef695c9fe2d3.scenario_d2830c5c4b02fe38.webp)

![scenario_f4d028153147147.png](https://blog.everyreach.wiki/static/img/d9b3750d1eac8971debb49bde084b292.scenario_f4d028153147147.webp)



:::info{title="相关信息"}
本篇代码受
https://blog.csdn.net/weixin_50232758/article/details/132260047
启发，如有侵权回复删除
:::

Waymo motion车道可视化

# 基于Java中 Random随机函数的抽奖

这篇博客介绍了一个基于Java的简单随机抽奖程序。通过Random类，作者创建了一个静态内部类`TestSuiJi`，并实现了从预定义的抽奖内容数组中随机抽取幸运儿的功能。程序会连续抽出五位幸运儿并打印结果。这个简单的抽奖应用可以作为理解Java随机数生成和数组操作的基础示例。



```
package Radom;
import java.util.Random;
public class StudentRadom {
    public static class TestSuiJi {
        //ramdom抽签
        static String[] s1 = new String[]{
                //抽奖内容
        };
        public static void main(String[] args) {
            Random random = new Random();
 


            System.out.println("参与抽奖人数为"+s1.length);
            for (int i = 1; i <6; i++) {
                int b = random.nextInt(s1.length);
                System.out.println("幸运儿:"+s1[b]);
            }
        }
    }
}

Java：点名器简易版

# 实现一个等腰杨辉三角
 


```
import java.util.Scanner;
public class yhsj {

    public static void main(String[] args) {
                yh();
            }
            /*
            外层循环的是行，内层循环的是行里的长度。
            要输出等腰三角，可以通过打印空格实现。
            如果是行首或者行末则为 1，否则当前索引 j 元素的值，等于前一行索引 j-1，加上索引 j 的值
            使用 System.out.printf("%4s",yh[i][j]+" ");可以格式化输出结果
             */


    public static void yh() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入打印行数");
        int n = scanner.nextInt();
        int yh[][]=new int[n][]; //定义二维数组；必须设置一维长度
        int sum=0; //总和

        //遍历二维数组
        for(int i=0;i<n;i++) {
            yh[i]=new int[i+1];//申请空间，第i行有i+1个数（i从0开始）
            for(int j=0;j<n-i-1;j++) {//打印等腰三角前面的空格
                System.out.print("  ");//两个空格
            }
            //遍历一维数组
            for(int j=0;j<i+1;j++) {
                if(j==0||j==yh[i].length-1) {//行首行末为1
                    yh[i][j]=1;
                }else {
                    //当前一维数组的索引n元素的值，等于前一个数组索引n-1，加上索引n的值
                    yh[i][j]=yh[i-1][j]+yh[i-1][j-1];
                }
                //格式化输出元素值
                System.out.printf("%4s",yh[i][j]+" ");
                //求和
                sum += yh[i][j];
            }
            //换行
            System.out.println();
        }
        //输出总和
        System.out.print("\n"+"前十行和为："+sum);
    }
}
```

Java入门算法：杨辉三角代码示例

# 获取你所拥有的宝石的数量




`
import java.util.Scanner;

public class 宝石 {
    public static void main(String[] args) {
        m1();
    }

    public static void m1() {
        //你想知道你拥有的石头中有多少是宝石。
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入宝石的类型");
        String bs = scanner.next();
        System.out.println("输入你所拥有的宝石");
        String ihava = scanner.next();

        char[] arr1 = bs.toCharArray();//转成char数组
        char[] arr2 = ihava.toCharArray();//转成char数组
        int c = 0;//定义接收值
        for (int i = 0; i < arr1.length; i++) {//遍历arr1
            char a = arr1[i];
            for (int j = 0; j < arr2.length; j++) {//遍历arr2
                char b = arr2[j];
                if (a == b) {
                    c++;
                }
            }
        }
        System.out.println(c);
    }`