2024年华为杯数学建模E题-高速公路应急车道启用建模-基于YOLO8的数据处理代码参考（无偿分享）

news2024/11/15 8:22:18

利用YOLO模型进行高速公路交通流量分析

识别效果：
在这里插入图片描述

免责声明

本文所提供的信息和内容仅供参考。尽管我尽力确保所提供信息的准确性和可靠性，但我们不对其完整性、准确性或及时性作出任何保证。使用本文信息所造成的任何直接或间接损失，本人概不负责。请在做出任何决策之前自行进行必要的研究和咨询专业人士。

无偿提供代码，感谢点赞、收藏与关注！

随着交通管理的日益重要，自动化监测系统的需求也随之增加。利用计算机视觉技术，我们可以高效地分析视频中的车辆流量，提升交通管理的科学性和有效性。本文将详细介绍如何使用YOLO（You Only Look Once）模型分析高速公路的交通流，结合视频数据提取车辆信息、速度计算和流量分析。整个过程将结合代码，逐步解析每个步骤的细节及其背后的原理。

1. 问题背景

在交通流量分析中，实时监测和处理车辆数据是一个具有挑战性的任务。我们希望能够快速且准确地识别视频中的车辆，并计算它们的速度、流量和密度。为此，我们将使用YOLO模型来进行目标检测，结合一些图像处理技术，分析交通状况。

2. 准备工作

在开始之前，我们需要确保安装必要的库，包括OpenCV、Pandas、NumPy、YOLO等。以下是我们将用到的库：

import cv2
import pandas as pd
import numpy as np
from ultralytics import YOLO
from datetime import datetime
from scipy.spatial import distance

3. 计算视频时长

首先，我们需要计算视频的时长，以便在后续处理中使用。以下是计算视频时长的函数：

def calculate_duration(start_time, end_time):
    fmt = '%H:%M:%S'
    start = datetime.strptime(start_time, fmt)
    end = datetime.strptime(end_time, fmt)
    duration = end - start
    return duration

在这个函数中，我们使用datetime模块将输入的开始时间和结束时间转换为datetime对象，并计算它们之间的差值，这就是视频的总时长。

4. 获取视频信息

我们需要从视频中提取一些关键信息，例如总帧数、帧率和每帧的时间间隔。可以使用以下函数来实现：

def get_video_info(video_path, duration):
    cap = cv2.VideoCapture(video_path)

    if not cap.isOpened():
        raise ValueError("无法打开视频文件")

    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    fps = cap.get(cv2.CAP_PROP_FPS)
    frame_time = 1 / fps if fps > 0 else 0
    interval_time = duration.total_seconds() / total_frames if total_frames > 0 else 0

    cap.release()
    return total_frames, fps, frame_time, interval_time

这个函数会返回视频的总帧数、帧率、每帧时间以及每帧之间的时间间隔，供后续处理使用。

初始化路径和视频时长

接下来，我们需要初始化视频路径和时长：

video_path = './高速公路交通流数据/32.31.250.103/20240501_20240501125647_20240501140806_125649.mp4'
duration = calculate_duration('12:56:47', '14:08:05')
total_frames, fps, frame_time, interval_time = get_video_info(video_path, duration)

5. 加载YOLO模型

我们将加载预训练的YOLOv8模型以进行目标检测：

model = YOLO('yolov8n.pt')

这一步确保我们有一个强大的目标检测模型，可以处理视频中的车辆检测。

6. 处理视频帧

我们将处理视频的前10%帧，以减少计算量并专注于关键时刻。以下是相关代码：

num_frames_to_process = total_frames // 1
frame_count = 0

# 存储车辆信息
vehicle_data = {}
unique_vehicle_counter = 0
data = []

6.1 定义参数

我们还需要定义一些判断参数，以帮助后续判断车辆是否为同一辆车：

