学校项目培训之Carla仿真平台之Carla学习内容

news2024/12/25 1:22:05

一、Blender

Blender入门：https://www.bilibili.com/video/BV1fb4y1e7PD/
Blender导入骨骼：https://www.bilibili.com/video/BV1hc41157nL
做一个车：https://www.bilibili.com/video/BV1hY411q7w2
请添加图片描述
请添加图片描述在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

二、Roadrunner

RoadRunner Scenario+CARLA联合仿真
在这里插入图片描述

三、Blender中导入汽车骨骼

carla仿真器搭建及特定车辆模型的导入
里面有两个视频，无声的看小车的骨骼构建，有声的看小车导入UE：
How to add a vehicle/truck in carla using Unreal Engine Editor 4 + Blender for beginners
How to rig vehicle in Blender 2.8 for UE4 [No Sound] _ Blender 2.8, Unreal Engine 4
建议先做一个简单的小车学习导入流程，汽车做的太豪华，导入的时候没卡出来

以下过程中，每个步骤有编译的的地方点一下，有保存的地方点一下

  1. UE4中导入小车的fbx在这里插入图片描述

  2. 在物理资产中设置骨骼
    在这里插入图片描述
    进入编辑：
    在这里插入图片描述
    在这里插入图片描述

  3. 添加动画蓝图，直接去现有的车辆动画蓝图复制过来
    在这里插入图片描述
    在这里插入图片描述

在这里插入图片描述

进入编辑：在这里插入图片描述

  1. 添加轮子的蓝图
    在这里插入图片描述
    在这里插入图片描述
    进入编辑：
    前轮胎：在这里插入图片描述
    后轮胎：在这里插入图片描述

  2. 新建汽车蓝图类
    在这里插入图片描述
    进入编辑：
    在这里插入图片描述
    在这里插入图片描述

  3. 编辑汽车资产库
    在这里插入图片描述
    进入编辑：
    （这里写错了，是 SimpleCar和SimpleCar01）在这里插入图片描述好了，此时就可以运行看看了。

python manual_control.py --filter SimplerCar01

四、小车等待红绿灯code

# ==============================================================================
# -- find carla module ---------------------------------------------------------
# ==============================================================================
import glob
import math
import os
import random
import sys

try:
    sys.path.append(glob.glob('../carla/dist/carla-*%d.%d-%s.egg' % (
        sys.version_info.major,
        sys.version_info.minor,
        'win-amd64' if os.name == 'nt' else 'linux-x86_64'))[0])
except IndexError:
    pass

import carla


def hld(world, vehicle, vehicle_max_speed):
    global vehicle_current_location
    global way_near_point
    global distance_to_intersection
    # if vehicle:
    #     # 获取汽车当前位置
    #     vehicle_current_location = vehicle.get_location()
    #     # 使用Carla的道路地图获取最近的路口（交叉口）Waypoint
    #     waypoint_location = world.get_map().get_waypoint(vehicle_current_location).transform.location
    #     # 使用Waypoint的distance属性获取距离路口的距离
    #     print(vehicle_current_location)
    #     print(waypoint_location)
    #     distance_to_intersection = math.sqrt((vehicle_current_location.x - waypoint_location.x) ** 2 + (
    #                 vehicle_current_location.y - waypoint_location.y) ** 2)
    #     print("The neaerest way point's distance is：", distance_to_intersection, "meters")
    # else:
    #     print("_________________Not found the vehicle !_________________")
    #     return

    # 获取汽车的速度
    vehicle_current_velocity = vehicle.get_velocity()
    vehicle_current_speed = vehicle_current_velocity.length()  # 线速度

    print("vehicle_current_speed______", vehicle_current_speed)

    # 判断汽车当前是否处于红绿灯影响范围
    if vehicle.is_at_traffic_light():
        # 获取红绿灯
        traffic_light = vehicle.get_traffic_light()
        print("traffic_light.get_state()______", traffic_light.get_state())
        # 如果前方是红灯并且距离路口只有0.5m了，制动汽车
        if traffic_light and traffic_light.get_state() == carla.TrafficLightState.Red:
            print("红灯请停车！")
            # target_velocity = max(vehicle_current_speed - 5.0, 0.0)  # 以5m/s的速度减速，
            vehicle.apply_control(carla.VehicleControl(throttle=-0.0, steer=0, brake=1.0))
        # 如果前方是绿灯
        elif traffic_light and traffic_light.get_state() == carla.TrafficLightState.Green:
            # 如果当前是静止的状态，则让汽车启动
            if vehicle_current_speed == 0.0:
                print("绿灯请行驶！")
                vehicle.apply_control(carla.VehicleControl(throttle=1.0, steer=0.0, brake=0.0))
            # 如果当前是行驶状态并且速度大于最大速度限制的一半，则让其保持当前速度行驶
            elif vehicle_current_speed > (vehicle_max_speed / 2.0):
                print("路口请缓行！")
                vehicle.apply_control(carla.VehicleControl(throttle=0.0, steer=0.0, brake=0.0))
            # 其他情况，则保持当前速度行驶
            else :
                print("绿灯请缓行！")
                vehicle.apply_control(carla.VehicleControl(throttle=0.5, steer=0.0, brake=0.0))
        # 如果前方是黄灯，则汽车开始制动
        elif traffic_light and traffic_light.get_state() == carla.TrafficLightState.Yellow:
            print("黄灯请停车！")
            vehicle.apply_control(carla.VehicleControl(throttle=0.0, steer=0.0, brake=1.0))
    else:
        print("直线行驶中~~~")
        # 如果汽车的速度超过了最大速度，则让他保持当前速度行驶
        speed_tolerance = 0.5  # 设置速度容忍范围，可以根据需要调整
        # 计算油门值，使车辆保持在最大速度附近
        if vehicle_current_speed < vehicle_max_speed - speed_tolerance:
            # print("start throttle")
            throttle = 1.0  # 假设油门力度为1.0
        else:
            # print("stop throttle")
            throttle = 0.0  # 达到最大速度时，停止加油门

        vehicle.apply_control(carla.VehicleControl(throttle=throttle, steer=0.0, brake=0.0))