IOU_THRESHOLD = 0.3
MAX_MOVEMENT_DISTANCE = 50
MAX_SIZE_DIFFERENCE = 0.2
COLOR_THRESHOLD = 30
  • IOU_THRESHOLD：用于判断车辆边界框重叠的阈值。
  • MAX_MOVEMENT_DISTANCE：判断车辆在相邻帧之间的最大移动距离。
  • MAX_SIZE_DIFFERENCE：判断车辆大小差异的最大阈值。
  • COLOR_THRESHOLD：用于判断颜色差异的阈值。

7. 定义辅助函数

7.1 计算IoU（交并比）

def calculate_iou(box1, box2):
    x1, y1, x2, y2 = box1
    x1b, y1b, x2b, y2b = box2
    inter_x1 = max(x1, x1b)
    inter_y1 = max(y1, y1b)
    inter_x2 = min(x2, x2b)
    inter_y2 = min(y2, y2b)
    inter_area = max(0, inter_x2 - inter_x1) * max(0, inter_y2 - inter_y1)
    box1_area = (x2 - x1) * (y2 - y1)
    box2_area = (x2b - x1b) * (y2b - y1b)
    union_area = box1_area + box2_area - inter_area
    return inter_area / union_area if union_area > 0 else 0

此函数计算两个边界框的交并比（IoU），用于判断两个检测框的重叠程度。

7.2 计算中心距离

def calculate_center_distance(box1, box2):
    center1 = ((box1[0] + box1[2]) / 2, (box1[1] + box1[3]) / 2)
    center2 = ((box2[0] + box2[2]) / 2, (box2[1] + box2[3]) / 2)
    return distance.euclidean(center1, center2)

计算两个边界框中心点之间的距离，以判断车辆是否为同一辆车。

7.3 提取车辆颜色

def extract_vehicle_color(frame, box):
    x1, y1, x2, y2 = map(int, box)
    vehicle_roi = frame[y1:y2, x1:x2]
    hsv_roi = cv2.cvtColor(vehicle_roi, cv2.COLOR_BGR2HSV)
    return cv2.mean(hsv_roi)[:3]

提取车辆在当前帧中的颜色，便于后续判断车辆是否相同。

7.4 计算颜色差异

def calculate_color_difference(color1, color2):
    return np.linalg.norm(np.array(color1) - np.array(color2))

计算两个颜色之间的差异，为车辆匹配提供依据。

7.5 判断是否为同一辆车

def is_same_vehicle(vehicle_info, new_box, new_color):
    prev_box = vehicle_info["box"]
    prev_color = vehicle_info["color"]
    
    iou = calculate_iou(prev_box, new_box)
    center_distance = calculate_center_distance(prev_box, new_box)
    prev_size = (prev_box[2] - prev_box[0]) * (prev_box[3] - prev_box[1])
    new_size = (new_box[2] - new_box[0]) * (new_box[3] - new_box[1])
    size_difference = abs(new_size - prev_size) / prev_size if prev_size > 0 else 1
    color_difference = calculate_color_difference(prev_color, new_color)
    
    return (
        iou > IOU_THRESHOLD
        and center_distance < MAX_MOVEMENT_DISTANCE
        and size_difference < MAX_SIZE_DIFFERENCE
        and color_difference < COLOR_THRESHOLD
    )

这个函数综合考虑了IoU、中心距离、大小差异和颜色差异，来判断检测到的车辆是否与之前记录的车辆相同。

7.6 车型类别映射

class_map = {
    2: 'car',
    7: 'truck',
    5: 'bus',
    3: 'motorcycle',
    1: 'bicycle',
}

我们定义了一个字典，用于将YOLO模型输出的类别编号映射到相应的车辆类型。

8. 处理视频帧

我们开始逐帧处理视频，检测车辆并记录相关信息：

cap = cv2.VideoCapture(video_path)

start_time_seconds = 12 * 3600 + 56 * 60 + 47  # 起始时间转换为秒
frame_count = 0
LANE_WIDTH = 3  # 车道宽度（米）
LANE_LENGTH = 30  # 识别范围的长度（米）

# 用于存储流量计算的车辆ID
unique_vehicles_in_interval = set()

while cap.isOpened() and frame_count < num_frames_to_process:
    ret, frame = cap.read()
    if not ret:
        break

    results = model(frame)
    current_frame_vehicle_ids = []
    vehicle_speeds = []
    truck_count = 0
    other_count = 0

    # 处理检测结果
    for result in results:
        for box in result.boxes:
            coords = box.xyxy[0]
            x1, y1, x2, y2 = coords[0], coords[1], coords[2], coords[3]
            cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 2)

            vehicle_class = int(box.cls.item())
            vehicle_type = class_map.get(vehicle_class, 'unknown')

            if vehicle_type == 'truck':
                truck_count += 1
            else:
                other_count += 1

            vehicle_color = extract_vehicle_color(frame, (x1, y1, x2, y2))
            matched_vehicle_id = None

            for vehicle_id, vehicle_info in vehicle_data.items():
                if is_same_vehicle(vehicle_info, (x1, y1, x2, y2), vehicle_color):
                    matched_vehicle_id = vehicle_id
                    break

            if matched_vehicle_id is None:
                unique_vehicle_counter += 1
                matched_vehicle_id = unique_vehicle_counter
                vehicle_data[matched_vehicle_id] = {
                    "box": (x1, y1, x2, y2),
                    "color": vehicle_color,
                    "first_frame": frame_count,
                    "last_frame": frame_count
                }
            else:
                vehicle_data[matched_vehicle_id]["last_frame"] = frame_count
                vehicle_data[matched_vehicle_id]["box"] = (x1, y1, x2, y2)
                vehicle_data[matched_vehicle_id]["color"] = vehicle_color

            current_frame_vehicle_ids.append(matched_vehicle_id)

在这段代码中，我们使用YOLO模型检测当前帧中的车辆，并提取每辆车的边界框、类型和颜色。通过判断条件，我们可以将车辆与已知车辆进行匹配，确保我们能够跟踪同一辆车。

9. 计算车辆速度

根据检测到的车辆信息，我们可以计算车辆的速度。以下是速度计算的代码：

# 计算车辆速度
for vehicle_id in current_frame_vehicle_ids:
    vehicle_info = vehicle_data[vehicle_id]
    first_frame = vehicle_info["first_frame"]
    last_frame = vehicle_info["last_frame"]
    frame_diff = last_frame - first_frame + 1
    if frame_diff > 0:
        vehicle_speed = 30 / (frame_diff * 0.4)  # 计算速度的公式
        vehicle_speeds.append(vehicle_speed)

根据车辆在视频中的帧差和已知车道长度，计算每辆车的速度。

10. 过滤速度异常值

为了确保计算结果的可靠性，我们对速度进行过滤，去除异常值：

filtered_speeds = []
if vehicle_speeds:
    lower_bound = 0
    upper_bound = 40
    filtered_speeds = [speed for speed in vehicle_speeds if lower_bound <= speed <= upper_bound]

在这里，我们设定了速度的上下限，仅保留在该范围内的速度数据。

11. 计算流量和密度

在每20帧中，我们将计算流量和车辆密度：

unique_vehicles_in_interval.update(current_frame_vehicle_ids)
if (frame_count + 1) % 20 == 0:
    flow = len(unique_vehicles_in_interval)  # 每20帧的唯一车辆数
    unique_vehicles_in_interval.clear()  # 清空当前周期的车辆ID
else:
    flow = None

通过维护一个唯一车辆ID的集合，我们能够计算特定时间间隔内的流量。

12. 输出信息

最后，我们将输出当前帧的分析结果，并将所有数据存储在一个列表中，便于后续分析：

current_time_seconds = start_time_seconds + frame_count * interval_time
current_time = datetime.utcfromtimestamp(current_time_seconds).strftime('%H:%M:%S')