def main():
    actor_list = []
    client = carla.Client('127.0.0.1', 2000)
    client.set_timeout(2.0)
    try:
        # 获取世界
        world = client.get_world()

        # 创建汽车蓝图
        # vehicle_blueprint = random.choice(world.get_blueprint_library().filter('vehicle.*'))
        # 选用自定义小车蓝图
        vehicle_blueprint = world.get_blueprint_library().filter('vehicle.simplecar.simplecar')
        # vehicle_spawn_points = random.choice(world.get_map().get_spawn_points())
        vehicle_spawn_points = carla.Transform(
            carla.Location(x=20.235275, y=13.414804, z=0.600000),  # 设置初始位置的x、y和z坐标
            carla.Rotation(pitch=0.000000, yaw=-179.840790, roll=0.000000)  # 设置初始方向的pitch、yaw和roll角度
        )
        print("vehicle_spawn_points: ",vehicle_spawn_points)

        vehicle = world.spawn_actor(vehicle_blueprint, vehicle_spawn_points)
        # 设置最大车速
        vehicle_max_speed = 7.0

        actor_list.append(vehicle)

        # 创建相机蓝图
        camera_blueprint = world.get_blueprint_library().find('sensor.camera.rgb')
        camera_spawn_points = carla.Transform(carla.Location(x=-5, z=4), carla.Rotation(pitch=-20))
        camera = world.spawn_actor(camera_blueprint, camera_spawn_points, attach_to=vehicle)
        # camera.listen(lambda image: image.save_to_disk(os.path.join('_out', '%06d.png' % image.frame)))

        actor_list.append(camera)

        while True:
            # 设置相机视角
            world.get_spectator().set_transform(camera.get_transform())

            hld(world, vehicle, vehicle_max_speed)

            # 优化循环性能
            world.tick()

    finally:
        client.apply_batch([carla.command.DestroyActor(x) for x in actor_list])
        print("All the actors have already been destroied !")


if __name__ == "__main__":
    main()

五、两个小车跟车code

import carla
import math
import random
import time

# 创建CARLA仿真客户端
client = carla.Client('127.0.0.1', 2000)
client.set_timeout(2.0)
actor_list=[]