# 输出信息
total_vehicles = truck_count + other_count
print(f"当前帧: {frame_count}, 时间: {current_time}, 卡车数: {truck_count}, 其他车辆数: {other_count}, 总车辆数: {total_vehicles}")
print(f"车辆编号集合: {current_frame_vehicle_ids}")
print(f"原始车辆速度: {vehicle_speeds}")
print(f"过滤后的车辆速度: {filtered_speeds}")
print(f"每帧平均速度: {average_speed:.2f}")
print(f"流量: {flow}辆 " if flow is not None and density is not None else "")
print(f"密度: {density:.2f}辆/米")
# 存储帧相关数据
data.append({
    'timestamp': current_time,                   
    'frame': frame_count,
    'total_vehicles': total_vehicles,
    'trucks': truck_count,
    'others': other_count,
    'vehicle_ids': current_frame_vehicle_ids,  
    'original_speeds': vehicle_speeds,          
    'filtered_speeds': filtered_speeds,          
    'average_speed': average_speed,              
    'flow': flow,                                
    'density': density                            
})

13. 显示结果

最后，我们将每帧的结果显示出来，并在按下’q’键时退出视频：

cv2.imshow('frame', frame)
frame_count += 1
if cv2.waitKey(1) & 0xFF == ord('q'):
    break

14. 保存结果

完成视频处理后，我们将分析结果转换为DataFrame，并保存到Excel文件中，以便后续分析：

df = pd.DataFrame(data)
df.to_excel('./video_analysis_with_color.xlsx', index=False)

输出表格展示：

在这里插入图片描述

15. 总结

通过上述步骤，我们实现了一个基于YOLO模型的高速公路交通流量分析系统。该系统不仅可以检测和跟踪车辆，还能计算它们的速度、流量和密度，为交通管理提供重要的数据支持。随着技术的不断进步，我们期待在交通流量监测方面能够实现更高的自动化和智能化。

完整代码

import cv2
import pandas as pd
import numpy as np
from ultralytics import YOLO
from datetime import datetime
from scipy.spatial import distance

# 计算视频时长
def calculate_duration(start_time, end_time):
    fmt = '%H:%M:%S'
    start = datetime.strptime(start_time, fmt)
    end = datetime.strptime(end_time, fmt)
    duration = end - start
    return duration

# 获取视频信息
def get_video_info(video_path, duration):
    cap = cv2.VideoCapture(video_path)

    if not cap.isOpened():
        raise ValueError("无法打开视频文件")

    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    fps = cap.get(cv2.CAP_PROP_FPS)
    frame_time = 1 / fps if fps > 0 else 0
    interval_time = duration.total_seconds() / total_frames if total_frames > 0 else 0

    cap.release()
    return total_frames, fps, frame_time, interval_time

# 初始化路径和视频时长
video_path = './高速公路交通流数据/32.31.250.103/20240501_20240501125647_20240501140806_125649.mp4'
duration = calculate_duration('12:56:47', '14:08:05')
total_frames, fps, frame_time, interval_time = get_video_info(video_path, duration)

# 加载预训练的YOLOv8模型
model = YOLO('yolov8n.pt')

# 处理前10%的帧
num_frames_to_process = total_frames // 100
frame_count = 0

# 存储车辆信息
vehicle_data = {}
unique_vehicle_counter = 0
data = []

# 定义IoU阈值以及其他判断参数
IOU_THRESHOLD = 0.3
MAX_MOVEMENT_DISTANCE = 50
MAX_SIZE_DIFFERENCE = 0.2
COLOR_THRESHOLD = 30

# 计算IoU（交并比）
def calculate_iou(box1, box2):
    x1, y1, x2, y2 = box1
    x1b, y1b, x2b, y2b = box2
    inter_x1 = max(x1, x1b)
    inter_y1 = max(y1, y1b)
    inter_x2 = min(x2, x2b)
    inter_y2 = min(y2, y2b)
    inter_area = max(0, inter_x2 - inter_x1) * max(0, inter_y2 - inter_y1)
    box1_area = (x2 - x1) * (y2 - y1)
    box2_area = (x2b - x1b) * (y2b - y1b)
    union_area = box1_area + box2_area - inter_area
    return inter_area / union_area if union_area > 0 else 0