try:
    # ======================================获取CARLA世界和地图======================================
    world = client.get_world()
    blueprint_library = world.get_blueprint_library()
    map = world.get_map()

    # ======================================创建两辆车======================================
    # 位置设置
    # spawn_points = map.get_spawn_points()
    spawn_points = carla.Transform(
        carla.Location(x=20.235275, y=13.414804, z=0.600000),  # 设置初始位置的x、y和z坐标
        carla.Rotation(pitch=0.000000, yaw=-179.840790, roll=0.000000)  # 设置初始方向的pitch、yaw和roll角度
    )
    # 主车
    # vehicle_bp1 = blueprint_library.filter('vehicle')[0]
    # vehicle_bp1.set_attribute('color', '255,0,0')
    # 自定义小车
    vehicle_bp1 = blueprint_library.find('vehicle.simplecar.simplecar')
    # vehicle1_spawn_point = random.choice(spawn_points)
    vehicle1_spawn_point = spawn_points
    vehicle1 = world.spawn_actor(vehicle_bp1, vehicle1_spawn_point)
    # 跟车
    # vehicle_bp2 = blueprint_library.filter('vehicle')[0]
    # vehicle_bp2.set_attribute('color', '0,0,255')
    # 自定义小车
    vehicle_bp2 = blueprint_library.find('vehicle.simplecar3.simplecar3')
    vehicle2_spawn_point = carla.Transform(vehicle1_spawn_point.location + carla.Location(x=10.0),carla.Rotation(pitch=0.000000, yaw=-179.840790, roll=0.000000))
    vehicle2 = world.spawn_actor(vehicle_bp2, vehicle2_spawn_point)

    # 设置车辆的初始速度
    vehicle1.apply_control(carla.VehicleControl(throttle=0.5, steer=0, brake=0)) # 车1的初始速度为10 m/s
    vehicle2.apply_control(carla.VehicleControl(throttle=0, steer=0, brake=0))
    actor_list.append(vehicle1)
    actor_list.append(vehicle2)
    # # 给两个车设置自动驾驶
    # vehicle1.set_autopilot(True)
    # vehicle2.set_autopilot(True)


    # ======================================创建相机蓝图======================================
    camera_blueprint = world.get_blueprint_library().find('sensor.camera.rgb')
    camera_transform = carla.Transform(carla.Location(x=-5, z=4), carla.Rotation(pitch=-10))
    camera1 = world.spawn_actor(camera_blueprint, camera_transform, attach_to=vehicle1)
    camera2 = world.spawn_actor(camera_blueprint, camera_transform, attach_to=vehicle2)
    # camera.listen(lambda image: image.save_to_disk(os.path.join('_out', '%06d.png' % image.frame)))
    actor_list.append(camera1)
    actor_list.append(camera2)

    # ======================================定义跟车参数======================================
    desired_distance = 20.0  # 期望的跟车距离
    max_velocity = 1.0  # 最大速度 (m/s)

    while True:
        # 设置相机视角
        world.get_spectator().set_transform(camera2.get_transform())

        # 获取车辆的位置
        location1 = vehicle1.get_location()
        location2 = vehicle2.get_location()

        # 计算车辆之间的距离
        distance = math.sqrt((location1.x - location2.x)**2 + (location1.y - location2.y)**2)

        # 计算车辆2的期望速度，使其保持在期望跟车距离内
        target_speed = 0.0 if desired_distance > distance else max_velocity

        # 设置车辆2的速度
        vehicle2.apply_control(carla.VehicleControl(throttle=target_speed, steer=0, brake=0))

        # 打印信息
        print(f"Distance between vehicles: {distance:.2f} m, Target Speed for Vehicle 2: {vehicle2.get_velocity().length():.2f} m/s")


        world.tick()

finally:
    client.apply_batch([carla.command.DestroyActor(x) for x in actor_list])
    print("All the actors have already been destroied !")

六、前车实现等红绿灯+后车实现跟车code


import glob
import math
import os
import random
import sys

try:
    sys.path.append(glob.glob('../carla/dist/carla-*%d.%d-%s.egg' % (
        sys.version_info.major,
        sys.version_info.minor,
        'win-amd64' if os.name == 'nt' else 'linux-x86_64'))[0])
except IndexError:
    pass

import carla


# ======================================后车执行跟车逻辑======================================

def follow(vehicle1, vehicle2, max_speed, desired_distance,):
    # 获取车辆的位置
    location1 = vehicle1.get_location()
    location2 = vehicle2.get_location()
    # 获取汽车的速度
    vehicle2_current_velocity = vehicle2.get_velocity()
    vehicle2_current_speed = vehicle2_current_velocity.length()  # 线速度

    # 计算车辆之间的距离
    distance = math.sqrt((location1.x - location2.x) ** 2 + (location1.y - location2.y) ** 2)

    # 设置车辆2的速度
    if desired_distance>distance:
        vehicle2.apply_control(carla.VehicleControl(throttle=0.0, steer=0, brake=0))
    else:
        # 如果汽车的速度超过了最大速度，则让他保持当前速度行驶
        speed_tolerance = 0  # 设置速度容忍范围，可以根据需要调整
        # 计算油门值，使车辆保持在最大速度附近
        if vehicle2_current_speed < max_speed - speed_tolerance or desired_distance>distance:
            # print("start throttle")
            throttle = 1.0  # 假设油门力度为1.0
        else:
            # print("stop throttle")
            throttle = 0.1  # 达到最大速度时，停止加油门

        vehicle2.apply_control(carla.VehicleControl(throttle=throttle, steer=0.0, brake=0.0))

    # 打印信息
    print(
        f"Distance between vehicles: {distance:.2f} m, Target Speed for Vehicle 2: {vehicle2.get_velocity().length():.2f} m/s")


# ======================================主车执行红绿灯逻辑======================================
def hld(world, vehicle, vehicle_max_speed):
    global vehicle_current_location
    global way_near_point
    global distance_to_intersection
    # if vehicle:
    #     # 获取汽车当前位置
    #     vehicle_current_location = vehicle.get_location()
    #     # 使用Carla的道路地图获取最近的路口（交叉口）Waypoint
    #     waypoint_location = world.get_map().get_waypoint(vehicle_current_location).transform.location
    #     # 使用Waypoint的distance属性获取距离路口的距离
    #     print(vehicle_current_location)
    #     print(waypoint_location)
    #     distance_to_intersection = math.sqrt((vehicle_current_location.x - waypoint_location.x) ** 2 + (
    #                 vehicle_current_location.y - waypoint_location.y) ** 2)
    #     print("The neaerest way point's distance is：", distance_to_intersection, "meters")
    # else:
    #     print("_________________Not found the vehicle !_________________")
    #     return

    # 获取汽车的速度
    vehicle_current_velocity = vehicle.get_velocity()
    vehicle_current_speed = vehicle_current_velocity.length()  # 线速度

    print("vehicle_current_speed______", vehicle_current_speed)

    # 判断汽车当前是否处于红绿灯影响范围
    if vehicle.is_at_traffic_light():
        # 获取红绿灯
        traffic_light = vehicle.get_traffic_light()
        print("traffic_light.get_state()______", traffic_light.get_state())
        # 如果前方是红灯并且距离路口只有0.5m了，制动汽车
        if traffic_light and traffic_light.get_state() == carla.TrafficLightState.Red:
            print("红灯请停车！")
            # target_velocity = max(vehicle_current_speed - 5.0, 0.0)  # 以5m/s的速度减速，
            vehicle.apply_control(carla.VehicleControl(throttle=-0.0, steer=0, brake=1.0))
        # 如果前方是绿灯
        elif traffic_light and traffic_light.get_state() == carla.TrafficLightState.Green:
            # 如果当前是静止的状态，则让汽车启动
            if vehicle_current_speed == 0.0:
                print("绿灯请行驶！")
                vehicle.apply_control(carla.VehicleControl(throttle=1.0, steer=0.0, brake=0.0))
            # 如果当前是行驶状态并且速度大于最大速度限制的一半，则让其保持当前速度行驶
            elif vehicle_current_speed > (vehicle_max_speed / 2.0):
                print("路口请缓行！")
                vehicle.apply_control(carla.VehicleControl(throttle=0.0, steer=0.0, brake=0.0))
            # 其他情况，则保持当前速度行驶
            else:
                print("绿灯请缓行！")
                vehicle.apply_control(carla.VehicleControl(throttle=0.5, steer=0.0, brake=0.0))
        # 如果前方是黄灯，则汽车开始制动
        elif traffic_light and traffic_light.get_state() == carla.TrafficLightState.Yellow:
            print("黄灯请停车！")
            vehicle.apply_control(carla.VehicleControl(throttle=0.0, steer=0.0, brake=1.0))
    else:
        print("直线行驶中~~~")
        # 如果汽车的速度超过了最大速度，则让他保持当前速度行驶
        speed_tolerance = 0.5  # 设置速度容忍范围，可以根据需要调整
        # 计算油门值，使车辆保持在最大速度附近
        if vehicle_current_speed < vehicle_max_speed - speed_tolerance:
            # print("start throttle")
            throttle = 1.0  # 假设油门力度为1.0
        else:
            # print("stop throttle")
            throttle = 0.0  # 达到最大速度时，停止加油门

        vehicle.apply_control(carla.VehicleControl(throttle=throttle, steer=0.0, brake=0.0))