# 计算中心距离
def calculate_center_distance(box1, box2):
    center1 = ((box1[0] + box1[2]) / 2, (box1[1] + box1[3]) / 2)
    center2 = ((box2[0] + box2[2]) / 2, (box2[1] + box2[3]) / 2)
    return distance.euclidean(center1, center2)

# 提取车辆颜色
def extract_vehicle_color(frame, box):
    x1, y1, x2, y2 = map(int, box)
    vehicle_roi = frame[y1:y2, x1:x2]
    hsv_roi = cv2.cvtColor(vehicle_roi, cv2.COLOR_BGR2HSV)
    return cv2.mean(hsv_roi)[:3]

# 计算颜色差异
def calculate_color_difference(color1, color2):
    return np.linalg.norm(np.array(color1) - np.array(color2))

# 判断车辆是否为同一辆车
def is_same_vehicle(vehicle_info, new_box, new_color):
    prev_box = vehicle_info["box"]
    prev_color = vehicle_info["color"]
    
    iou = calculate_iou(prev_box, new_box)
    center_distance = calculate_center_distance(prev_box, new_box)
    prev_size = (prev_box[2] - prev_box[0]) * (prev_box[3] - prev_box[1])
    new_size = (new_box[2] - new_box[0]) * (new_box[3] - new_box[1])
    size_difference = abs(new_size - prev_size) / prev_size if prev_size > 0 else 1
    color_difference = calculate_color_difference(prev_color, new_color)
    
    return (
        iou > IOU_THRESHOLD
        and center_distance < MAX_MOVEMENT_DISTANCE
        and size_difference < MAX_SIZE_DIFFERENCE
        and color_difference < COLOR_THRESHOLD
    )

# 车型类别映射
class_map = {
    2: 'car',
    7: 'truck',
    5: 'bus',
    3: 'motorcycle',
    1: 'bicycle',
}

# 打开视频文件
cap = cv2.VideoCapture(video_path)

start_time_seconds = 12 * 3600 + 56 * 60 + 47  # 起始时间转换为秒
frame_count = 0
LANE_WIDTH = 3  # 车道宽度（米）
LANE_LENGTH = 30  # 识别范围的长度（米）

# 用于存储流量计算的车辆ID
unique_vehicles_in_interval = set()