# 创建CARLA仿真客户端
client = carla.Client('127.0.0.1', 2000)
client.set_timeout(2.0)
actor_list = []

try:
    # ======================================获取CARLA世界和地图======================================
    world = client.get_world()
    blueprint_library = world.get_blueprint_library()
    map = world.get_map()

    # ======================================创建两辆车======================================
    # 位置设置
    # spawn_points = map.get_spawn_points()
    # vehicle1_spawn_point = random.choice(spawn_points)
    # print(vehicle1_spawn_point)

    # 自定义小车位置
    spawn_points = carla.Transform(
        carla.Location(x=400, y=-0.6, z=4.000000), carla.Rotation(pitch=0.000000, yaw=-180, roll=0.000000))
    vehicle1_spawn_point = spawn_points
    print(vehicle1_spawn_point)

    # 主车
    # vehicle_bp1 = blueprint_library.filter('vehicle')[0]
    # vehicle_bp1.set_attribute('color', '255,0,0')
    # 自定义小车
    vehicle_bp1 = blueprint_library.find('vehicle.simplecar.simplecar')
    vehicle1 = world.spawn_actor(vehicle_bp1, vehicle1_spawn_point)
    # 跟车
    # vehicle_bp2 = blueprint_library.filter('vehicle')[0]
    # vehicle_bp2.set_attribute('color', '0,0,255')
    # 自定义小车
    vehicle_bp2 = blueprint_library.find('vehicle.simplecar3.simplecar3')
    vehicle2_spawn_point = carla.Transform(vehicle1_spawn_point.location + carla.Location(x=10.0),
                                           carla.Rotation(pitch=0.000000, yaw=-180, roll=0.000000))
    vehicle2 = world.spawn_actor(vehicle_bp2, vehicle2_spawn_point)

    # 设置车辆的初始速度
    vehicle1.apply_control(carla.VehicleControl(throttle=0.5, steer=0, brake=0))  # 车1的初始速度为10 m/s
    vehicle2.apply_control(carla.VehicleControl(throttle=0, steer=0, brake=0))
    actor_list.append(vehicle1)
    actor_list.append(vehicle2)
    # # 给两个车设置自动驾驶
    # vehicle1.set_autopilot(True)
    # vehicle2.set_autopilot(True)

    # ======================================创建相机蓝图======================================
    camera_blueprint = world.get_blueprint_library().find('sensor.camera.rgb')
    camera_transform = carla.Transform(carla.Location(x=-5, z=4), carla.Rotation(pitch=-10))
    camera1 = world.spawn_actor(camera_blueprint, camera_transform, attach_to=vehicle1)
    camera2 = world.spawn_actor(camera_blueprint, camera_transform, attach_to=vehicle2)
    # camera.listen(lambda image: image.save_to_disk(os.path.join('_out', '%06d.png' % image.frame)))
    actor_list.append(camera1)
    actor_list.append(camera2)

    # ======================================定义跟车参数======================================
    desired_distance = 15.0  # 期望的跟车距离
    max_velocity = 1.0  # 最大速度 (m/s)
    max_speed = 7.0  # 最大速度 (m/s)

    while True:
        # 设置相机视角
        world.get_spectator().set_transform(camera2.get_transform())
        # 主车执行红绿灯
        hld(world, vehicle1, max_speed)
        # 后车执行跟车
        follow(vehicle1, vehicle2, max_speed, desired_distance)

        world.tick()

finally:
    client.apply_batch([carla.command.DestroyActor(x) for x in actor_list])
    print("All the actors have already been destroied !")

七、实现效果

跟车+红绿灯+roadRunner+有红灯停下效果 15m

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

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

相关文章

Flink状态管理与检查点机制

Flink状态管理与检查点机制

1.状态分类 相对于其他流计算框架，Flink 一个比较重要的特性就是其支持有状态计算。即你可以将中间的计算结果进行保存，并提供给后续的计算使用： 具体而言，Flink 又将状态 (State) 分为 Keyed State 与 Operator State： 1.1 算子状态 算子状态 (Operator State)：顾名思义…
阅读更多...
计组—— I/O系统

计组—— I/O系统