while cap.isOpened() and frame_count < num_frames_to_process:
    ret, frame = cap.read()
    if not ret:
        break

    results = model(frame)
    current_frame_vehicle_ids = []
    vehicle_speeds = []
    truck_count = 0
    other_count = 0

    # 处理检测结果
    for result in results:
        for box in result.boxes:
            coords = box.xyxy[0]
            x1, y1, x2, y2 = coords[0], coords[1], coords[2], coords[3]
            cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 2)

            vehicle_class = int(box.cls.item())
            vehicle_type = class_map.get(vehicle_class, 'unknown')

            if vehicle_type == 'truck':
                truck_count += 1
            else:
                other_count += 1

            vehicle_color = extract_vehicle_color(frame, (x1, y1, x2, y2))
            matched_vehicle_id = None

            for vehicle_id, vehicle_info in vehicle_data.items():
                if is_same_vehicle(vehicle_info, (x1, y1, x2, y2), vehicle_color):
                    matched_vehicle_id = vehicle_id
                    break

            if matched_vehicle_id is None:
                unique_vehicle_counter += 1
                matched_vehicle_id = unique_vehicle_counter
                vehicle_data[matched_vehicle_id] = {
                    "box": (x1, y1, x2, y2),
                    "color": vehicle_color,
                    "first_frame": frame_count,
                    "last_frame": frame_count
                }
            else:
                vehicle_data[matched_vehicle_id]["last_frame"] = frame_count
                vehicle_data[matched_vehicle_id]["box"] = (x1, y1, x2, y2)
                vehicle_data[matched_vehicle_id]["color"] = vehicle_color

            current_frame_vehicle_ids.append(matched_vehicle_id)

    # 计算车辆速度
    for vehicle_id in current_frame_vehicle_ids:
        vehicle_info = vehicle_data[vehicle_id]
        first_frame = vehicle_info["first_frame"]
        last_frame = vehicle_info["last_frame"]
        frame_diff = last_frame - first_frame + 1
        if frame_diff > 0:
            vehicle_speed = 30 / (frame_diff * 0.4)  # 计算速度的公式
            vehicle_speeds.append(vehicle_speed)

    # 过滤速度异常值
    filtered_speeds = []
    if vehicle_speeds:
        lower_bound = 0
        upper_bound = 40
        filtered_speeds = [speed for speed in vehicle_speeds if lower_bound <= speed <= upper_bound]

    # 计算每一帧的平均速度
    average_speed = np.mean(filtered_speeds) if filtered_speeds else 0

    # 计算流量和密度
    unique_vehicles_in_interval.update(current_frame_vehicle_ids)
    if (frame_count + 1) % 20 == 0:
        flow = len(unique_vehicles_in_interval)  # 每20帧的唯一车辆数
        unique_vehicles_in_interval.clear()  # 清空当前周期的车辆ID
    else:
        flow = None
    # 计算实际时间
    current_time_seconds = start_time_seconds + frame_count * interval_time
    current_time = datetime.utcfromtimestamp(current_time_seconds).strftime('%H:%M:%S')

    # 输出信息
    total_vehicles = truck_count + other_count
    density = total_vehicles / (LANE_WIDTH * LANE_LENGTH)  # 单位长度内的车辆数
    print(f"当前帧: {frame_count}, 时间: {current_time}, 卡车数: {truck_count}, 其他车辆数: {other_count}, 总车辆数: {total_vehicles}")
    print(f"车辆编号集合: {current_frame_vehicle_ids}")
    print(f"原始车辆速度: {vehicle_speeds}")
    print(f"过滤后的车辆速度: {filtered_speeds}")
    print(f"每帧平均速度: {average_speed:.2f}")
    print(f"流量: {flow}辆 " if flow is not None and density is not None else "")
    print(f"密度: {density:.2f}辆/米")
    # 存储帧相关数据
    data.append({
        'timestamp': current_time,                   # 当前帧的时间戳
        'frame': frame_count,
        'total_vehicles': total_vehicles,
        'trucks': truck_count,
        'others': other_count,
        'vehicle_ids': current_frame_vehicle_ids,  # 记录当前帧车辆编号
        'original_speeds': vehicle_speeds,          # 原始速度
        'filtered_speeds': filtered_speeds,          # 过滤后的速度
        'average_speed': average_speed,              # 每帧平均速度
        'flow': flow,                                # 流量
        'density': density                            # 密度
    })


    # 显示结果
    cv2.imshow('frame', frame)
    # 更新帧计数器
    frame_count += 1
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()

# 转换为DataFrame并保存到Excel
df = pd.DataFrame(data)
df.to_excel('./video_analysis_with_color.xlsx', index=False)

再次提醒：本文内容仅供参考，作者对此不负任何责任。希望读者能够从中获得启发，继续探索交通流量分析的更深入领域。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2157034.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

记一次Meilisearch轻量级搜索引擎使用

记一次Meilisearch轻量级搜索引擎使用

以前使用的是mysql的全文索引、最开始还行。后续觉得就不好用了&#xff0c;但是服务器资源有限&#xff0c;没法上ES&#xff0c;只好找一个轻量级的搜索引擎、找了半天&#xff0c;决定使用这一个&#xff0c;目前效果还不错的。 参考网址 官网&#xff1a;https://www.meil…
阅读更多...
java反射基础知识

java反射基础知识

1.java的反射机制 Java 反射机制是在运行状态中&#xff0c;对于任意一个类&#xff0c;都能够知道这个类的所有属性和方法&#xff1b;对于任意一个对象&#xff0c;都能够调用它的任意方法和属性&#xff1b;这种动态获取信息以及动态调用对象方法的功能称为 Java 语言的反射…
阅读更多...
【C语言零基础入门篇 - 16】：栈和队列