&#x1f4d5;&#xff1a;参考王道课件 目录 一、I/O系统的基本概念 1.什么是“I/O”&#xff1f; ​编辑2.主机如何和I/O设备进行交互&#xff1f; 3.I/O控制方式 &#xff08;1&#xff09;程序查询方式 &#xff08;2&#xff09;程序中断方式 &#xff08;3&#x…
阅读更多...
【MATLAB源码-第41期】基于压缩感知算法的OFDM系统信道估计和LS算法对比仿真。

【MATLAB源码-第41期】基于压缩感知算法的OFDM系统信道估计和LS算法对比仿真。

操作环境&#xff1a; MATLAB 2013b 1、算法描述 压缩感知&#xff08;Compressed Sensing, CS&#xff09;是一种从稀疏或可压缩信号中重构完整信号的数学理论和技术。下面详细介绍压缩感知和它在OFDM信道估计中的应用。 1. 压缩感知基本概念 在传统采样理论中&#xff0…
阅读更多...
数字电路逻辑与设计 之循环码和 移存码

数字电路逻辑与设计 之循环码和 移存码

有发现错误的能力&#xff0c;不能纠正 只能检查单次的错误&#xff0c;不能完全抗干扰 可以按照上面的方法来循环构造 移存码可以通过前推后推来实现
阅读更多...
pytorch_神经网络构建1

pytorch_神经网络构建1

文章目录 pytorch简介神经网络基础分类问题分析:逻辑回归模型逻辑回归实现多层神经网络多层网络搭建保存模型 pytorch简介 为什么神经网络要自定义数据类型torch.tensor? tensor可以放在gpu上训练,支持自动求导,方便快速训练,同时支持numpy的运算,是加强版,numpy不支持这些 为…
阅读更多...
C++项目：【高并发内存池】

C++项目：【高并发内存池】

文章目录 一、项目介绍 二、什么是内存池 1.池化技术 2.内存池 3.内存池主要解决的问题 4.malloc 三、定长的内存池 四、高并发内存池整体框架设计 1.高并发内存池--thread cache 1.1申请内存&#xff1a; 1.2释放内存&#xff1a; 1.3用TLS实现thread cache无锁访…
阅读更多...
GD32F10 串口通信

GD32F10 串口通信

1. 什么是通信 通信&#xff0c;指人与人或人与自然之间通过某种行为或媒介进行的信息交流与传递&#xff0c;从广义上指需要信息的双方或多方在不违背各自意愿的情况下采用任意方法&#xff0c;任意媒质&#xff0c;将信息从某方准确安全地传送到另方。通信双方如果想正确传输…
阅读更多...
SystemUI导航栏

SystemUI导航栏

SystemUI导航栏 1、系统中参数项1.1 相关开关属性2.2 属性设置代码 2、设置中设置“三按钮”导航更新流程2.1 属性资源覆盖叠加2.2 SystemUI导航栏接收改变广播2.3 SystemUI导航栏布局更新2.4 时序图 android13-release 1、系统中参数项 1.1 相关开关属性 设置->系统->…
阅读更多...
C++算法 —— 动态规划（9）完全背包问题

C++算法 —— 动态规划（9）完全背包问题

文章目录 1、动规思路简介2、完全背包【模板】3、零钱兑换4、零钱兑换Ⅱ5、完全平方数 背包问题需要读者先明白动态规划是什么&#xff0c;理解动规的思路&#xff0c;并不能给刚接触动规的人学习。所以最好是看了之前的动规博客&#xff0c;以及01背包博客&#xff0c;才能看完…
阅读更多...
学习C++语言可以适用于哪些方面

学习C++语言可以适用于哪些方面

学习C可以让你具备开发各种类型软件和系统的能力&#xff0c;它是一种通用的、高性能的编程语言。以下是学习C的一些用途和应用领域&#xff1a; 系统开发&#xff1a;C被广泛用于操作系统、驱动程序和嵌入式系统的开发。通过学习C&#xff0c;你可以编写底层的系统代码&#x…
阅读更多...
java大富翁

java大富翁

一、 概述 Java Swing大富翁游戏是一个经典的大富翁桌面游戏的简单实现&#xff0c;使用Java Swing库创建。该游戏允许玩家在一个虚拟棋盘上掷骰子&#xff0c;购买和升级属性&#xff0c;赚取租金和尽量丰富自己。这个文档说明将介绍如何安装和运行游戏&#xff0c;以及游戏规…
阅读更多...
【C++】C++11——右值引用和移动语义、左值引用和右值引用、右值引用使用场景和意义、完美转发、新的类功能

【C++】C++11——右值引用和移动语义、左值引用和右值引用、右值引用使用场景和意义、完美转发、新的类功能

文章目录 C115.右值引用和移动语义5.1左值引用和右值引用5.2左值引用与右值引用比较5.3右值引用使用场景和意义5.4右值引用引用左值及其一些更深入的使用场景分析5.5完美转发 6.新的类功能 C11 5.右值引用和移动语义 右值引用是C11引入的一个新特性&#xff0c;用于支持移动语义…
阅读更多...
冯诺依曼体系结构与进程的初步理解

冯诺依曼体系结构与进程的初步理解

目录 一&#xff0c;冯诺依曼体系结构 1.是什么&#xff1f;特点 2.为什么&#xff1f; 二&#xff0c;操作系统 三&#xff0c;进程 1.什么是进程&#xff1f; 2.查看进程 3.进程的管理 4.fork()创建子进程 1.fork()简介 2.fork()干了啥 3.fork()为什么会有两个返回…
阅读更多...
【Java】微服务——Ribbon负载均衡（跟进源码分析原理）

【Java】微服务——Ribbon负载均衡（跟进源码分析原理）

添加LoadBalanced注解&#xff0c;即可实现负载均衡功能&#xff0c;这是什么原理 1.负载均衡原理 SpringCloud底层其实是利用了一个名为Ribbon的组件&#xff0c;来实现负载均衡功能的。 2.源码跟踪 为什么我们只输入了service名称就可以访问了呢&#xff1f;之前还要获取…
阅读更多...
mstsc无法保存RDP凭据, 100%生效

mstsc无法保存RDP凭据, 100%生效

问题 即使如下两项都打勾&#xff0c;其还是无法保存凭据&#xff0c;特别是连接Ubuntu (freerdp server)&#xff1a; 解决方法 网上多种复杂方法&#xff0c;不生效&#xff0c;其思路是修改后台配置&#xff0c;以使mstsc跟平常一样自动记住凭据。最后&#xff0c;如下的…
阅读更多...
Python无废话-办公自动化Excel写入操作

Python无废话-办公自动化Excel写入操作

Python 办公自动化-Excel写入 创建并保存Excel文件 import openpyxl workbookopenpyxl.Workbook() #创建空Excel文件 sheetworkbook.active #获取活动的工作表 sheet.title“测试“ #修改sheet工作表名称为测试 workbook.save(“data\input\Test.xlsx”) #保存Excel文件 …
阅读更多...
R中的min()函数 和max()函数

R中的min()函数 和max()函数

通过min()函数和max()函数产生Inf 数值空集的最小值和最大值是Inf和–Inf(按此顺序&#xff01;)这确保了传递性&#xff0c;例如min(x1&#xff0c;min(x2)) min(x1&#xff0c;x2)。对于数值x&#xff0c;每当length (x) 0时&#xff0c;max(x) - Inf和min(x) Inf(如果需…
阅读更多...
C#餐饮收银系统

C#餐饮收银系统

一、引言 餐饮收银系统是一种用于管理餐馆、咖啡厅、快餐店等餐饮业务的计算机化工具。它旨在简化点餐、结账、库存管理等任务&#xff0c;提高运营效率&#xff0c;增强客户体验&#xff0c;同时提供准确的财务记录。C# 餐饮收银系统是一种使用C#编程语言开发的餐饮业务管理软…
阅读更多...
SDK Vitis记录

SDK Vitis记录

文章目录 SDK记录SDK中报错“undefined reference to sqrt”的解决方法通过XML文件导入工程的include路径方法说明 其他设置编译选项设置某些文件/文件夹不编译单独设置文件的编译选项 向存储区中导入/导出数据通过GUI操作使用命令行操作 产生C代码的MAP文件在Xilinx SDK 工程的…
阅读更多...
Golang 中的调试技巧

Golang 中的调试技巧

掌握有效的策略和工具&#xff0c;实现顺畅的开发 调试是每位开发人员都必须掌握的关键技能。它是识别、隔离和解决代码库中问题的过程。在 Golang 的世界中&#xff0c;掌握有效的调试技巧可以显著提升您的开发工作流程&#xff0c;并帮助您创建更可靠和健壮的应用程序。在本…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023