【C语言零基础入门篇 - 16】：栈和队列

文章目录 栈和队列栈栈功能的实现源代码 队列队列功能的实现源代码 栈和队列 栈 什么是栈&#xff1a;功能受限的线性数据结构 栈的特点&#xff1a;先进后出 。例如&#xff1a;仓库进货、出货。 栈只有一个开口&#xff0c;先进去的数据在栈底&#xff08;bottom&#xf…
阅读更多...
高版本idea开启热部署找不到compiler.automake.allow.when.app.running

高版本idea开启热部署找不到compiler.automake.allow.when.app.running

高版本idea开启热部署找不到compiler.automake.allow.when.app.running 1.解决方案 设置----》高级设置 搜索 allow 勾选完成就能使用了
阅读更多...
针对论坛系统设计测试用例

针对论坛系统设计测试用例

针对用户登录设计测试用例 针对站内信编写测试用例
阅读更多...
mysql5.7小版本升级

mysql5.7小版本升级

最近因为mysql漏洞问题需要升级版本 目标&#xff1a;5.7.17升级到最新的5.7.44 提前准备&#xff1a;必须 MySQL :: Download MySQL Community Server (Archived Versions) 下载最新的5.7版本5.7.44&#xff0c;下载后&#xff0c;解压备用 ​ 方案1&#xff1a;卸载原有…
阅读更多...
网站建设模板选择哪种

网站建设模板选择哪种

在选择网站建设模板时&#xff0c;需要考虑多个因素&#xff0c;包括网站的目的、受众、内容类型以及个性化需求等。以下是一些常见的网站建设模板类型&#xff0c;以及它们的特点&#xff0c;希望对你的选择有所帮助。 企业/商务模板&#xff1a; 企业和商务网站通常需要专业、…
阅读更多...
python画图|把X轴标签移动到图像顶端

python画图|把X轴标签移动到图像顶端

在前述学习过程中&#xff0c;我们一直使用的是默认的轴坐标&#xff0c;X轴往往置于图像的下端。 有时候&#xff0c;也会有将X轴标签放置在图形顶端的需求&#xff0c;今天就一起学习一下。 【1】官网教程 首先打开官网&#xff0c;可以通过下述链接一步直达&#xff1a; …
阅读更多...
【开源免费】基于SpringBoot+Vue.JS学科竞赛管理系统（JAVA毕业设计）

【开源免费】基于SpringBoot+Vue.JS学科竞赛管理系统（JAVA毕业设计）

本文项目编号 T 047 &#xff0c;文末自助获取源码 \color{red}{T047&#xff0c;文末自助获取源码} T047&#xff0c;文末自助获取源码 目录 一、系统介绍二、演示录屏三、启动教程四、功能截图五、文案资料5.1 选题背景5.2 国内外研究现状5.3 可行性分析 六、核心代码6.1 查…
阅读更多...
小红书自动化写文以及发文机器人

小红书自动化写文以及发文机器人

&#x1f4aa;&#x1f3fb; 1. Python基础专栏&#xff0c;基础知识一网打尽&#xff0c;9.9元买不了吃亏&#xff0c;买不了上当。 Python从入门到精通 &#x1f601; 2. 毕业设计专栏&#xff0c;毕业季咱们不慌忙&#xff0c;几百款毕业设计等你选。 ❤️ 3. Python爬虫专栏…
阅读更多...
【C语言零基础入门篇 - 15】：单链表

【C语言零基础入门篇 - 15】：单链表

文章目录 单链表链表的基本概念单链表功能的实现单链表的初始化单链表新结点的创建单链表头插法单链表的输出单链表的查找单链表修改单链表的删除单链表所有数据结点释放源代码 单链表 链表的基本概念 一、什么是链表&#xff1f; 链表是数据结构中线性表的一种&#xff0c;其…
阅读更多...
element ui实现全局el-dialog可拖拽

element ui实现全局el-dialog可拖拽

此情况适用于在已有项目中&#xff0c;想实现全局拖拽弹出框&#xff0c;而逐一添加拖拽自定义指令会过于麻烦的情况下&#xff0c;这种情况可以尝试下此方法。 话不多说&#xff0c;直接上代码&#xff1a; 1.先在src下新建一个config文件夹&#xff0c;里面再新建一个dialog…
阅读更多...
【MySQL 03】表的操作

【MySQL 03】表的操作

目录 1.在数据库内创建表 2.表的查询 3.表的插入 往数据库中插入数据 4.表的修改 5.删除表 1.在数据库内创建表 create table 表名(字段1 字段1类型); 这样我们就创建好了一张表&#xff0c;我们可以进入hellosql目录下进行查看&#xff1a;所以在数据库内建立表&#xf…
阅读更多...
python绘制弦图-科研作图

python绘制弦图-科研作图

一、背景 弦图以其直观、精美的展示方式受到越来越多人的关注&#xff0c;它不仅能够有效展示两个变量之间的联系&#xff0c;还能同时展现多个变量间的复杂互动&#xff0c;本文将通过Python语言中的pycirclize库&#xff0c;带你深入了解如何绘制弦图。 弦图是一种圆…
阅读更多...
linux中vim编辑器的应用实例

linux中vim编辑器的应用实例

前言 Linux有大量的配置文件&#xff0c;其中编辑一些配置文件&#xff0c;最常用的工具就是 Vim &#xff0c;本文介绍一个实际应用的Vim编辑器开发文档的实例。 Vim是一个类似于Vi的著名的功能强大、高度可定制的文本编辑器&#xff0c;在Vi的基础上改进和增加了很多特性。…
阅读更多...
力扣 92.反转链表Ⅱ

力扣 92.反转链表Ⅱ

力扣《反转链表》系列文章目录 刷题次序&#xff0c;由易到难&#xff0c;一次刷通&#xff01;&#xff01;&#xff01; 题目题解206. 反转链表反转链表的全部 题解192. 反转链表 II反转链表的指定段24. 两两交换链表中的节点两个一组反转链表 题解225. K 个一组翻转链表K …
阅读更多...
基尔霍夫衍射理论

基尔霍夫衍射理论

一、矢量理论到标量理论 前提条件：介质同时具有线性、各向同性、均匀性且无色散。 结论：电场和磁场的所有分量的行为完全相同，可由单一的一个标量波动方程描述，标量理论可以完全准确的代替矢量理论。 若介质不具备上述前提，则用标量理论来表征矢 量理论就会引入误差。 …
阅读更多...
【C++】继承（上）

【C++】继承（上）

个人主页~ 继承 一、继承的概念以及定义1、继承的概念2、继承的定义&#xff08;1&#xff09;定义格式&#xff08;2&#xff09;继承基类成员访问方式的变化 二、基类和派生类对象赋值转换三、继承中的作用域 一、继承的概念以及定义 1、继承的概念 继承机制是面向对象程序…
阅读更多...
【C语言零基础入门篇 - 17】：排序算法

【C语言零基础入门篇 - 17】：排序算法

文章目录 排序算法排序的基本概念冒泡排序选择排序插入排序 排序算法 排序的基本概念 1、什么是排序&#xff1f; 排序是指把一组数据以某种关系&#xff08;递增或递减&#xff09;按顺序排列起来的一种算法。 例如&#xff1a;数列 8、3、5、6、2、9、1、0、4、7 递增排序…
阅读更多...
Windows 配置docker和ubuntu系统

Windows 配置docker和ubuntu系统

windos10 配置docke时&#xff0c;无意间发现wsl功能挺好用&#xff0c;而且是和docker 的linux容器连通的。 记录一下解决的几个问题 error during connect: Get http://%2F%2F.%2Fpipe%2Fdocker_engine/v1.40/images/json: open //./pipe/docker_engine: The system cannot …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023