CARLA
 
载入中...
搜索中...
未找到
ActorBlueprintFunctionLibrary.cpp
浏览该文件的文档.
1// Copyright (c) 2019 Computer Vision Center (CVC) at the Universitat Autonoma
2// de Barcelona (UAB).
3// 上面两行意思是版权所有 (c) 2019 巴塞罗那自治大学 (UAB) 计算机视觉中心 (CVC)
4//
5// This work is licensed under the terms of the MIT license.(本工作遵循 MIT 许可证条款进行授权)
6// For a copy, see <https://opensource.org/licenses/MIT>.(如需副本,请访问 <https://opensource.org/licenses/MIT>)
7
8// 引入 Carla 项目的头文件
9#include "Carla.h"
10
11// 引入 Carla 中 Actor 蓝图功能库的头文件
13
14// 引入 Carla 中激光雷达描述的头文件
16
17// 引入 Carla 中场景捕获传感器的头文件
19
20// 引入 Carla 中基于着色器的传感器的头文件
22
23// 引入 Carla 中 V2X 路径损耗模型的头文件
25
26// 引入 Carla 中作用域栈工具的头文件
28
29// 引入标准算法库
30#include <algorithm>
31
32// 引入标准库中的极限值
33#include <limits>
34
35// 引入标准栈库
36#include <stack>
37
38/// Checks validity of FActorDefinition.(检查 FActorDefinition 的有效性)
40{
41public:
42
43 /// Iterate all actor definitions and their properties and display messages on
44 /// error.
45 /// 上面两行代码意思是遍历所有 actor 定义及其属性,并在出错时显示消息
46 bool AreValid(const TArray<FActorDefinition> &ActorDefinitions)
47 {
48 // 调用重载的 AreValid 方法,传入 "Actor Definition" 字符串和 actor 定义数组
49 return AreValid(TEXT("Actor Definition"), ActorDefinitions);
50 }
51
52 /// Validate @a ActorDefinition and display messages on error.(验证@a ActorDefinition的有效性,并在出现错误时显示消息)
53 bool SingleIsValid(const FActorDefinition& Definition)
54 {
55 // 使用Definition的Id构造一个作用域文本
56 auto ScopeText = FString::Printf(TEXT("[Actor Definition : %s]"), *Definition.Id);
57
58 // 将作用域文本推入Stack的作用域栈中
59 auto Scope = Stack.PushScope(ScopeText);
60
61 // 调用IsValid函数验证Definition的有效性
62 return IsValid(Definition);
63 }
64
65private:
66
67 /// If @a Predicate is false, print an error message. If possible the message
68 /// is printed to the editor window.
69 /// 上面两行代码意思是如果@a Predicate为false,则打印一条错误消息。如果可能,消息将被打印到编辑器窗口中
70 template <typename T, typename ... ARGS>
71 bool OnScreenAssert(bool Predicate, const T &Format, ARGS && ... Args) const
72 {
73 if (!Predicate)
74 {
75 FString Message;
76 // 遍历Stack中的所有字符串,并将它们添加到Message中
77 for (auto &String : Stack)
78 {
79 Message += String;
80 }
81 // 在Message末尾添加一个空格
82 Message += TEXT(" ");
83 // 使用Format和参数Args格式化字符串,并追加到Message中
84 Message += FString::Printf(Format, std::forward<ARGS>(Args) ...);
85
86 // 使用UE_LOG记录错误消息
87 UE_LOG(LogCarla, Error, TEXT("%s"), *Message);
88
89
90#if WITH_EDITOR
91 // 如果在编辑器模式下,且GEngine对象存在
92 if (GEngine)
93 {
94 // 在屏幕上显示一条调试消息,消息颜色为红色
95 GEngine->AddOnScreenDebugMessage(42, 15.0f, FColor::Red, Message);
96 }
97#endif // WITH_EDITOR(被用来检查是否正在编辑器环境中运行)
98 }
99 // 返回Predicate的值
100 return Predicate;
101 }
102
103 /// 为给定类型的项目生成显示ID。
104 template <typename T>
105 FString GetDisplayId(const FString &Type, size_t Index, const T &Item)
106 {
107 // 使用Type、Index和Item的Id构造并返回一个格式化的字符串
108 return FString::Printf(TEXT("[%s %d : %s]"), *Type, Index, *Item.Id);
109 }
110
111 /// 为给定类型的字符串项目生成显示ID的重载版本。
112 FString GetDisplayId(const FString &Type, size_t Index, const FString &Item)
113 {
114 // 使用Type、Index和Item字符串构造并返回一个格式化的字符串
115 return FString::Printf(TEXT("[%s %d : %s]"), *Type, Index, *Item);
116 }
117
118 /// Applies @a Validator to each item in @a Array. Pushes a new context to the
119 /// stack for each item.
120 /// 上面两行的意思是对@a Array中的每个元素应用@a Validator。为每个元素向堆栈推送一个新的上下文
121 template <typename T, typename F>
122bool ForEach(const FString &Type, const TArray<T> &Array, F Validator)
123{
124 bool Result = true; // 初始化结果为true,假设所有元素都通过验证。
125 auto Counter = 0u; // 初始化计数器,用于追踪当前正在验证的元素位置。
126
127 // 遍历数组中的每个元素
128 for (const auto &Item : Array)
129 {
130 // 为当前元素生成一个显示ID,并将其推送到堆栈的新上下文中。
131 // 这里假设Stack是一个能够管理上下文的某种堆栈结构,而PushScope是一个向堆栈添加新上下文的方法。
132 // GetDisplayId是一个函数,用于生成包含元素类型、索引和ID的格式化字符串。
133 auto Scope = Stack.PushScope(GetDisplayId(Type, Counter, Item));
134
135 // 对当前元素应用Validator进行验证,并将验证结果与当前Result进行逻辑与运算。
136 // 如果Validator返回false,则Result也将变为false。
137 Result &= Validator(Item);
138
139 // 计数器递增,准备验证下一个元素。
140 ++Counter;
141 }
142
143 // 返回最终的验证结果。如果所有元素都通过验证,则Result为true;否则为false。
144 return Result;
145}
146
147
148 /// Applies @a IsValid to each item in @a Array. Pushes a new context to the
149 /// stack for each item.
150 /// 上面两行代码的意思是对@a Array中的每个元素应用验证函数,为每个元素向堆栈推送一个新的上下文
151 template <typename T>
152bool AreValid(const FString &Type, const TArray<T> &Array)
153{
154 // 调用ForEach函数,传入类型名称、元素数组和一个lambda表达式作为验证函数。
155 // lambda表达式捕获当前对象(this),并调用IsValid成员函数来验证每个元素
156 return ForEach(Type, Array, [this](const auto &Item) { return IsValid(Item); });
157}
158
159 /// 验证ID是否有效
160 bool IsIdValid(const FString &Id)
161 {
162 /// @todo Do more checks.(@todo 执行更多检查)
163 // 使用OnScreenAssert函数来断言ID不为空且不是"."。如果失败,则显示错误信息
164 return OnScreenAssert((!Id.IsEmpty() && Id != TEXT(".")), TEXT("Id cannot be empty"));
165 }
166
167 /// 验证标签是否有效
168 bool AreTagsValid(const FString &Tags)
169 {
170 /// @todo Do more checks.(@todo 执行更多检查)
171 // 使用OnScreenAssert函数来断言标签不为空。如果失败,则显示错误信息
172 return OnScreenAssert(!Tags.IsEmpty(), TEXT("Tags cannot be empty"));
173 }
174
175 /// 验证类型是否有效
177 {
178 /// @todo Do more checks.(@todo 执行更多检查)
179 // 使用OnScreenAssert函数来断言类型值小于EActorAttributeType枚举的大小。如果失败,则显示错误信息
180 return OnScreenAssert(Type < EActorAttributeType::SIZE, TEXT("Invalid type"));
181 }
182
183 /// 验证值是否有效
184 bool ValueIsValid(const EActorAttributeType Type, const FString &Value)
185 {
186 /// @todo Do more checks.(@todo 执行更多检查)
187 // 当前版本未执行任何检查,直接返回true
188 return true;
189 }
190
191 // 判断给定的因子变化是否有效
192 bool IsValid(const FActorVariation &Variation)
193 {
194 // 返回以下条件都为真的结果
195 return
196
197 //因子变化的ID有效
198 IsIdValid(Variation.Id) &&
199
200 //因子变化的类型有效
201 IsValid(Variation.Type) &&
202
203 //因子变化的推荐值数量大于0,且推荐值不能为空
204 OnScreenAssert(Variation.RecommendedValues.Num() > 0, TEXT("Recommended values cannot be empty")) &&
205
206 //对每个推荐值,调用一个lambda函数检查其是否有效,该函数根据因子变化的类型检查值的有效性
207 ForEach(TEXT("Recommended Value"), Variation.RecommendedValues, [&](auto &Value) {
208 return ValueIsValid(Variation.Type, Value);
209 });
210 }
211
212 // 判断给定的因子属性是否有效
213 bool IsValid(const FActorAttribute &Attribute)
214 {
215 // 返回以下条件都为真的结果
216 return
217
218 //因子属性的ID有效
219 IsIdValid(Attribute.Id) &&
220
221 //因子属性的类型有效
222 IsValid(Attribute.Type) &&
223
224 //根据因子属性的类型,其值有效
225 ValueIsValid(Attribute.Type, Attribute.Value);
226 }
227
228 // 判断给定的角色定义是否有效
229 bool IsValid(const FActorDefinition &ActorDefinition)
230 {
231 /// @todo Validate Class and make sure IDs are not repeated.(@todo验证类别并确保ID不重复)
232 //返回以下条件都为真的结果
233 return
234
235 //角色定义的ID有效
236 IsIdValid(ActorDefinition.Id) &&
237
238 //角色定义的标签有效
239 AreTagsValid(ActorDefinition.Tags) &&
240
241 //角色定义的变化(因子变化)集合有效
242 AreValid(TEXT("Variation"), ActorDefinition.Variations) &&
243
244 //角色定义的属性集合有效
245 AreValid(TEXT("Attribute"), ActorDefinition.Attributes);
246 }
247 // 一个FScopedStack<FString>类型的栈实例,用于特定的字符串管理或操作
249};
250
251// 定义一个模板函数,用于将多个字符串使用指定的分隔符连接起来
252template <typename ... ARGS>
253static FString JoinStrings(const FString &Separator, ARGS && ... Args)
254{
255 // 使用FString的Join方法,将Args中的字符串使用Separator连接起来
256 // std::forward<ARGS>(Args) ... 是完美转发,用于保持参数的左值或右值属性
257 // TArray<FString>{std::forward<ARGS>(Args) ...} 创建了一个包含所有参数的FString数组
258 return FString::Join(TArray<FString>{std::forward<ARGS>(Args) ...}, *Separator);
259}
260
261// 定义一个函数,用于将FColor颜色对象转换为FString字符串
262// 字符串格式为 "R,G,B",其中R、G、B是颜色的红、绿、蓝分量
263static FString ColorToFString(const FColor &Color)
264{
265 // 调用JoinStrings函数,将颜色的红、绿、蓝分量转换为字符串并用逗号连接
266 return JoinStrings(
267 TEXT(","), // 使用逗号作为分隔符
268 FString::FromInt(Color.R), // 将红色分量转换为字符串
269 FString::FromInt(Color.G), // 将绿色分量转换为字符串
270 FString::FromInt(Color.B)); // 将蓝色分量转换为字符串
271}
272
273/// ============================================================================
274/// -- Actor definition validators(Actor定义验证器) --------------------------
275/// ============================================================================
276
277// UActorBlueprintFunctionLibrary类中的成员函数,用于验证单个Actor定义的有效性
279{
280 // 创建FActorDefinitionValidator验证器对象
282
283 // 调用验证器的SingleIsValid方法,验证单个Actor定义的有效性
284 return Validator.SingleIsValid(ActorDefinition);
285}
286
287// UActorBlueprintFunctionLibrary类中的成员函数,用于验证多个Actor定义的有效性
288bool UActorBlueprintFunctionLibrary::CheckActorDefinitions(const TArray<FActorDefinition> &ActorDefinitions)
289{
290 // 创建FActorDefinitionValidator验证器对象
292
293 // 调用验证器的AreValid方法,验证多个Actor定义的有效性
294 return Validator.AreValid(ActorDefinitions);
295}
296
297/// ============================================================================
298/// -- Helpers to create actor definitions (创建Actor定义的辅助函数)----------
299/// ============================================================================
300
301// 定义一个模板函数,接受任意数量的字符串参数(可变参数模板)
302template <typename ... TStrs>
303
304// 静态函数,用于填充参与者定义(FActorDefinition)的ID和标签(Tags),以及添加一些默认属性
305static void FillIdAndTags(FActorDefinition& Def, TStrs && ... Strings)
306{
307 // 将传入的字符串参数用"."连接,并转换为小写,作为参与者的ID
308 Def.Id = JoinStrings(TEXT("."), std::forward<TStrs>(Strings) ...).ToLower();
309
310 // 将传入的字符串参数用","连接,并转换为小写,作为参与者的标签
311 Def.Tags = JoinStrings(TEXT(","), std::forward<TStrs>(Strings) ...).ToLower();
312
313 // 每个参与者都会有一个角色名称属性(默认为空)
314 FActorVariation ActorRole;
315 ActorRole.Id = TEXT("role_name"); // 属性ID
316 ActorRole.Type = EActorAttributeType::String; // 属性类型:字符串
317 ActorRole.RecommendedValues = { TEXT("default") }; // 推荐值:默认
318 ActorRole.bRestrictToRecommended = false; // 是否限制为推荐值:否
319 Def.Variations.Emplace(ActorRole); // 将参与者名称属性添加到角色的属性列表中
320
321 // ROS2相关的属性设置
322 FActorVariation Var;
323 Var.Id = TEXT("ros_name"); // 属性ID:ros名称
324 Var.Type = EActorAttributeType::String; // 属性类型:字符串
325 Var.RecommendedValues = { Def.Id }; // 推荐值:参与者的ID
326 Var.bRestrictToRecommended = false; // 是否限制为推荐值:否
327 Def.Variations.Emplace(Var); // 将ROS2名称属性添加到参与者的属性列表中
328}
329
330// 定义一个静态函数,用于为参与者名称属性添加推荐值
332 FActorDefinition &Definition, // 参与者定义引用
333 TArray<FString> &&RecommendedValues) // 推荐值的数组(右值引用)
334{
335 // 遍历参与者的属性列表
336 for (auto &&ActorVariation: Definition.Variations)
337 {
338 // 如果找到ID为"role_name"的属性
339 if (ActorVariation.Id == "role_name")
340 {
341 // 将该属性的推荐值设置为传入的推荐值
342 ActorVariation.RecommendedValues = RecommendedValues;
343 return; // 找到后直接返回,不再继续遍历
344 }
345 }
346}
347
348// 定义一个函数,用于为传感器的参与者名称添加推荐值
350{
351 // 为参与者定义的参与者名称添加推荐的传感器位置名称
352 AddRecommendedValuesForActorRoleName(Definition, { TEXT("front"), TEXT("back"), TEXT("left"), TEXT("right"), TEXT("front_left"), TEXT("front_right"), TEXT("back_left"), TEXT("back_right") });
353}
354
355// 定义一个函数,用于为传感器添加变化属性
357{
358 // 创建一个参与者变化对象
359 FActorVariation Tick;
360
361 // 设置变化对象的ID为"sensor_tick"
362 Tick.Id = TEXT("sensor_tick");
363
364 // 设置变化对象的类型为浮点型
366
367 // 设置变化对象的推荐值为"0.0"
368 Tick.RecommendedValues = { TEXT("0.0") };
369
370 // 设置是否限制只能使用推荐值,这里为false,表示不限制
371 Tick.bRestrictToRecommended = false;
372
373 // 将变化对象添加到参与者定义的变化列表中
374 Def.Variations.Emplace(Tick);
375}
376
377// 定义一个函数,用于为触发器添加变化属性
379{
380 // Friction(摩擦力)
381 FActorVariation Friction;
382
383 // 设置摩擦力变化对象的ID为"friction"
384 Friction.Id = FString("friction");
385
386 // 设置摩擦力变化对象的类型为浮点型
388
389 // 设置摩擦力变化对象的推荐值为"3.5f"
390 Friction.RecommendedValues = { TEXT("3.5f") };
391
392 // 设置是否限制只能使用推荐值,这里为false,表示不限制
393 Friction.bRestrictToRecommended = false;
394
395 // 将摩擦力变化对象添加到参与者定义的变化列表中
396 Def.Variations.Emplace(Friction);
397
398 // Extent(范围)
399 FString Extent("extent");
400 FString Coordinates[3] = { FString("x"), FString("y"), FString("z") }; // 定义三个坐标轴x, y, z
401
402 // 遍历坐标轴数组
403 for (auto Coordinate : Coordinates)
404 {
405 FActorVariation ExtentCoordinate; // 为每个坐标轴创建一个变化对象
406
407 // 设置变化对象的ID,格式为"extent_x", "extent_y", "extent_z"
408 ExtentCoordinate.Id = JoinStrings(TEXT("_"), Extent, Coordinate);
409
410 // 设置变化对象的类型为浮点型
411 ExtentCoordinate.Type = EActorAttributeType::Float;
412
413 // 设置变化对象的推荐值为"1.0f"
414 ExtentCoordinate.RecommendedValues = { TEXT("1.0f") };
415
416 // 设置是否限制只能使用推荐值,这里为false,表示不限制
417 ExtentCoordinate.bRestrictToRecommended = false;
418
419 // 将变化对象添加到参与者定义的变化列表中
420 Def.Variations.Emplace(ExtentCoordinate);
421 }
422}
423
424// 在UActorBlueprintFunctionLibrary类中定义一个成员函数,用于创建一个通用的Actor定义。
425// 它接收三个参数:分类(Category)、类型(Type)和ID(Id),并返回一个参与者对象。
427
428 // 分类名称
429 const FString& Category,
430
431 // 参与者的类型
432 const FString& Type,
433
434 // 参与者的唯一标识符
435 const FString& Id)
436{
437 // 创建一个参与者对象,用于存储Actor的定义
438 FActorDefinition Definition;
439
440 // 调用FillIdAndTags函数,填充定义中的ID和标签
441 FillIdAndTags(Definition, Category, Type, Id);
442
443 // 返回填充后的定义
444 return Definition;
445}
446
447// 在UActorBlueprintFunctionLibrary类中定义一个成员函数,专门用于创建传感器类型的Actor定义。
448// 它接收两个参数:类型(Type)和ID(Id),并返回一个FActorDefinition对象。
450
451 // 传感器的类型
452 const FString& Type,
453
454 // 传感器的唯一标识符
455 const FString& Id)
456{
457 // 调用MakeGenericDefinition函数,创建一个分类为“sensor”的通用定义
458 auto Definition = MakeGenericDefinition(TEXT("sensor"), Type, Id);
459
460 // 调用AddRecommendedValuesForSensorRoleNames函数,为定义添加建议的传感器角色名称值
462
463 // 返回填充后的定义
464 return Definition;
465}
466
467// 在UActorBlueprintFunctionLibrary类中定义一个成员函数,用于创建一个相机Actor的定义。
468// 它接收两个参数:ID(Id)和一个布尔值(bEnableModifyingPostProcessEffects),指示是否允许修改后处理效果。
469// 函数返回一个FActorDefinition对象。
471
472 // 相机的唯一标识符
473 const FString& Id,
474
475 // 是否允许修改后处理效果的标志
476 const bool bEnableModifyingPostProcessEffects)
477{
478 // 创建一个参与者对象,用于存储相机的定义
479 FActorDefinition Definition;
480
481 // 定义一个布尔变量,用于指示定义创建是否成功
482 bool Success;
483
484 // 调用一个重载版本的MakeCameraDefinition函数(未在代码片段中给出),该版本接受一个额外的Success参数用于输出操作结果
485 MakeCameraDefinition(Id, bEnableModifyingPostProcessEffects, Success, Definition);
486
487 // 使用check宏确保定义创建成功,如果失败则触发断言
488 check(Success);
489
490 // 返回填充后的定义
491 return Definition;
492}
493
494// 定义一个函数,用于创建相机定义
495// 该函数属于UActorBlueprintFunctionLibrary类
497
498 // 相机的唯一标识符
499 const FString& Id,
500
501 // 是否允许修改后处理效果
502 const bool bEnableModifyingPostProcessEffects,
503
504 // 函数执行成功与否的标志,通过引用传递,函数内部可以修改其值
505 bool& Success,
506
507 // 相机定义的对象,通过引用传递,函数内部会对其进行填充
508 FActorDefinition& Definition)
509{
510 // 填充相机定义的基本信息,包括Id和标签(此处标签为"sensor"和"camera")
511 FillIdAndTags(Definition, TEXT("sensor"), TEXT("camera"), Id);
512
513 // 为相机定义添加推荐的参与者名称值,这些值通常与传感器的参与者有关
515
516 // 为相机定义添加传感器相关的变体(可能是不同的配置或参数集合)
517 AddVariationsForSensor(Definition);
518
519 // 下面的代码块用于添加相机的视野(Field of View, FOV)定义
520
521 // 创建一个FActorVariation对象,用于表示FOV的定义
522 FActorVariation FOV;
523
524 // 设置FOV定义的标识符为"fov"
525 FOV.Id = TEXT("fov");
526
527 // 设置FOV的类型为浮点型
529
530 // 为FOV设置一个推荐的值,这里是90.0度
531 FOV.RecommendedValues = { TEXT("90.0") };
532
533 // 设置是否限制用户只能使用推荐的值,这里设置为false,表示用户可以选择其他值
534 FOV.bRestrictToRecommended = false;
535
536 // 关于分辨率
537 // 定义图像的宽度(X轴)变化的结构体
538 FActorVariation ResX;
539
540 // 设置该变化项的标识符为"image_size_x"
541 ResX.Id = TEXT("image_size_x");
542
543 // 设置该变化项的类型为整数(Int)
545
546 // 设置推荐的值为"800"
547 ResX.RecommendedValues = { TEXT("800") };
548
549 // 设置是否限制用户只能使用推荐值,这里设置为false,意味着用户可以选择其他值
550 ResX.bRestrictToRecommended = false;
551
552 // 定义图像的高度(Y轴)变化的结构体
553 FActorVariation ResY;
554
555 // 设置该变化项的标识符为"image_size_y"
556 ResY.Id = TEXT("image_size_y");
557
558 // 设置该变化项的类型为整数(Int)
560
561 // 设置推荐的值为"600"(同样以文本形式给出,但实际为整数)
562 ResY.RecommendedValues = { TEXT("600") };
563
564 // 设置是否限制用户只能使用推荐值,这里同样设置为false
565 ResY.bRestrictToRecommended = false;
566
567 // 镜头参数
568 // 定义镜头圆形衰减参数的结构体
569 FActorVariation LensCircleFalloff;
570
571 // 设置该变化项的标识符为"lens_circle_falloff"
572 LensCircleFalloff.Id = TEXT("lens_circle_falloff");
573
574 // 设置该变化项的类型为浮点数(Float)
575 LensCircleFalloff.Type = EActorAttributeType::Float;
576
577 // 设置推荐的值为"5.0"
578 LensCircleFalloff.RecommendedValues = { TEXT("5.0") };
579
580 // 设置是否限制用户只能使用推荐值,这里设置为false
581 LensCircleFalloff.bRestrictToRecommended = false;
582
583 // 定义镜头圆形倍增参数的结构体
584 FActorVariation LensCircleMultiplier;
585
586 // 设置该变化项的标识符为"lens_circle_multiplier"
587 LensCircleMultiplier.Id = TEXT("lens_circle_multiplier");
588
589 // 设置该变化项的类型为浮点数(Float)
590 LensCircleMultiplier.Type = EActorAttributeType::Float;
591
592 // 设置推荐的值为"0.0"(以文本形式给出,但实际为浮点数)
593 LensCircleMultiplier.RecommendedValues = { TEXT("0.0") };
594
595 // 设置是否限制用户只能使用推荐值,这里同样设置为false
596 LensCircleMultiplier.bRestrictToRecommended = false;
597
598 // 定义一个FActorVariation类型的变量LensK,用于表示某种属性或参数的变化
599 FActorVariation LensK;
600
601 // 为LensK设置唯一标识符,这里是一个文本字符串"lens_k"
602 LensK.Id = TEXT("lens_k");
603
604 // 设置LensK的属性类型为浮点型
606
607 // 为LensK设置一个推荐值列表,这里只有一个值"-1.0"
608 LensK.RecommendedValues = { TEXT("-1.0") };
609
610 // 设置是否将LensK的值限制在推荐值之内,这里设置为false,表示不限制
611 LensK.bRestrictToRecommended = false;
612
613 // 定义一个FActorVariation类型的变量LensKcube,与LensK类似,但表示不同的属性或参数
614 FActorVariation LensKcube;
615
616 // 为LensKcube设置唯一标识符"lens_kcube"
617 LensKcube.Id = TEXT("lens_kcube");
618
619 // 设置LensKcube的属性类型也为浮点型
621
622 // 为LensKcube设置一个推荐值列表,这里只有一个值"0.0"
623 LensKcube.RecommendedValues = { TEXT("0.0") };
624
625 // 设置是否将LensKcube的值限制在推荐值之内,这里也设置为false
626 LensKcube.bRestrictToRecommended = false;
627
628 // 定义一个FActorVariation类型的变量LensXSize,表示透镜在X轴方向上的尺寸变化
629 FActorVariation LensXSize;
630
631 // 为LensXSize设置唯一标识符"lens_x_size"
632 LensXSize.Id = TEXT("lens_x_size");
633
634 // 设置LensXSize的属性类型也为浮点型
636
637 // 为LensXSize设置一个推荐值列表,这里只有一个值"0.08"
638 LensXSize.RecommendedValues = { TEXT("0.08") };
639
640 // 设置是否将LensXSize的值限制在推荐值之内,这里也设置为false
641 LensXSize.bRestrictToRecommended = false;
642
643 // 定义一个FActorVariation类型的变量LensYSize,表示透镜在Y轴方向上的尺寸变化
644 FActorVariation LensYSize;
645
646 // 为LensYSize设置唯一标识符"lens_y_size"
647 LensYSize.Id = TEXT("lens_y_size");
648
649 // 设置LensYSize的属性类型也为浮点型
651
652 // 为LensYSize设置一个推荐值列表,这里只有一个值"0.08"
653 LensYSize.RecommendedValues = { TEXT("0.08") };
654
655 // 设置是否将LensYSize的值限制在推荐值之内,这里也设置为false
656 LensYSize.bRestrictToRecommended = false;
657
658
659 // 将一系列变量(如分辨率、视野等)添加到定义的变化列表中
660Definition.Variations.Append({
661 ResX, // 分辨率X轴
662 ResY, // 分辨率Y轴
663 FOV, // 视野(Field of View)
664 LensCircleFalloff, // 镜头圆形衰减
665 LensCircleMultiplier, // 镜头圆形倍增器
666 LensK, // 镜头K值(一种镜头畸变参数)
667 LensKcube, // 镜头K立方值(另一种镜头畸变参数)
668 LensXSize, // 镜头X轴尺寸
669 LensYSize}); // 镜头Y轴尺寸
670
671// 如果启用了修改后处理效果的功能
672if (bEnableModifyingPostProcessEffects)
673{
674 // 创建一个后处理效果的变化定义
675 FActorVariation PostProccess;
676 PostProccess.Id = TEXT("enable_postprocess_effects"); // 设置变化的标识符
677 PostProccess.Type = EActorAttributeType::Bool; // 设置变化类型为布尔值
678 PostProccess.RecommendedValues = { TEXT("true") }; // 设置推荐的值为"true"(启用)
679 PostProccess.bRestrictToRecommended = false; // 不限制用户只能使用推荐值
680
681 // 创建一个关于Gamma值的变化定义
682 FActorVariation Gamma;
683 Gamma.Id = TEXT("gamma"); // 设置变化的标识符为"gamma"
684 Gamma.Type = EActorAttributeType::Float; // 设置变化类型为浮点数
685 Gamma.RecommendedValues = { TEXT("2.2") }; // 设置推荐的Gamma值为2.2
686 Gamma.bRestrictToRecommended = false; // 不限制用户只能使用推荐的Gamma值
687}
688
689 // 运动模糊配置
690 // 定义运动模糊强度的变化属性
691 FActorVariation MBIntesity;
692 MBIntesity.Id = TEXT("motion_blur_intensity"); // 设置属性的唯一标识符
693 MBIntesity.Type = EActorAttributeType::Float; // 指定属性类型为浮点数
694 MBIntesity.RecommendedValues = { TEXT("0.45") }; // 设置推荐的运动模糊强度值
695 MBIntesity.bRestrictToRecommended = false; // 允许用户选择不使用推荐值
696
697 // 定义运动模糊最大扭曲的变化属性
698 FActorVariation MBMaxDistortion;
699 MBMaxDistortion.Id = TEXT("motion_blur_max_distortion"); // 设置属性的唯一标识符
700 MBMaxDistortion.Type = EActorAttributeType::Float; // 指定属性类型为浮点数
701 MBMaxDistortion.RecommendedValues = { TEXT("0.35") }; // 设置推荐的运动模糊最大扭曲值
702 MBMaxDistortion.bRestrictToRecommended = false; // 允许用户选择不使用推荐值
703
704 // 定义运动模糊最小对象屏幕尺寸的变化属性
705 FActorVariation MBMinObjectScreenSize;
706 MBMinObjectScreenSize.Id = TEXT("motion_blur_min_object_screen_size"); // 设置属性的唯一标识符
707 MBMinObjectScreenSize.Type = EActorAttributeType::Float; // 指定属性类型为浮点数
708 MBMinObjectScreenSize.RecommendedValues = { TEXT("0.1") }; // 设置推荐的运动模糊最小对象屏幕尺寸值
709 MBMinObjectScreenSize.bRestrictToRecommended = false; // 允许用户选择不使用推荐值
710
711 // 关于镜头光晕效果的设置
712 FActorVariation LensFlareIntensity; // 声明一个FActorVariation类型的对象,用于存储镜头光晕强度的配置
713
714 // 设置对象的Id属性,用于唯一标识这个变量
715 LensFlareIntensity.Id = TEXT("lens_flare_intensity"); // 将Id设置为"lens_flare_intensity",这是一个字符串标识符
716
717 // 设置对象的Type属性,指定变量的数据类型
718 LensFlareIntensity.Type = EActorAttributeType::Float; // 将类型设置为浮点型(Float),意味着镜头光晕的强度是一个浮点数
719
720 // 设置RecommendedValues属性,提供推荐的变量值列表
721 LensFlareIntensity.RecommendedValues = { TEXT("0.1") }; // 这里只提供了一个推荐值"0.1",意味着默认情况下镜头光晕的强度被设置为0.1
722
723 // 设置bRestrictToRecommended属性,决定变量值是否必须为推荐值之一
724 LensFlareIntensity.bRestrictToRecommended = false; // 设置为false,意味着镜头光晕的强度值不仅限于推荐值,可以是任意浮点数。
725
726
727 // 初始化一个名为BloomIntensity的FActorVariation对象,用于控制Bloom效果的强度
728 FActorVariation BloomIntensity;
729
730 // 设置BloomIntensity的标识符(ID)为"bloom_intensity",用于在引擎中唯一标识这个变量
731 BloomIntensity.Id = TEXT("bloom_intensity");
732
733 // 设置BloomIntensity的类型为Float,表示这个变量的值是一个浮点数
734 BloomIntensity.Type = EActorAttributeType::Float;
735
736 // 设置BloomIntensity的推荐值为0.675。这通常是一个经验值,可以在编辑器中作为默认值或推荐值显示
737 BloomIntensity.RecommendedValues = { TEXT("0.675") };
738
739 // 设置BloomIntensity是否限制为仅使用推荐值。这里设置为false,意味着用户可以选择任何值
740 BloomIntensity.bRestrictToRecommended = false;
741
742 // 更多信息(这些链接提供了关于如何在Unreal Engine中使用和配置这些效果的详细信息):
743 // https://docs.unrealengine.com/en-US/Engine/Rendering/PostProcessEffects/AutomaticExposure/index.html
744 // https://docs.unrealengine.com/en-US/Engine/Rendering/PostProcessEffects/DepthOfField/CinematicDOFMethods/index.html
745 // https://docs.unrealengine.com/en-US/Engine/Rendering/PostProcessEffects/ColorGrading/index.html
746
747 // 初始化一个名为ExposureMode的FActorVariation对象,用于控制曝光模式
748 FActorVariation ExposureMode;
749
750 // 设置ExposureMode的标识符(ID)为"exposure_mode",用于在引擎中唯一标识这个变量
751 ExposureMode.Id = TEXT("exposure_mode");
752
753 // 设置ExposureMode的类型为String,表示这个变量的值是一个字符串
754 ExposureMode.Type = EActorAttributeType::String;
755
756 // 设置ExposureMode的推荐值为"histogram"和"manual",表示曝光模式可以是基于直方图的自动曝光或手动曝光
757 ExposureMode.RecommendedValues = { TEXT("histogram"), TEXT("manual") };
758
759 // 设置ExposureMode是否限制为仅使用推荐值。这里设置为true,意味着用户只能选择推荐值之一
760 ExposureMode.bRestrictToRecommended = true;
761
762 // 初始化一个名为ExposureCompensation的FActorVariation对象,用于控制曝光的对数调整
763 FActorVariation ExposureCompensation;
764
765 // 设置ExposureCompensation的标识符(ID)为"exposure_compensation",用于在引擎中唯一标识这个变量
766 ExposureCompensation.Id = TEXT("exposure_compensation");
767
768 // 设置ExposureCompensation的类型为Float,表示这个变量的值是一个浮点数
769 ExposureCompensation.Type = EActorAttributeType::Float;
770
771 // 设置ExposureCompensation的推荐值为0.0
772 // 不同的值代表不同的亮度调整倍数:-1表示2倍暗,-2表示4倍暗;1表示2倍亮,2表示4倍亮
773 ExposureCompensation.RecommendedValues = { TEXT("0.0") };
774
775 // 设置ExposureCompensation是否限制为仅使用推荐值。这里设置为false,意味着用户可以选择任何值
776 ExposureCompensation.bRestrictToRecommended = false;
777
778 // - 手动设置 ------------------------------------------------
779
780 // 用于计算相机曝光比例的公式是:
781 // 曝光 = 1 / (1.2 * 2^(log2( N²/t * 100/S )))
782
783 // 相机的快门速度,单位为秒
784 FActorVariation ShutterSpeed; // (1/t),t为快门时间的倒数
785 ShutterSpeed.Id = TEXT("shutter_speed"); // 设置属性ID为"shutter_speed"
786 ShutterSpeed.Type = EActorAttributeType::Float; // 设置属性类型为浮点型
787 ShutterSpeed.RecommendedValues = { TEXT("200.0") }; // 设置推荐的属性值为"200.0"
788 ShutterSpeed.bRestrictToRecommended = false; // 设置是否限制用户只能使用推荐值
789
790 // 相机的传感器灵敏度。
791 FActorVariation ISO; // S,感光度
792 ISO.Id = TEXT("iso"); // 设置属性ID为"iso"
793 ISO.Type = EActorAttributeType::Float; // 设置属性类型为浮点型
794 ISO.RecommendedValues = { TEXT("100.0") }; // 设置推荐的属性值为"100.0"
795 ISO.bRestrictToRecommended = false; // 设置是否限制用户只能使用推荐值
796
797 // 定义相机镜头开口的大小。
798 // 使用较大的数值将减少景深(DOF)效果。
799 FActorVariation Aperture; // N,光圈值(f值),注意这里注释中的N与代码中的fstop对应,通常f值越小,光圈越大
800 Aperture.Id = TEXT("fstop"); // 设置属性ID为"fstop"
801 Aperture.Type = EActorAttributeType::Float; // 设置属性类型为浮点型
802 Aperture.RecommendedValues = { TEXT("1.4") }; // 设置推荐的属性值为"1.4"
803 Aperture.bRestrictToRecommended = false; // 设置是否限制用户只能使用推荐值
804
805
806 // - 直方图相关设置 ---------------------------------------------
807
808 // 自动曝光的最小亮度值,它限制了眼睛能够适应的最低亮度范围
809 FActorVariation ExposureMinBright; // 自动曝光最小亮度变量
810 ExposureMinBright.Id = TEXT("exposure_min_bright"); // 设置变量的ID为"exposure_min_bright"
811 ExposureMinBright.Type = EActorAttributeType::Float; // 设置变量的类型为浮点型
812 ExposureMinBright.RecommendedValues = { TEXT("10.0") }; // 设置推荐值为10.0
813 ExposureMinBright.bRestrictToRecommended = false; // 设置不限制变量值必须为推荐值
814
815 // 自动曝光的最大亮度值,它限制了眼睛能够适应的最高亮度范围
816 FActorVariation ExposureMaxBright; // 自动曝光最大亮度变量
817 ExposureMaxBright.Id = TEXT("exposure_max_bright"); // 设置变量的ID为"exposure_max_bright"
818 ExposureMaxBright.Type = EActorAttributeType::Float; // 设置变量的类型为浮点型
819 ExposureMaxBright.RecommendedValues = { TEXT("12.0") }; // 设置推荐值为12.0
820 ExposureMaxBright.bRestrictToRecommended = false; // 设置不限制变量值必须为推荐值
821
822 // 从暗环境到亮环境的适应速度
823 FActorVariation ExposureSpeedUp; // 曝光上调速度变量
824 ExposureSpeedUp.Id = TEXT("exposure_speed_up"); // 设置变量的ID为"exposure_speed_up"
825 ExposureSpeedUp.Type = EActorAttributeType::Float; // 设置变量的类型为浮点型
826 ExposureSpeedUp.RecommendedValues = { TEXT("3.0") }; // 设置推荐值为3.0
827 ExposureSpeedUp.bRestrictToRecommended = false; // 设置不限制变量值必须为推荐值
828
829 // 从亮环境到暗环境的适应速度
830 FActorVariation ExposureSpeedDown; // 曝光下调速度变量
831 ExposureSpeedDown.Id = TEXT("exposure_speed_down"); // 设置变量的ID为"exposure_speed_down"
832 ExposureSpeedDown.Type = EActorAttributeType::Float; // 设置变量的类型为浮点型
833 ExposureSpeedDown.RecommendedValues = { TEXT("1.0") }; // 设置推荐值为1.0
834 ExposureSpeedDown.bRestrictToRecommended = false; // 设置不限制变量值必须为推荐值
835
836 // 18%反射率(Albedo)的校准常数
837 FActorVariation CalibrationConstant; // 校准常数变量
838 CalibrationConstant.Id = TEXT("calibration_constant"); // 设置变量的ID为"calibration_constant"
839 CalibrationConstant.Type = EActorAttributeType::Float; // 设置变量的类型为浮点型
840 CalibrationConstant.RecommendedValues = { TEXT("16.0") }; // 设置推荐值为16.0
841 CalibrationConstant.bRestrictToRecommended = false; // 设置不限制变量值必须为推荐值
842
843 // 景深效果应保持清晰的距离
844 // 单位为虚幻引擎单位(厘米)
845 FActorVariation FocalDistance; // 焦距距离变量
846 FocalDistance.Id = TEXT("focal_distance"); // 设置变量的ID为"focal_distance"
847 FocalDistance.Type = EActorAttributeType::Float; // 设置变量的类型为浮点型
848 FocalDistance.RecommendedValues = { TEXT("1000.0") }; // 设置推荐值为1000.0
849 FocalDistance.bRestrictToRecommended = false; // 设置不限制变量值必须为推荐值
850
851 // 50%深度模糊系数
852 FActorVariation DepthBlurAmount; // 深度模糊量
853 DepthBlurAmount.Id = TEXT("blur_amount"); // 标识符为"blur_amount"
854 DepthBlurAmount.Type = EActorAttributeType::Float; // 类型为浮点数
855 DepthBlurAmount.RecommendedValues = { TEXT("1.0") }; // 推荐值为1.0
856 DepthBlurAmount.bRestrictToRecommended = false; // 不限制为推荐值
857
858 // 在1920x分辨率下的深度模糊半径(以像素为单位)
859 FActorVariation DepthBlurRadius; // 深度模糊半径
860 DepthBlurRadius.Id = TEXT("blur_radius"); // 标识符为"blur_radius"
861 DepthBlurRadius.Type = EActorAttributeType::Float; // 类型为浮点数
862 DepthBlurRadius.RecommendedValues = { TEXT("0.0") }; // 推荐值为0.0
863 DepthBlurRadius.bRestrictToRecommended = false; // 不限制为推荐值
864
865 // 定义相机镜头的开口大小,光圈是1.0/fstop,
866 // 典型的镜头可以小到f/1.2(大开口),
867 // 较大的数值会减少景深效果
868 FActorVariation MaxAperture; // 最大光圈
869 MaxAperture.Id = TEXT("min_fstop"); // 标识符为"min_fstop"
870 MaxAperture.Type = EActorAttributeType::Float; // 类型为浮点数
871 MaxAperture.RecommendedValues = { TEXT("1.2") }; // 推荐值为1.2
872 MaxAperture.bRestrictToRecommended = false; // 不限制为推荐值
873
874 // 定义镜头内光圈叶片的数量(在4到16之间)
875 FActorVariation BladeCount; // 叶片数量
876 BladeCount.Id = TEXT("blade_count"); // 标识符为"blade_count"
877 BladeCount.Type = EActorAttributeType::Int; // 类型为整数
878 BladeCount.RecommendedValues = { TEXT("5") }; // 推荐值为5
879 BladeCount.bRestrictToRecommended = false; // 不限制为推荐值
880
881 // - 调色映射器设置 -----------------------------------
882 // 您可以调整这些调色映射器控件,以模拟其他类型的胶片库存,用于您的项目
883 FActorVariation FilmSlope; // 胶片斜率变量
884 FilmSlope.Id = TEXT("slope"); // 变量标识符设置为"slope"
885 FilmSlope.Type = EActorAttributeType::Float; // 变量类型设置为浮点型
886 FilmSlope.RecommendedValues = { TEXT("0.88") }; // 推荐值设置为0.88
887 FilmSlope.bRestrictToRecommended = false; // 不限制用户只能使用推荐值
888
889 FActorVariation FilmToe; // 胶片趾部变量
890 FilmToe.Id = TEXT("toe"); // 变量标识符设置为"toe"
891 FilmToe.Type = EActorAttributeType::Float; // 变量类型设置为浮点型
892 FilmToe.RecommendedValues = { TEXT("0.55") }; // 推荐值设置为0.55
893 FilmToe.bRestrictToRecommended = false; // 不限制用户只能使用推荐值
894
895 FActorVariation FilmShoulder; // 胶片肩部变量
896 FilmShoulder.Id = TEXT("shoulder"); // 变量标识符设置为"shoulder"
897 FilmShoulder.Type = EActorAttributeType::Float; // 变量类型设置为浮点型
898 FilmShoulder.RecommendedValues = { TEXT("0.26") }; // 推荐值设置为0.26
899 FilmShoulder.bRestrictToRecommended = false; // 不限制用户只能使用推荐值
900
901 FActorVariation FilmBlackClip; // 胶片黑色截断变量
902 FilmBlackClip.Id = TEXT("black_clip"); // 变量标识符设置为"black_clip"
903 FilmBlackClip.Type = EActorAttributeType::Float; // 变量类型设置为浮点型
904 FilmBlackClip.RecommendedValues = { TEXT("0.0") }; // 推荐值设置为0.0
905 FilmBlackClip.bRestrictToRecommended = false; // 不限制用户只能使用推荐值
906
907 FActorVariation FilmWhiteClip; // 胶片白色截断变量
908 FilmWhiteClip.Id = TEXT("white_clip"); // 变量标识符设置为"white_clip"
909 FilmWhiteClip.Type = EActorAttributeType::Float; // 变量类型设置为浮点型
910 FilmWhiteClip.RecommendedValues = { TEXT("0.04") }; // 推荐值设置为0.04
911 FilmWhiteClip.bRestrictToRecommended = false; // 不限制用户只能使用推荐值
912
913
914 // 颜色相关设置
915 FActorVariation Temperature;// 温度变量
916 Temperature.Id = TEXT("temp"); // 设置温度变量的标识符为"temp"
917 Temperature.Type = EActorAttributeType::Float;// 设置温度变量的类型为浮点数
918 Temperature.RecommendedValues = { TEXT("6500.0") };// 为温度变量设置推荐值
919 Temperature.bRestrictToRecommended = false;// 设置是否限制变量值只能为推荐值
920
921 FActorVariation Tint; // 色调变量
922 Tint.Id = TEXT("tint");// 设置色调变量的标识符为"tint"
923 Tint.Type = EActorAttributeType::Float;// 设置色调变量的类型为浮点数
924 Tint.RecommendedValues = { TEXT("0.0") };// 为色调变量设置推荐值
925 Tint.bRestrictToRecommended = false;// 设置是否限制变量值只能为推荐值
926
927 FActorVariation ChromaticIntensity;// 色散强度变量
928 ChromaticIntensity.Id = TEXT("chromatic_aberration_intensity");// 设置色散强度变量的标识符为"chromatic_aberration_intensity"
929 ChromaticIntensity.Type = EActorAttributeType::Float; // 设置色散强度变量的类型为浮点数
930 ChromaticIntensity.RecommendedValues = { TEXT("0.0") };// 为色散强度变量设置推荐值
931 ChromaticIntensity.bRestrictToRecommended = false;// 设置是否限制变量值只能为推荐值
932
933 FActorVariation ChromaticOffset;// 色散偏移变量
934 ChromaticOffset.Id = TEXT("chromatic_aberration_offset"); // 设置色散偏移变量的标识符为"chromatic_aberration_offset"
935 ChromaticOffset.Type = EActorAttributeType::Float;// 设置色散偏移变量的类型为浮点数
936 ChromaticOffset.RecommendedValues = { TEXT("0.0") }; // 为色散偏移变量设置推荐值
937 ChromaticOffset.bRestrictToRecommended = false;// 设置是否限制变量值只能为推荐值
938
939 // 向一个名为Definition的对象的Variations属性中添加一个新的集合
940 Definition.Variations.Append({
941
942 // 曝光模式
943 ExposureMode,
944
945 // 曝光补偿
946 ExposureCompensation,
947
948 // 快门速度
949 ShutterSpeed,
950
951 // ISO感光度
952 ISO,
953
954 // 光圈大小
955 Aperture,
956
957 // 后期处理
958 PostProccess,
959
960 // Gamma值,用于调整图像的亮度
961 Gamma,
962
963 // MB强度
964 MBIntesity,
965
966 // MB最大畸变
967 MBMaxDistortion,
968
969 // 镜头光晕强度
970 LensFlareIntensity,
971
972 // 泛光强度
973 BloomIntensity,
974
975 // MB最小对象屏幕大小
976 MBMinObjectScreenSize,
977
978 // 曝光最小亮度
979 ExposureMinBright,
980
981 // 曝光最大亮度
982 ExposureMaxBright,
983
984 // 曝光加速
985 ExposureSpeedUp,
986
987 // 曝光减速
988 ExposureSpeedDown,
989
990 // 校准常数
991 CalibrationConstant,
992
993 // 焦距
994 FocalDistance,
995
996 // 最大光圈
997 MaxAperture,
998
999 // 光圈叶片数量
1000 BladeCount,
1001
1002 // 景深模糊量
1003 DepthBlurAmount,
1004
1005 // 景深模糊半径
1006 DepthBlurRadius,
1007
1008 // 胶片斜率(影响图像对比度)
1009 FilmSlope,
1010
1011 // 胶片趾部(影响图像暗部细节)
1012 FilmToe,
1013
1014 // 胶片肩部(影响图像亮部细节)
1015 FilmShoulder,
1016
1017 // 胶片黑剪(最暗部被剪切的程度)
1018 FilmBlackClip,
1019
1020 // 胶片白剪(最亮部被剪切的程度)
1021 FilmWhiteClip,
1022
1023 // 色温
1024 Temperature,
1025
1026 // 色调
1027 Tint,
1028
1029 // 色差强度
1030 ChromaticIntensity,
1031
1032 // 色差偏移
1033 ChromaticOffset
1034 });
1035
1036 // 调用CheckActorDefinition函数来检查Definition对象是否有效或符合某种标准
1037 // 并将结果赋值给Success变量
1038 Success = CheckActorDefinition(Definition);
1039}
1040
1041// 定义一个函数,该函数属于UActorBlueprintFunctionLibrary类,用于创建一个法线相机的定义
1043{
1044 // 创建一个FActorDefinition类型的对象Definition,用于存储相机定义
1045 FActorDefinition Definition;
1046
1047 // 定义一个布尔变量Success,用于标记操作是否成功
1048 bool Success;
1049
1050 // 调用重载的MakeNormalsCameraDefinition函数,传入Success和Definition的引用,以填充Definition并设置Success的值
1052
1053 // 使用check宏来验证Success是否为true,如果不是,则程序将在这里崩溃。这是一种调试时的保护措施。
1054 check(Success);
1055
1056 // 返回填充好的Definition对象
1057 return Definition;
1058}
1059
1060// 定义一个重载的函数,该函数同样属于UActorBlueprintFunctionLibrary类,用于填充法线相机的定义
1062{
1063 // 调用FillIdAndTags函数为Definition设置ID和标签,这里设置的ID为"sensor",标签包括"camera"和"normals"
1064 FillIdAndTags(Definition, TEXT("sensor"), TEXT("camera"), TEXT("normals"));
1065
1066 // 调用AddRecommendedValuesForSensorRoleNames函数为Definition添加建议的角色名称值,这些值可能用于优化相机性能或行为
1068
1069 // 调用AddVariationsForSensor函数为Definition添加传感器的变种或变体,这可能包括不同的配置或设置以适应不同的使用场景
1070 AddVariationsForSensor(Definition);
1071
1072 // 视场角设置
1073 FActorVariation FOV; // 创建一个FActorVariation类型的对象FOV,用于表示相机的视场角变化
1074 FOV.Id = TEXT("fov"); // 设置FOV对象的ID为"fov",这是其唯一标识符
1075 FOV.Type = EActorAttributeType::Float; // 设置FOV对象的类型为浮点型,表示视场角是一个浮点数
1076 FOV.RecommendedValues = { TEXT("90.0") }; // 为FOV对象设置一个推荐的视场角值
1077 FOV.bRestrictToRecommended = false; // 设置FOV对象是否限制为只能使用推荐值
1078
1079 // 分辨率设置
1080 FActorVariation ResX; // 创建一个FActorVariation类型的对象ResX,用于表示相机图像宽度的变化
1081 ResX.Id = TEXT("image_size_x"); // 设置ResX对象的ID为"image_size_x",表示图像宽度
1082 ResX.Type = EActorAttributeType::Int; // 设置ResX对象的类型为整型,表示图像宽度是一个整数
1083 ResX.RecommendedValues = { TEXT("800") }; // 为ResX对象设置一个推荐的图像宽度值
1084 ResX.bRestrictToRecommended = false; // 设置ResX对象是否限制为只能使用推荐值
1085
1086 FActorVariation ResY; // 创建一个FActorVariation类型的对象ResY,用于表示相机图像高度的变化
1087 ResY.Id = TEXT("image_size_y"); // 设置ResY对象的ID为"image_size_y",表示图像高度
1088 ResY.Type = EActorAttributeType::Int; // 设置ResY对象的类型为整型,表示图像高度是一个整数
1089 ResY.RecommendedValues = { TEXT("600") }; // 为ResY对象设置一个推荐的图像高度值
1090 ResY.bRestrictToRecommended = false; // 设置ResY对象是否限制为只能使用推荐值
1091
1092 // 镜头参数
1093 FActorVariation LensCircleFalloff; // 镜头圆形衰减参数
1094 LensCircleFalloff.Id = TEXT("lens_circle_falloff"); // 设置参数ID为"lens_circle_falloff"
1095 LensCircleFalloff.Type = EActorAttributeType::Float; // 设置参数类型为浮点型
1096 LensCircleFalloff.RecommendedValues = { TEXT("5.0") }; // 设置推荐值为"5.0"
1097 LensCircleFalloff.bRestrictToRecommended = false; // 设置不限制用户只能使用推荐值
1098
1099 FActorVariation LensCircleMultiplier; // 镜头圆形倍增参数
1100 LensCircleMultiplier.Id = TEXT("lens_circle_multiplier"); // 设置参数ID为"lens_circle_multiplier"
1101 LensCircleMultiplier.Type = EActorAttributeType::Float; // 设置参数类型为浮点型
1102 LensCircleMultiplier.RecommendedValues = { TEXT("0.0") }; // 设置推荐值为"0.0"
1103 LensCircleMultiplier.bRestrictToRecommended = false; // 设置不限制用户只能使用推荐值
1104
1105 FActorVariation LensK; // 镜头K参数
1106 LensK.Id = TEXT("lens_k"); // 设置参数ID为"lens_k"
1107 LensK.Type = EActorAttributeType::Float; // 设置参数类型为浮点型
1108 LensK.RecommendedValues = { TEXT("-1.0") }; // 设置推荐值为"-1.0"
1109 LensK.bRestrictToRecommended = false; // 设置不限制用户只能使用推荐值
1110
1111 FActorVariation LensKcube; // 镜头K的三次方参数
1112 LensKcube.Id = TEXT("lens_kcube"); // 设置参数ID为"lens_kcube"
1113 LensKcube.Type = EActorAttributeType::Float; // 设置参数类型为浮点型
1114 LensKcube.RecommendedValues = { TEXT("0.0") }; // 设置推荐值为"0.0"
1115 LensKcube.bRestrictToRecommended = false; // 设置不限制用户只能使用推荐值
1116
1117 FActorVariation LensXSize; // 镜头X轴大小参数
1118 LensXSize.Id = TEXT("lens_x_size"); // 设置参数ID为"lens_x_size"
1119 LensXSize.Type = EActorAttributeType::Float; // 设置参数类型为浮点型
1120 LensXSize.RecommendedValues = { TEXT("0.08") }; // 设置推荐值
1121 LensXSize.bRestrictToRecommended = false; // 不限制为只能使用推荐值
1122
1123 FActorVariation LensYSize; // 镜头Y轴大小参数
1124 LensYSize.Id = TEXT("lens_y_size"); // 设置参数ID为"lens_y_size"
1125 LensYSize.Type = EActorAttributeType::Float; // 设置参数类型为浮点型
1126 LensYSize.RecommendedValues = { TEXT("0.08") }; // 设置推荐值
1127 LensYSize.bRestrictToRecommended = false; // 不限制为只能使用推荐值
1128
1129 // 将一个包含多个参数的集合追加到Definitions的Variations列表中
1130 Definition.Variations.Append({
1131 ResX, // 分辨率X轴
1132 ResY, // 分辨率Y轴
1133 FOV, // 视场角
1134 LensCircleFalloff, // 镜头圆形衰减
1135 LensCircleMultiplier, // 镜头圆形倍乘器
1136 LensK, // 镜头K系数
1137 LensKcube, // 镜头K立方系数
1138 LensXSize, // 镜头X尺寸
1139 LensYSize });// 镜头Y尺寸
1140
1141 // 调用CheckActorDefinition函数检查Definition是否有效,并将结果存储在Success变量中
1142 Success = CheckActorDefinition(Definition);
1143}
1144
1145// UActorBlueprintFunctionLibrary类的成员函数MakeIMUDefinition,用于创建一个IMU(惯性测量单元)的定义
1147{
1148 FActorDefinition Definition; // 创建一个FActorDefinition类型的对象Definition
1149
1150 bool Success; // 声明一个布尔类型的变量Success,用于存储操作的结果
1151
1152 // 调用MakeIMUDefinition函数,该函数填充Definition并设置Success
1153 MakeIMUDefinition(Success, Definition);
1154
1155 // 使用check宏断言Success为真,如果为假则触发断言错误
1156 check(Success);
1157
1158 // 返回填充好的Definition对象
1159 return Definition;
1160}
1161
1162// 定义UActorBlueprintFunctionLibrary类的成员函数MakeIMUDefinition,用于创建一个IMU(惯性测量单元)的定义,包含成功标志和定义结构体
1164 bool &Success, // 成功标志的引用,用于指示函数执行是否成功
1165 FActorDefinition &Definition) // 定义结构体的引用,用于存储IMU的定义信息
1166{
1167 // 为定义填充ID和标签,分别为"sensor"、"other"和"imu"
1168 FillIdAndTags(Definition, TEXT("sensor"), TEXT("other"), TEXT("imu"));
1169
1170 // 为传感器添加变体信息
1171 AddVariationsForSensor(Definition);
1172
1173 // ------------------------ 噪声种子 --------------------------------
1174 // 创建一个噪声种子的变体信息
1175 FActorVariation NoiseSeed;
1176 NoiseSeed.Id = TEXT("noise_seed"); // 设置ID为"noise_seed"
1177 NoiseSeed.Type = EActorAttributeType::Int; // 设置类型为整型
1178 NoiseSeed.RecommendedValues = { TEXT("0") }; // 设置推荐值为0
1179 NoiseSeed.bRestrictToRecommended = false; // 设置不限制为推荐值
1180
1181 // -------------------------------- 加速度计标准差 --------------------------
1182 // X 分量
1183 FActorVariation StdDevAccelX;
1184 StdDevAccelX.Id = TEXT("noise_accel_stddev_x"); // 设置ID为"noise_accel_stddev_x"
1185 StdDevAccelX.Type = EActorAttributeType::Float; // 设置类型为浮点型
1186 StdDevAccelX.RecommendedValues = { TEXT("0.0") }; // 设置推荐值为0.0
1187 StdDevAccelX.bRestrictToRecommended = false; // 设置不限制为推荐值
1188
1189 // Y 分量
1190 FActorVariation StdDevAccelY;
1191 StdDevAccelY.Id = TEXT("noise_accel_stddev_y"); // 设置ID为"noise_accel_stddev_y"
1192 StdDevAccelY.Type = EActorAttributeType::Float; // 设置类型为浮点型
1193 StdDevAccelY.RecommendedValues = { TEXT("0.0") }; // 设置推荐值为0.0
1194 StdDevAccelY.bRestrictToRecommended = false; // 设置不限制为推荐值
1195
1196 // Z 分量
1197 FActorVariation StdDevAccelZ;
1198 StdDevAccelZ.Id = TEXT("noise_accel_stddev_z"); // 设置ID为"noise_accel_stddev_z"
1199 StdDevAccelZ.Type = EActorAttributeType::Float; // 设置类型为浮点型
1200 StdDevAccelZ.RecommendedValues = { TEXT("0.0") }; // 设置推荐值为0.0
1201 StdDevAccelZ.bRestrictToRecommended = false; // 设置不限制为推荐值
1202
1203
1204 // - 陀螺仪标准差 --------------
1205 // X 分量
1206 FActorVariation StdDevGyroX; // 定义一个变量,用于存储陀螺仪X轴方向的标准差
1207 StdDevGyroX.Id = TEXT("noise_gyro_stddev_x"); // 设置该变量的标识符为"noise_gyro_stddev_x"
1208 StdDevGyroX.Type = EActorAttributeType::Float; // 设置该变量的类型为浮点数
1209 StdDevGyroX.RecommendedValues = { TEXT("0.0") }; // 设置该变量的推荐值为0.0
1210 StdDevGyroX.bRestrictToRecommended = false; // 设置该变量不受推荐值的限制
1211
1212 // Y 分量
1213 FActorVariation StdDevGyroY; // 定义一个变量,用于存储陀螺仪Y轴方向的标准差
1214 StdDevGyroY.Id = TEXT("noise_gyro_stddev_y"); // 设置该变量的标识符为"noise_gyro_stddev_y"
1215 StdDevGyroY.Type = EActorAttributeType::Float; // 设置该变量的类型为浮点数
1216 StdDevGyroY.RecommendedValues = { TEXT("0.0") }; // 设置该变量的推荐值为0.0
1217 StdDevGyroY.bRestrictToRecommended = false; // 设置该变量不受推荐值的限制
1218
1219 // Z 分量
1220 FActorVariation StdDevGyroZ; // 定义一个变量,用于存储陀螺仪Z轴方向的标准差
1221 StdDevGyroZ.Id = TEXT("noise_gyro_stddev_z"); // 设置该变量的标识符为"noise_gyro_stddev_z"
1222 StdDevGyroZ.Type = EActorAttributeType::Float; // 设置该变量的类型为浮点数
1223 StdDevGyroZ.RecommendedValues = { TEXT("0.0") }; // 设置该变量的推荐值为0.0
1224 StdDevGyroZ.bRestrictToRecommended = false; // 设置该变量不受推荐值的限制
1225
1226 // - 陀螺仪偏差 ----------------------------
1227 // X 分量
1228 FActorVariation BiasGyroX; // 定义一个用于表示陀螺仪X轴偏差的变量
1229 BiasGyroX.Id = TEXT("noise_gyro_bias_x"); // 设置该变量的标识符为"noise_gyro_bias_x"
1230 BiasGyroX.Type = EActorAttributeType::Float; // 设置该变量的类型为浮点型
1231 BiasGyroX.RecommendedValues = { TEXT("0.0") }; // 设置该变量的推荐值为0.0
1232 BiasGyroX.bRestrictToRecommended = false; // 设置该变量不强制限制为推荐值
1233
1234 // Y 分量
1235 FActorVariation BiasGyroY; // 定义一个用于表示陀螺仪Y轴偏差的变量
1236 BiasGyroY.Id = TEXT("noise_gyro_bias_y"); // 设置该变量的标识符为"noise_gyro_bias_y"
1237 BiasGyroY.Type = EActorAttributeType::Float; // 设置该变量的类型为浮点型
1238 BiasGyroY.RecommendedValues = { TEXT("0.0") }; // 设置该变量的推荐值为0.0
1239 BiasGyroY.bRestrictToRecommended = false; // 设置该变量不强制限制为推荐值
1240
1241 // Z 分量
1242 FActorVariation BiasGyroZ; // 定义一个用于表示陀螺仪Z轴偏差的变量
1243 BiasGyroZ.Id = TEXT("noise_gyro_bias_z"); // 设置该变量的标识符为"noise_gyro_bias_z"
1244 BiasGyroZ.Type = EActorAttributeType::Float; // 设置该变量的类型为浮点型
1245 BiasGyroZ.RecommendedValues = { TEXT("0.0") }; // 设置该变量的推荐值为0.0
1246 BiasGyroZ.bRestrictToRecommended = false; // 设置该变量不强制限制为推荐值
1247
1248 // 将一系列变量添加到Definition的Variations列表中,这些变量通常用于定义某个物体的噪声和偏差特性
1249 Definition.Variations.Append({
1250 // 噪声种子,用于生成随机数序列,以模拟噪声的随机性
1251 NoiseSeed,
1252
1253 // 加速度计X轴的标准偏差,表示X轴加速度测量值的噪声水平
1254 StdDevAccelX,
1255
1256 // 加速度计Y轴的标准偏差,表示Y轴加速度测量值的噪声水平
1257 StdDevAccelY,
1258
1259 // 加速度计Z轴的标准偏差,表示Z轴加速度测量值的噪声水平
1260 StdDevAccelZ,
1261
1262 // 陀螺仪X轴的标准偏差,表示X轴角速度测量值的噪声水平
1263 StdDevGyroX,
1264
1265 // 陀螺仪Y轴的标准偏差,表示Y轴角速度测量值的噪声水平
1266 StdDevGyroY,
1267
1268 // 陀螺仪Z轴的标准偏差,表示Z轴角速度测量值的噪声水平
1269 StdDevGyroZ,
1270
1271 // 陀螺仪X轴的偏差,表示X轴角速度测量值的固定偏移量
1272 BiasGyroX,
1273
1274 // 陀螺仪Y轴的偏差,表示Y轴角速度测量值的固定偏移量
1275 BiasGyroY,
1276
1277 // 陀螺仪Z轴的偏差,表示Z轴角速度测量值的固定偏移量
1278 BiasGyroZ
1279 });
1280
1281 // 调用CheckActorDefinition函数来检查Definition对象的有效性或配置是否正确
1282 Success = CheckActorDefinition(Definition);
1283
1284
1285 // 在UActorBlueprintFunctionLibrary类中定义一个成员函数MakeRadarDefinition,该函数用于创建一个雷达的定义,并返回这个定义
1287 {
1288 // 定义一个FActorDefinition类型的变量Definition,用于存储雷达的定义
1289 FActorDefinition Definition;
1290
1291 // 定义一个布尔类型的变量Success,用于表示MakeRadarDefinition函数的执行结果是否成功
1292 bool Success;
1293
1294 // 调用重载的MakeRadarDefinition函数,传入Success和Definition作为参数,用于填充雷达的定义并设置Success的值
1295 MakeRadarDefinition(Success, Definition);
1296
1297 // 使用check宏来确保MakeRadarDefinition函数执行成功,如果不成功则会在此处触发断言失败
1298 check(Success);
1299
1300 // 返回填充好的雷达定义
1301 return Definition;
1302 }
1303
1304 // 在UActorBlueprintFunctionLibrary类中定义一个重载的成员函数MakeRadarDefinition,该函数用于填充雷达的定义
1306
1307 // 引用传递,用于返回函数执行的结果是否成功
1308 bool& Success,
1309
1310 // 引用传递,用于接收并填充雷达的定义
1311 FActorDefinition& Definition)
1312 {
1313 // 调用FillIdAndTags函数,为Definition设置ID和标签,
1314 FillIdAndTags(Definition, TEXT("sensor"), TEXT("other"), TEXT("radar"));
1315
1316 // 调用AddVariationsForSensor函数,为Definition添加传感器的变化特性
1317 AddVariationsForSensor(Definition);
1318
1319 // 定义一个FActorVariation类型的变量HorizontalFOV,用于表示雷达的水平视场角(Field of View)的变化特性
1320 FActorVariation HorizontalFOV;
1321
1322 // 设置HorizontalFOV的ID为"horizontal_fov"
1323 HorizontalFOV.Id = TEXT("horizontal_fov");
1324
1325 // 设置HorizontalFOV的类型为浮点型
1326 HorizontalFOV.Type = EActorAttributeType::Float;
1327
1328 // 设置HorizontalFOV的推荐值为"30"
1329 HorizontalFOV.RecommendedValues = { TEXT("30") };
1330
1331 // 设置HorizontalFOV是否限制为只能使用推荐值,这里设置为false
1332 HorizontalFOV.bRestrictToRecommended = false;
1333
1334 // 定义一个FActorVariation类型的变量VerticalFOV,用于表示垂直视场角(Field of View)的可变属性
1335 FActorVariation VerticalFOV;
1336
1337 // 设置VerticalFOV的标识符(ID)为"vertical_fov"
1338 VerticalFOV.Id = TEXT("vertical_fov");
1339
1340 // 设置VerticalFOV的类型为浮点数(Float)
1341 VerticalFOV.Type = EActorAttributeType::Float;
1342
1343 // 设置VerticalFOV的推荐值为"30"
1344 VerticalFOV.RecommendedValues = { TEXT("30") };
1345
1346 // 设置VerticalFOV是否限制为仅使用推荐值,这里设置为false,表示不限制
1347 VerticalFOV.bRestrictToRecommended = false;
1348
1349 // 定义一个FActorVariation类型的变量Range,用于表示范围的可变属性
1350 FActorVariation Range;
1351
1352 // 设置Range的标识符(ID)为"range"
1353 Range.Id = TEXT("range");
1354
1355 // 设置Range的类型为浮点数(Float)
1357
1358 // 设置Range的推荐值为"100"
1359 Range.RecommendedValues = { TEXT("100") };
1360
1361 // 设置Range是否限制为仅使用推荐值,这里设置为false,表示不限制
1362 Range.bRestrictToRecommended = false;
1363
1364 // 定义一个FActorVariation类型的变量PointsPerSecond,用于表示每秒点数的可变属性
1365 FActorVariation PointsPerSecond;
1366
1367 // 设置PointsPerSecond的标识符(ID)为"points_per_second"
1368 PointsPerSecond.Id = TEXT("points_per_second");
1369
1370 // 设置PointsPerSecond的类型为整数(Int)
1371 PointsPerSecond.Type = EActorAttributeType::Int;
1372
1373 // 设置PointsPerSecond的推荐值为"1500"
1374 PointsPerSecond.RecommendedValues = { TEXT("1500") };
1375
1376 // 设置PointsPerSecond是否限制为仅使用推荐值,这里设置为false,表示不限制
1377 PointsPerSecond.bRestrictToRecommended = false;
1378
1379 // 噪声种子设置
1380 // 定义一个变量NoiseSeed,类型为FActorVariation,用于存储噪声种子的配置
1381 FActorVariation NoiseSeed;
1382
1383 // 设置NoiseSeed的标识符为"noise_seed"
1384 NoiseSeed.Id = TEXT("noise_seed");
1385
1386 // 设置NoiseSeed的类型为整型(Int)
1387 NoiseSeed.Type = EActorAttributeType::Int;
1388
1389 // 设置NoiseSeed的推荐值为"0"的字符串数组
1390 NoiseSeed.RecommendedValues = { TEXT("0") };
1391
1392
1393 NoiseSeed.bRestrictToRecommended = false;
1394
1395 // 将HorizontalFOV, VerticalFOV, Range, PointsPerSecond, NoiseSeed添加到Definition的Variations列表中
1396 Definition.Variations.Append({
1397 HorizontalFOV, //水平视场角
1398 VerticalFOV, //垂直视场角
1399 Range, //范围
1400 PointsPerSecond, //每秒点数
1401 NoiseSeed }); //噪声种子
1402
1403 // 调用CheckActorDefinition函数检查Definition的有效性,并将结果存储在Success变量中
1404 Success = CheckActorDefinition(Definition);
1405 }
1406
1407// UActorBlueprintFunctionLibrary类的成员函数,用于创建一个激光雷达(Lidar)的定义
1409 // 接收一个字符串类型的Id作为参数
1410 const FString& Id)
1411 {
1412 // 定义一个FActorDefinition类型的变量Definition,用于存储激光雷达的定义
1413 FActorDefinition Definition;
1414
1415 // 定义一个布尔类型的变量Success,用于存储操作是否成功的标志
1416 bool Success;
1417
1418 // 调用MakeLidarDefinition的另一个重载版本,传入Id、Success和Definition,实际进行定义创建
1419 MakeLidarDefinition(Id, Success, Definition);
1420
1421 // 使用check宏确保操作成功,如果不成功则抛出异常
1422 check(Success);
1423
1424 // 返回创建好的激光雷达定义
1425 return Definition;
1426 }
1427
1428// 定义一个函数,用于创建激光雷达的定义
1430 // 激光雷达的唯一标识符
1431 const FString& Id,
1432
1433 // 函数执行成功与否的标志
1434 bool& Success,
1435
1436 // 激光雷达的定义结构体
1437 FActorDefinition& Definition)
1438{
1439 // 为定义填充标识符和标签,这里将激光雷达的角色标签设置为"sensor"和"lidar",并赋予其一个唯一Id
1440 FillIdAndTags(Definition, TEXT("sensor"), TEXT("lidar"), Id);
1441
1442 // 为传感器角色名称添加推荐值
1444
1445 // 为传感器添加变种
1446 AddVariationsForSensor(Definition);
1447
1448 // 定义激光雷达的通道数量
1449 FActorVariation Channels; // 创建一个用于存储通道数量变种的结构体
1450 Channels.Id = TEXT("channels"); // 变种的标识符
1451 Channels.Type = EActorAttributeType::Int; // 变种的数据类型,这里是整型
1452 Channels.RecommendedValues = { TEXT("32") }; // 推荐值,这里是32个通道
1453
1454 // 定义激光雷达的探测范围
1455 FActorVariation Range; // 创建一个用于存储探测范围变种的结构体
1456 Range.Id = TEXT("range"); // 变种的标识符
1457 Range.Type = EActorAttributeType::Float; // 变种的数据类型,这里是浮点型
1458 Range.RecommendedValues = { TEXT("10.0") }; // 推荐值,这里是10米
1459
1460 // 定义激光雷达每秒的点数(可能是指每秒采集的数据点数)
1461 FActorVariation PointsPerSecond; // 创建一个用于存储每秒点数变种的结构体
1462 PointsPerSecond.Id = TEXT("points_per_second"); // 变种的标识符
1463 PointsPerSecond.Type = EActorAttributeType::Int; // 变种的数据类型,这里是整型
1464 PointsPerSecond.RecommendedValues = { TEXT("56000") }; // 推荐值,这里是每秒56000个点
1465
1466 // 频率设置
1467 FActorVariation Frequency; // 定义一个用于存储频率变种的结构体变量
1468 Frequency.Id = TEXT("rotation_frequency"); // 设置变种的标识符为"rotation_frequency",表示旋转频率
1469 Frequency.Type = EActorAttributeType::Float; // 设置变种的数据类型为浮点型
1470 Frequency.RecommendedValues = { TEXT("10.0") }; // 设置推荐的频率值为10.0
1471
1472 // 上方视场角(FOV)限制
1473 FActorVariation UpperFOV; // 定义一个用于存储上方视场角变种的结构体变量
1474 UpperFOV.Id = TEXT("upper_fov"); // 设置变种的标识符为"upper_fov",表示上方的视场角
1475 UpperFOV.Type = EActorAttributeType::Float; // 设置变种的数据类型为浮点型
1476 UpperFOV.RecommendedValues = { TEXT("10.0") }; // 设置推荐的上方视场角值为10.0度
1477
1478 // 下方视场角(FOV)限制
1479 FActorVariation LowerFOV; // 定义一个用于存储下方视场角变种的结构体变量
1480 LowerFOV.Id = TEXT("lower_fov"); // 设置变种的标识符为"lower_fov",表示下方的视场角
1481 LowerFOV.Type = EActorAttributeType::Float; // 设置变种的数据类型为浮点型
1482 LowerFOV.RecommendedValues = { TEXT("-30.0") }; // 设置推荐的下方视场角值为-30.0度
1483
1484 // 水平视场角(FOV)
1485 FActorVariation HorizontalFOV; // 定义一个用于存储水平视场角变种的结构体变量
1486 HorizontalFOV.Id = TEXT("horizontal_fov"); // 设置变种的标识符为"horizontal_fov",表示水平方向的视场角
1487 HorizontalFOV.Type = EActorAttributeType::Float; // 设置变种的数据类型为浮点型
1488 HorizontalFOV.RecommendedValues = { TEXT("360.0") }; // 设置推荐的水平视场角值为360.0度,表示全向视野
1489
1490 // 大气衰减率
1491 FActorVariation AtmospAttenRate; // 定义一个大气衰减率的变化因子
1492 AtmospAttenRate.Id = TEXT("atmosphere_attenuation_rate"); // 设置该因子的ID为"atmosphere_attenuation_rate"
1493 AtmospAttenRate.Type = EActorAttributeType::Float; // 设置该因子的类型为浮点数
1494 AtmospAttenRate.RecommendedValues = { TEXT("0.004") }; // 设置该因子的推荐值为0.004
1495
1496 // 噪声种子
1497 FActorVariation NoiseSeed; // 定义一个噪声种子的变化因子
1498 NoiseSeed.Id = TEXT("noise_seed"); // 设置该因子的ID为"noise_seed"
1499 NoiseSeed.Type = EActorAttributeType::Int; // 设置该因子的类型为整数
1500 NoiseSeed.RecommendedValues = { TEXT("0") }; // 设置该因子的推荐值为0
1501 NoiseSeed.bRestrictToRecommended = false; // 设置该因子不受推荐值的限制
1502
1503 // 衰减通用率
1504 FActorVariation DropOffGenRate; // 定义一个衰减通用率的变化因子
1505 DropOffGenRate.Id = TEXT("dropoff_general_rate"); // 设置该因子的ID为"dropoff_general_rate"
1506 DropOffGenRate.Type = EActorAttributeType::Float; // 设置该因子的类型为浮点数
1507 DropOffGenRate.RecommendedValues = { TEXT("0.45") }; // 设置该因子的推荐值为0.45
1508
1509 // 衰减强度限制
1510 FActorVariation DropOffIntensityLimit; // 定义一个衰减强度限制的变化因子
1511 DropOffIntensityLimit.Id = TEXT("dropoff_intensity_limit"); // 设置该因子的ID为"dropoff_intensity_limit"
1512 DropOffIntensityLimit.Type = EActorAttributeType::Float; // 设置该因子的类型为浮点数
1513 DropOffIntensityLimit.RecommendedValues = { TEXT("0.8") }; // 设置该因子的推荐值为0.8
1514
1515 // 零强度时的衰减
1516 FActorVariation DropOffAtZeroIntensity; // 定义一个零强度时衰减的变化因子
1517 DropOffAtZeroIntensity.Id = TEXT("dropoff_zero_intensity"); // 设置该因子的ID为"dropoff_zero_intensity"
1518 DropOffAtZeroIntensity.Type = EActorAttributeType::Float; // 设置该因子的类型为浮点数
1519 DropOffAtZeroIntensity.RecommendedValues = { TEXT("0.4") }; // 设置该因子的推荐值为0.4
1520
1521 // 激光雷达云点中的噪声
1522 FActorVariation StdDevLidar; // 定义一个激光雷达云点噪声标准差的变化因子
1523 StdDevLidar.Id = TEXT("noise_stddev"); // 设置该因子的ID为"noise_stddev"
1524 StdDevLidar.Type = EActorAttributeType::Float; // 设置该因子的类型为浮点数
1525 StdDevLidar.RecommendedValues = { TEXT("0.0") }; // 设置该因子的推荐值为0.0
1526
1527 if (Id == "ray_cast") {
1528 Definition.Variations.Append({
1529 Channels,
1530 Range,
1531 PointsPerSecond,
1532 Frequency,
1533 UpperFOV,
1534 LowerFOV,
1535 AtmospAttenRate,
1536 NoiseSeed,
1537 DropOffGenRate,
1538 DropOffIntensityLimit,
1539 DropOffAtZeroIntensity,
1540 StdDevLidar,
1541 HorizontalFOV});
1542 }
1543 else if (Id == "ray_cast_semantic") {
1544 Definition.Variations.Append({
1545 Channels,
1546 Range,
1547 PointsPerSecond,
1548 Frequency,
1549 UpperFOV,
1550 LowerFOV,
1551 HorizontalFOV});
1552 }
1553 else {
1554 DEBUG_ASSERT(false);
1555 }
1556
1557 Success = CheckActorDefinition(Definition);
1558}
1559
1561{
1562 FActorDefinition Definition;
1563 bool Success;
1564 MakeV2XDefinition(Success, Definition);
1565 check(Success);
1566 return Definition;
1567}
1568
1570 bool &Success,
1571 FActorDefinition &Definition)
1572{
1573 FillIdAndTags(Definition, TEXT("sensor"), TEXT("other"), TEXT("v2x"));
1574 AddVariationsForSensor(Definition);
1575
1576 // - Noise seed --------------------------------
1577 FActorVariation NoiseSeed;
1578 NoiseSeed.Id = TEXT("noise_seed");
1579 NoiseSeed.Type = EActorAttributeType::Int;
1580 NoiseSeed.RecommendedValues = { TEXT("0") };
1581 NoiseSeed.bRestrictToRecommended = false;
1582
1583 //Frequency
1584 FActorVariation Frequency;
1585 Frequency.Id = TEXT("frequency_ghz");
1586 Frequency.Type = EActorAttributeType::Float;
1587 Frequency.RecommendedValues = { TEXT("5.9")};
1588
1589 //TransmitPower
1590 FActorVariation TransmitPower;
1591 TransmitPower.Id = TEXT("transmit_power");
1592 TransmitPower.Type = EActorAttributeType::Float;
1593 TransmitPower.RecommendedValues = { TEXT("21.5")};
1594
1595 //ReceiveSensitivity
1596 FActorVariation ReceiverSensitivity;
1597 ReceiverSensitivity.Id = TEXT("receiver_sensitivity");
1598 ReceiverSensitivity.Type = EActorAttributeType::Float;
1599 ReceiverSensitivity.RecommendedValues = { TEXT("-99.0")};
1600
1601 //Combined Antenna Gain in dBi
1602 FActorVariation CombinedAntennaGain;
1603 CombinedAntennaGain.Id = TEXT("combined_antenna_gain");
1604 CombinedAntennaGain.Type = EActorAttributeType::Float;
1605 CombinedAntennaGain.RecommendedValues = { TEXT("10.0")};
1606
1607 //Scenario
1608 FActorVariation Scenario;
1609 Scenario.Id = TEXT("scenario");
1611 Scenario.RecommendedValues = { TEXT("highway"), TEXT("rural"), TEXT("urban")};
1612 Scenario.bRestrictToRecommended = true;
1613
1614 //Path loss exponent
1615 FActorVariation PLE;
1616 PLE.Id = TEXT("path_loss_exponent");
1618 PLE.RecommendedValues = { TEXT("2.7")};
1619
1620
1621 //FSPL reference distance for LDPL calculation
1622 FActorVariation FSPL_RefDistance;
1623 FSPL_RefDistance.Id = TEXT("d_ref");
1624 FSPL_RefDistance.Type = EActorAttributeType::Float;
1625 FSPL_RefDistance.RecommendedValues = { TEXT("1.0")};
1626
1627 //filter distance to speed up calculation
1628 FActorVariation FilterDistance;
1629 FilterDistance.Id = TEXT("filter_distance");
1630 FilterDistance.Type = EActorAttributeType::Float;
1631 FilterDistance.RecommendedValues = { TEXT("500.0")};
1632
1633 //etsi fading
1634 FActorVariation EtsiFading;
1635 EtsiFading.Id = TEXT("use_etsi_fading");
1636 EtsiFading.Type = EActorAttributeType::Bool;
1637 EtsiFading.RecommendedValues = { TEXT("true")};
1638
1639 //custom fading std deviation
1640 FActorVariation CustomFadingStddev;
1641 CustomFadingStddev.Id = TEXT("custom_fading_stddev");
1642 CustomFadingStddev.Type = EActorAttributeType::Float;
1643 CustomFadingStddev.RecommendedValues = { TEXT("0.0")};
1644
1645 // Min Cam Generation
1646 FActorVariation GenCamMin;
1647 GenCamMin.Id = TEXT("gen_cam_min");
1648 GenCamMin.Type = EActorAttributeType::Float;
1649 GenCamMin.RecommendedValues = { TEXT("0.1")};
1650
1651 // Max Cam Generation
1652 FActorVariation GenCamMax;
1653 GenCamMax.Id = TEXT("gen_cam_max");
1654 GenCamMax.Type = EActorAttributeType::Float;
1655 GenCamMax.RecommendedValues = { TEXT("1.0")};
1656
1657 //Fixed Rate
1658 FActorVariation FixedRate;
1659 FixedRate.Id = TEXT("fixed_rate");
1660 FixedRate.Type = EActorAttributeType::Bool;
1661 FixedRate.RecommendedValues = { TEXT("false")};
1662
1663 //path loss model
1664 FActorVariation PLModel;
1665 PLModel.Id = TEXT("path_loss_model");
1667 PLModel.RecommendedValues = { TEXT("winner"), TEXT("geometric")};
1668 PLModel.bRestrictToRecommended = true;
1669
1670 //V2x Sensor sends GNSS position in CAM messages
1671 // - Latitude ----------------------------------
1672 FActorVariation StdDevLat;
1673 StdDevLat.Id = TEXT("noise_lat_stddev");
1674 StdDevLat.Type = EActorAttributeType::Float;
1675 StdDevLat.RecommendedValues = { TEXT("0.0") };
1676 StdDevLat.bRestrictToRecommended = false;
1677 FActorVariation BiasLat;
1678 BiasLat.Id = TEXT("noise_lat_bias");
1680 BiasLat.RecommendedValues = { TEXT("0.0") };
1681 BiasLat.bRestrictToRecommended = false;
1682
1683 // - Longitude ---------------------------------
1684 FActorVariation StdDevLong;
1685 StdDevLong.Id = TEXT("noise_lon_stddev");
1686 StdDevLong.Type = EActorAttributeType::Float;
1687 StdDevLong.RecommendedValues = { TEXT("0.0") };
1688 StdDevLong.bRestrictToRecommended = false;
1689 FActorVariation BiasLong;
1690 BiasLong.Id = TEXT("noise_lon_bias");
1692 BiasLong.RecommendedValues = { TEXT("0.0") };
1693 BiasLong.bRestrictToRecommended = false;
1694
1695 // - Altitude ----------------------------------
1696 FActorVariation StdDevAlt;
1697 StdDevAlt.Id = TEXT("noise_alt_stddev");
1698 StdDevAlt.Type = EActorAttributeType::Float;
1699 StdDevAlt.RecommendedValues = { TEXT("0.0") };
1700 StdDevAlt.bRestrictToRecommended = false;
1701 FActorVariation BiasAlt;
1702 BiasAlt.Id = TEXT("noise_alt_bias");
1704 BiasAlt.RecommendedValues = { TEXT("0.0") };
1705 BiasAlt.bRestrictToRecommended = false;
1706
1707 // - Heading ----------------------------------
1708 FActorVariation StdDevHeading;
1709 StdDevHeading.Id = TEXT("noise_head_stddev");
1710 StdDevHeading.Type = EActorAttributeType::Float;
1711 StdDevHeading.RecommendedValues = { TEXT("0.0") };
1712 StdDevHeading.bRestrictToRecommended = false;
1713 FActorVariation BiasHeading;
1714 BiasHeading.Id = TEXT("noise_head_bias");
1715 BiasHeading.Type = EActorAttributeType::Float;
1716 BiasHeading.RecommendedValues = { TEXT("0.0") };
1717 BiasHeading.bRestrictToRecommended = false;
1718
1719 //V2x Sensor sends acceleration in CAM messages
1720 // - Accelerometer Standard Deviation ----------
1721 // X Component
1722 FActorVariation StdDevAccelX;
1723 StdDevAccelX.Id = TEXT("noise_accel_stddev_x");
1724 StdDevAccelX.Type = EActorAttributeType::Float;
1725 StdDevAccelX.RecommendedValues = { TEXT("0.0") };
1726 StdDevAccelX.bRestrictToRecommended = false;
1727 // Y Component
1728 FActorVariation StdDevAccelY;
1729 StdDevAccelY.Id = TEXT("noise_accel_stddev_y");
1730 StdDevAccelY.Type = EActorAttributeType::Float;
1731 StdDevAccelY.RecommendedValues = { TEXT("0.0") };
1732 StdDevAccelY.bRestrictToRecommended = false;
1733 // Z Component
1734 FActorVariation StdDevAccelZ;
1735 StdDevAccelZ.Id = TEXT("noise_accel_stddev_z");
1736 StdDevAccelZ.Type = EActorAttributeType::Float;
1737 StdDevAccelZ.RecommendedValues = { TEXT("0.0") };
1738 StdDevAccelZ.bRestrictToRecommended = false;
1739
1740 // Yaw rate
1741 FActorVariation StdDevYawrate;
1742 StdDevYawrate.Id = TEXT("noise_yawrate_stddev");
1743 StdDevYawrate.Type = EActorAttributeType::Float;
1744 StdDevYawrate.RecommendedValues = { TEXT("0.0") };
1745 StdDevYawrate.bRestrictToRecommended = false;
1746 FActorVariation BiasYawrate;
1747 BiasYawrate.Id = TEXT("noise_yawrate_bias");
1748 BiasYawrate.Type = EActorAttributeType::Float;
1749 BiasYawrate.RecommendedValues = { TEXT("0.0") };
1750 BiasYawrate.bRestrictToRecommended = false;
1751
1752 //V2x Sensor sends speed in CAM messages
1753 // X Component
1754 FActorVariation StdDevVelX;
1755 StdDevVelX.Id = TEXT("noise_vel_stddev_x");
1756 StdDevVelX.Type = EActorAttributeType::Float;
1757 StdDevVelX.RecommendedValues = { TEXT("0.0") };
1758 StdDevVelX.bRestrictToRecommended = false;
1759
1760 Definition.Variations.Append({
1761 NoiseSeed,
1762 TransmitPower,
1763 ReceiverSensitivity,
1764 Frequency,
1765 CombinedAntennaGain,
1766 Scenario,
1767 PLModel,
1768 PLE,
1769 FSPL_RefDistance,
1770 FilterDistance,
1771 EtsiFading,
1772 CustomFadingStddev,
1773 GenCamMin,
1774 GenCamMax,
1775 FixedRate,
1776 StdDevLat,
1777 BiasLat,
1778 StdDevLong,
1779 BiasLong,
1780 StdDevAlt,
1781 BiasAlt,
1782 StdDevHeading,
1783 BiasHeading,
1784 StdDevAccelX,
1785 StdDevAccelY,
1786 StdDevAccelZ,
1787 StdDevYawrate,
1788 BiasYawrate,
1789 StdDevVelX});
1790 Success = CheckActorDefinition(Definition);
1791}
1792
1794{
1795 FActorDefinition Definition;
1796 bool Success;
1797 MakeCustomV2XDefinition(Success, Definition);
1798 check(Success);
1799 return Definition;
1800}
1801
1803 bool &Success,
1804 FActorDefinition &Definition)
1805{
1806 FillIdAndTags(Definition, TEXT("sensor"), TEXT("other"), TEXT("v2x_custom"));
1807 AddVariationsForSensor(Definition);
1808
1809 // - Noise seed --------------------------------
1810 FActorVariation NoiseSeed;
1811 NoiseSeed.Id = TEXT("noise_seed");
1812 NoiseSeed.Type = EActorAttributeType::Int;
1813 NoiseSeed.RecommendedValues = { TEXT("0") };
1814 NoiseSeed.bRestrictToRecommended = false;
1815
1816 //TransmitPower
1817 FActorVariation TransmitPower;
1818 TransmitPower.Id = TEXT("transmit_power");
1819 TransmitPower.Type = EActorAttributeType::Float;
1820 TransmitPower.RecommendedValues = { TEXT("21.5")};
1821
1822 //ReceiveSensitivity
1823 FActorVariation ReceiverSensitivity;
1824 ReceiverSensitivity.Id = TEXT("receiver_sensitivity");
1825 ReceiverSensitivity.Type = EActorAttributeType::Float;
1826 ReceiverSensitivity.RecommendedValues = { TEXT("-99.0")};
1827
1828 //Frequency
1829 FActorVariation Frequency;
1830 Frequency.Id = TEXT("frequency_ghz");
1831 Frequency.Type = EActorAttributeType::Float;
1832 Frequency.RecommendedValues = { TEXT("5.9")};
1833
1834 //Combined Antenna Gain in dBi
1835 FActorVariation CombinedAntennaGain;
1836 CombinedAntennaGain.Id = TEXT("combined_antenna_gain");
1837 CombinedAntennaGain.Type = EActorAttributeType::Float;
1838 CombinedAntennaGain.RecommendedValues = { TEXT("10.0")};
1839
1840 //Scenario
1841 FActorVariation Scenario;
1842 Scenario.Id = TEXT("scenario");
1844 Scenario.RecommendedValues = { TEXT("highway"), TEXT("rural"), TEXT("urban")};
1845 Scenario.bRestrictToRecommended = true;
1846
1847 //Path loss exponent
1848 FActorVariation PLE;
1849 PLE.Id = TEXT("path_loss_exponent");
1851 PLE.RecommendedValues = { TEXT("2.7")};
1852
1853
1854 //FSPL reference distance for LDPL calculation
1855 FActorVariation FSPL_RefDistance;
1856 FSPL_RefDistance.Id = TEXT("d_ref");
1857 FSPL_RefDistance.Type = EActorAttributeType::Float;
1858 FSPL_RefDistance.RecommendedValues = { TEXT("1.0")};
1859
1860 //filter distance to speed up calculation
1861 FActorVariation FilterDistance;
1862 FilterDistance.Id = TEXT("filter_distance");
1863 FilterDistance.Type = EActorAttributeType::Float;
1864 FilterDistance.RecommendedValues = { TEXT("500.0")};
1865
1866 //etsi fading
1867 FActorVariation EtsiFading;
1868 EtsiFading.Id = TEXT("use_etsi_fading");
1869 EtsiFading.Type = EActorAttributeType::Bool;
1870 EtsiFading.RecommendedValues = { TEXT("true")};
1871
1872 //custom fading std deviation
1873 FActorVariation CustomFadingStddev;
1874 CustomFadingStddev.Id = TEXT("custom_fading_stddev");
1875 CustomFadingStddev.Type = EActorAttributeType::Float;
1876 CustomFadingStddev.RecommendedValues = { TEXT("0.0")};
1877
1878 //path loss model
1879 FActorVariation PLModel;
1880 PLModel.Id = TEXT("path_loss_model");
1882 PLModel.RecommendedValues = { TEXT("winner"), TEXT("geometric")};
1883 PLModel.bRestrictToRecommended = true;
1884
1885
1886 Definition.Variations.Append({
1887 NoiseSeed,
1888 TransmitPower,
1889 ReceiverSensitivity,
1890 Frequency,
1891 CombinedAntennaGain,
1892 Scenario,
1893 PLModel,
1894 PLE,
1895 FSPL_RefDistance,
1896 FilterDistance,
1897 EtsiFading,
1898 CustomFadingStddev
1899});
1900
1901 Success = CheckActorDefinition(Definition);
1902}
1903
1904
1906{
1907 FActorDefinition Definition;
1908 bool Success;
1909 MakeGnssDefinition(Success, Definition);
1910 check(Success);
1911 return Definition;
1912}
1913
1915 bool &Success,
1916 FActorDefinition &Definition)
1917{
1918 FillIdAndTags(Definition, TEXT("sensor"), TEXT("other"), TEXT("gnss"));
1919 AddVariationsForSensor(Definition);
1920
1921 // - Noise seed --------------------------------
1922 FActorVariation NoiseSeed;
1923 NoiseSeed.Id = TEXT("noise_seed");
1924 NoiseSeed.Type = EActorAttributeType::Int;
1925 NoiseSeed.RecommendedValues = { TEXT("0") };
1926 NoiseSeed.bRestrictToRecommended = false;
1927
1928 // - Latitude ----------------------------------
1929 FActorVariation StdDevLat;
1930 StdDevLat.Id = TEXT("noise_lat_stddev");
1931 StdDevLat.Type = EActorAttributeType::Float;
1932 StdDevLat.RecommendedValues = { TEXT("0.0") };
1933 StdDevLat.bRestrictToRecommended = false;
1934 FActorVariation BiasLat;
1935 BiasLat.Id = TEXT("noise_lat_bias");
1937 BiasLat.RecommendedValues = { TEXT("0.0") };
1938 BiasLat.bRestrictToRecommended = false;
1939
1940 // - Longitude ---------------------------------
1941 FActorVariation StdDevLong;
1942 StdDevLong.Id = TEXT("noise_lon_stddev");
1943 StdDevLong.Type = EActorAttributeType::Float;
1944 StdDevLong.RecommendedValues = { TEXT("0.0") };
1945 StdDevLong.bRestrictToRecommended = false;
1946 FActorVariation BiasLong;
1947 BiasLong.Id = TEXT("noise_lon_bias");
1949 BiasLong.RecommendedValues = { TEXT("0.0") };
1950 BiasLong.bRestrictToRecommended = false;
1951
1952 // - Altitude ----------------------------------
1953 FActorVariation StdDevAlt;
1954 StdDevAlt.Id = TEXT("noise_alt_stddev");
1955 StdDevAlt.Type = EActorAttributeType::Float;
1956 StdDevAlt.RecommendedValues = { TEXT("0.0") };
1957 StdDevAlt.bRestrictToRecommended = false;
1958 FActorVariation BiasAlt;
1959 BiasAlt.Id = TEXT("noise_alt_bias");
1961 BiasAlt.RecommendedValues = { TEXT("0.0") };
1962 BiasAlt.bRestrictToRecommended = false;
1963
1964 Definition.Variations.Append({
1965 NoiseSeed,
1966 StdDevLat,
1967 BiasLat,
1968 StdDevLong,
1969 BiasLong,
1970 StdDevAlt,
1971 BiasAlt});
1972
1973 Success = CheckActorDefinition(Definition);
1974}
1975
1977 const FVehicleParameters &Parameters,
1978 bool &Success,
1979 FActorDefinition &Definition)
1980{
1981 /// @todo We need to validate here the params.
1982 FillIdAndTags(Definition, TEXT("vehicle"), Parameters.Make, Parameters.Model);
1984 {TEXT("autopilot"), TEXT("scenario"), TEXT("ego_vehicle")});
1985 Definition.Class = Parameters.Class;
1986
1987 if (Parameters.RecommendedColors.Num() > 0)
1988 {
1989 FActorVariation Colors;
1990 Colors.Id = TEXT("color");
1992 Colors.bRestrictToRecommended = false;
1993 for (auto &Color : Parameters.RecommendedColors)
1994 {
1995 Colors.RecommendedValues.Emplace(ColorToFString(Color));
1996 }
1997 Definition.Variations.Emplace(Colors);
1998 }
1999
2000 if (Parameters.SupportedDrivers.Num() > 0)
2001 {
2002 FActorVariation Drivers;
2003 Drivers.Id = TEXT("driver_id");
2005 Drivers.bRestrictToRecommended = true;
2006 for (auto &Id : Parameters.SupportedDrivers)
2007 {
2008 Drivers.RecommendedValues.Emplace(FString::FromInt(Id));
2009 }
2010 Definition.Variations.Emplace(Drivers);
2011 }
2012
2013 FActorVariation StickyControl;
2014 StickyControl.Id = TEXT("sticky_control");
2015 StickyControl.Type = EActorAttributeType::Bool;
2016 StickyControl.bRestrictToRecommended = false;
2017 StickyControl.RecommendedValues.Emplace(TEXT("true"));
2018 Definition.Variations.Emplace(StickyControl);
2019
2020 FActorVariation TerramechanicsAttribute;
2021 TerramechanicsAttribute.Id = TEXT("terramechanics");
2022 TerramechanicsAttribute.Type = EActorAttributeType::Bool;
2023 TerramechanicsAttribute.bRestrictToRecommended = false;
2024 TerramechanicsAttribute.RecommendedValues.Emplace(TEXT("false"));
2025 Definition.Variations.Emplace(TerramechanicsAttribute);
2026
2027 Definition.Attributes.Emplace(FActorAttribute{
2028 TEXT("object_type"),
2030 Parameters.ObjectType});
2031
2032 Definition.Attributes.Emplace(FActorAttribute{
2033 TEXT("base_type"),
2035 Parameters.BaseType});
2036 Success = CheckActorDefinition(Definition);
2037
2038 Definition.Attributes.Emplace(FActorAttribute{
2039 TEXT("special_type"),
2041 Parameters.SpecialType});
2042 Success = CheckActorDefinition(Definition);
2043
2044 Definition.Attributes.Emplace(FActorAttribute{
2045 TEXT("number_of_wheels"),
2047 FString::FromInt(Parameters.NumberOfWheels)});
2048 Success = CheckActorDefinition(Definition);
2049
2050 Definition.Attributes.Emplace(FActorAttribute{
2051 TEXT("generation"),
2053 FString::FromInt(Parameters.Generation)});
2054 Success = CheckActorDefinition(Definition);
2055
2056 Definition.Attributes.Emplace(FActorAttribute{
2057 TEXT("has_dynamic_doors"),
2059 Parameters.HasDynamicDoors ? TEXT("true") : TEXT("false")});
2060 Success = CheckActorDefinition(Definition);
2061
2062 Definition.Attributes.Emplace(FActorAttribute{
2063 TEXT("has_lights"),
2065 Parameters.HasLights ? TEXT("true") : TEXT("false")});
2066 Success = CheckActorDefinition(Definition);
2067}
2068
2069template <typename T, typename Functor>
2070static void FillActorDefinitionArray(
2071 const TArray<T> &ParameterArray,
2072 TArray<FActorDefinition> &Definitions,
2073 Functor Maker)
2074{
2075 for (auto &Item : ParameterArray)
2076 {
2077 FActorDefinition Definition;
2078 bool Success = false;
2079 Maker(Item, Success, Definition);
2080 if (Success)
2081 {
2082 Definitions.Emplace(std::move(Definition));
2083 }
2084 }
2085}
2086
2088 const TArray<FVehicleParameters> &ParameterArray,
2089 TArray<FActorDefinition> &Definitions)
2090{
2091 FillActorDefinitionArray(ParameterArray, Definitions, &MakeVehicleDefinition);
2092}
2093
2095 const FPedestrianParameters &Parameters,
2096 bool &Success,
2097 FActorDefinition &Definition)
2098{
2099 /// @todo We need to validate here the params.
2100 FillIdAndTags(Definition, TEXT("walker"), TEXT("pedestrian"), Parameters.Id);
2101 AddRecommendedValuesForActorRoleName(Definition, {TEXT("pedestrian")});
2102 Definition.Class = Parameters.Class;
2103
2104 auto GetGender = [](EPedestrianGender Value) {
2105 switch (Value)
2106 {
2107 case EPedestrianGender::Female: return TEXT("female");
2108 case EPedestrianGender::Male: return TEXT("male");
2109 default: return TEXT("other");
2110 }
2111 };
2112
2113 auto GetAge = [](EPedestrianAge Value) {
2114 switch (Value)
2115 {
2116 case EPedestrianAge::Child: return TEXT("child");
2117 case EPedestrianAge::Teenager: return TEXT("teenager");
2118 case EPedestrianAge::Elderly: return TEXT("elderly");
2119 default: return TEXT("adult");
2120 }
2121 };
2122
2123 Definition.Attributes.Emplace(FActorAttribute{
2124 TEXT("gender"),
2126 GetGender(Parameters.Gender)});
2127
2128 Definition.Attributes.Emplace(FActorAttribute{
2129 TEXT("generation"),
2131 FString::FromInt(Parameters.Generation)});
2132
2133 Definition.Attributes.Emplace(FActorAttribute{
2134 TEXT("age"),
2136 GetAge(Parameters.Age)});
2137
2138
2139 Definition.Attributes.Emplace(FActorAttribute{
2140 TEXT("can_use_wheelchair"),
2142 Parameters.bCanUseWheelChair ? TEXT("true") : TEXT("false") });
2143
2144 if (Parameters.Speed.Num() > 0)
2145 {
2146 FActorVariation Speed;
2147 Speed.Id = TEXT("speed");
2148 Speed.Type = EActorAttributeType::Float;
2149 for (auto &Value : Parameters.Speed)
2150 {
2151 Speed.RecommendedValues.Emplace(FString::SanitizeFloat(Value));
2152 }
2153 Speed.bRestrictToRecommended = false;
2154 Definition.Variations.Emplace(Speed);
2155 }
2156
2157 bool bCanUseWheelChair = Parameters.bCanUseWheelChair;
2158
2159 FActorVariation IsInvincible;
2160 IsInvincible.Id = TEXT("is_invincible");
2161 IsInvincible.Type = EActorAttributeType::Bool;
2162 IsInvincible.RecommendedValues = { TEXT("true") };
2163 IsInvincible.bRestrictToRecommended = false;
2164 Definition.Variations.Emplace(IsInvincible);
2165
2166 FActorVariation WheelChairVariation;
2167 WheelChairVariation.Id = TEXT("use_wheelchair");
2168 WheelChairVariation.Type = EActorAttributeType::Bool;
2169 if(bCanUseWheelChair)
2170 {
2171 WheelChairVariation.RecommendedValues = { TEXT("false"), TEXT("true") };
2172 }
2173 else
2174 {
2175 WheelChairVariation.RecommendedValues = { TEXT("false") };
2176 }
2177 WheelChairVariation.bRestrictToRecommended = true;
2178 Definition.Variations.Emplace(WheelChairVariation);
2179
2180 Success = CheckActorDefinition(Definition);
2181}
2182
2184 const TArray<FPedestrianParameters> &ParameterArray,
2185 TArray<FActorDefinition> &Definitions)
2186{
2187 FillActorDefinitionArray(ParameterArray, Definitions, &MakePedestrianDefinition);
2188}
2189
2191 const TArray<FString> &ParameterArray,
2192 TArray<FActorDefinition> &Definitions)
2193{
2194 FillActorDefinitionArray(ParameterArray, Definitions, &MakeTriggerDefinition);
2195}
2196
2198 const FString &Id,
2199 bool &Success,
2200 FActorDefinition &Definition)
2201{
2202 FillIdAndTags(Definition, TEXT("static"), TEXT("trigger"), Id);
2203 AddVariationsForTrigger(Definition);
2204 Success = CheckActorDefinition(Definition);
2205 check(Success);
2206}
2207
2209 const FPropParameters &Parameters,
2210 bool &Success,
2211 FActorDefinition &Definition)
2212{
2213 /// @todo We need to validate here the params.
2214 FillIdAndTags(Definition, TEXT("static"), TEXT("prop"), Parameters.Name);
2215 AddRecommendedValuesForActorRoleName(Definition, {TEXT("prop")});
2216
2217 auto GetSize = [](EPropSize Value) {
2218 switch (Value)
2219 {
2220 case EPropSize::Tiny: return TEXT("tiny");
2221 case EPropSize::Small: return TEXT("small");
2222 case EPropSize::Medium: return TEXT("medium");
2223 case EPropSize::Big: return TEXT("big");
2224 case EPropSize::Huge: return TEXT("huge");
2225 default: return TEXT("unknown");
2226 }
2227 };
2228
2229 Definition.Attributes.Emplace(FActorAttribute{
2230 TEXT("size"),
2232 GetSize(Parameters.Size)});
2233
2234 Success = CheckActorDefinition(Definition);
2235}
2236
2238 const TArray<FPropParameters> &ParameterArray,
2239 TArray<FActorDefinition> &Definitions)
2240{
2241 FillActorDefinitionArray(ParameterArray, Definitions, &MakePropDefinition);
2242}
2243
2245 const FString &Type,
2246 const FString &Id,
2247 FActorDefinition &Definition)
2248{
2249 Definition = MakeGenericSensorDefinition(TEXT("other"), TEXT("obstacle"));
2250 AddVariationsForSensor(Definition);
2251 // Distance.
2252 FActorVariation distance;
2253 distance.Id = TEXT("distance");
2255 distance.RecommendedValues = { TEXT("5.0") };
2256 distance.bRestrictToRecommended = false;
2257 // HitRadius.
2258 FActorVariation hitradius;
2259 hitradius.Id = TEXT("hit_radius");
2260 hitradius.Type = EActorAttributeType::Float;
2261 hitradius.RecommendedValues = { TEXT("0.5") };
2262 hitradius.bRestrictToRecommended = false;
2263 // Only Dynamics
2264 FActorVariation onlydynamics;
2265 onlydynamics.Id = TEXT("only_dynamics");
2266 onlydynamics.Type = EActorAttributeType::Bool;
2267 onlydynamics.RecommendedValues = { TEXT("false") };
2268 onlydynamics.bRestrictToRecommended = false;
2269 // Debug Line Trace
2270 FActorVariation debuglinetrace;
2271 debuglinetrace.Id = TEXT("debug_linetrace");
2272 debuglinetrace.Type = EActorAttributeType::Bool;
2273 debuglinetrace.RecommendedValues = { TEXT("false") };
2274 debuglinetrace.bRestrictToRecommended = false;
2275
2276 Definition.Variations.Append({
2277 distance,
2278 hitradius,
2279 onlydynamics,
2280 debuglinetrace
2281 });
2282
2283}
2284/// ============================================================================
2285/// -- Helpers to retrieve attribute values ------------------------------------
2286/// ============================================================================
2287
2289 const FActorAttribute &ActorAttribute,
2290 bool Default)
2291{
2292 if (ActorAttribute.Type != EActorAttributeType::Bool)
2293 {
2294 UE_LOG(LogCarla, Error, TEXT("ActorAttribute '%s' is not a bool"), *ActorAttribute.Id);
2295 return Default;
2296 }
2297 return ActorAttribute.Value.ToBool();
2298}
2299
2301 const FActorAttribute &ActorAttribute,
2302 int32 Default)
2303{
2304 if (ActorAttribute.Type != EActorAttributeType::Int)
2305 {
2306 UE_LOG(LogCarla, Error, TEXT("ActorAttribute '%s' is not an int"), *ActorAttribute.Id);
2307 return Default;
2308 }
2309 return FCString::Atoi(*ActorAttribute.Value);
2310}
2311
2313 const FActorAttribute &ActorAttribute,
2314 float Default)
2315{
2316 if (ActorAttribute.Type != EActorAttributeType::Float)
2317 {
2318 UE_LOG(LogCarla, Error, TEXT("ActorAttribute '%s' is not a float"), *ActorAttribute.Id);
2319 return Default;
2320 }
2321 return FCString::Atof(*ActorAttribute.Value);
2322}
2323
2325 const FActorAttribute &ActorAttribute,
2326 const FString &Default)
2327{
2328 if (ActorAttribute.Type != EActorAttributeType::String)
2329 {
2330 UE_LOG(LogCarla, Error, TEXT("ActorAttribute '%s' is not a string"), *ActorAttribute.Id);
2331 return Default;
2332 }
2333 return ActorAttribute.Value;
2334}
2335
2337 const FActorAttribute &ActorAttribute,
2338 const FColor &Default)
2339{
2340 if (ActorAttribute.Type != EActorAttributeType::RGBColor)
2341 {
2342 UE_LOG(LogCarla, Error, TEXT("ActorAttribute '%s' is not a color"), *ActorAttribute.Id);
2343 return Default;
2344 }
2345 TArray<FString> Channels;
2346 ActorAttribute.Value.ParseIntoArray(Channels, TEXT(","), false);
2347 if (Channels.Num() != 3)
2348 {
2349 UE_LOG(LogCarla,
2350 Error,
2351 TEXT("ActorAttribute '%s': invalid color '%s'"),
2352 *ActorAttribute.Id,
2353 *ActorAttribute.Value);
2354 return Default;
2355 }
2356 TArray<uint8> Colors;
2357 for (auto &Str : Channels)
2358 {
2359 auto Val = FCString::Atoi(*Str);
2360 if ((Val < 0) || (Val > std::numeric_limits<uint8>::max()))
2361 {
2362 UE_LOG(LogCarla,
2363 Error,
2364 TEXT("ActorAttribute '%s': invalid color '%s'"),
2365 *ActorAttribute.Id,
2366 *ActorAttribute.Value);
2367 return Default;
2368 }
2369 Colors.Add(Val);
2370 }
2371 FColor Color;
2372 Color.R = Colors[0u];
2373 Color.G = Colors[1u];
2374 Color.B = Colors[2u];
2375 return Color;
2376}
2377
2379 const FString &Id,
2380 const TMap<FString, FActorAttribute> &Attributes,
2381 bool Default)
2382{
2383 return Attributes.Contains(Id) ?
2384 ActorAttributeToBool(Attributes[Id], Default) :
2385 Default;
2386}
2387
2389 const FString &Id,
2390 const TMap<FString, FActorAttribute> &Attributes,
2391 int32 Default)
2392{
2393 return Attributes.Contains(Id) ?
2394 ActorAttributeToInt(Attributes[Id], Default) :
2395 Default;
2396}
2397
2399 const FString &Id,
2400 const TMap<FString, FActorAttribute> &Attributes,
2401 float Default)
2402{
2403 return Attributes.Contains(Id) ?
2404 ActorAttributeToFloat(Attributes[Id], Default) :
2405 Default;
2406}
2407
2409 const FString &Id,
2410 const TMap<FString, FActorAttribute> &Attributes,
2411 const FString &Default)
2412{
2413 return Attributes.Contains(Id) ?
2414 ActorAttributeToString(Attributes[Id], Default) :
2415 Default;
2416}
2417
2419 const FString &Id,
2420 const TMap<FString, FActorAttribute> &Attributes,
2421 const FColor &Default)
2422{
2423 return Attributes.Contains(Id) ?
2424 ActorAttributeToColor(Attributes[Id], Default) :
2425 Default;
2426}
2427
2428/// ============================================================================
2429/// -- Helpers to set Actors ---------------------------------------------------
2430/// ============================================================================
2431
2432// Here we do different checks when we are in editor because we don't want the
2433// editor crashing while people are testing new actor definitions.
2434#if WITH_EDITOR
2435# define CARLA_ABFL_CHECK_ACTOR(ActorPtr) \
2436 if ((ActorPtr == nullptr) || ActorPtr->IsPendingKill()) \
2437 { \
2438 UE_LOG(LogCarla, Error, TEXT("Cannot set empty actor!")); \
2439 return; \
2440 }
2441#else
2442# define CARLA_ABFL_CHECK_ACTOR(ActorPtr) \
2443 check((ActorPtr != nullptr) && !ActorPtr->IsPendingKill());
2444#endif // WITH_EDITOR
2445
2447 const FActorDescription &Description,
2448 ASceneCaptureSensor *Camera)
2449{
2450 CARLA_ABFL_CHECK_ACTOR(Camera);
2451 Camera->SetImageSize(
2452 RetrieveActorAttributeToInt("image_size_x", Description.Variations, 800),
2453 RetrieveActorAttributeToInt("image_size_y", Description.Variations, 600));
2454 Camera->SetFOVAngle(
2455 RetrieveActorAttributeToFloat("fov", Description.Variations, 90.0f));
2456 if (Description.Variations.Contains("enable_postprocess_effects"))
2457 {
2460 Description.Variations["enable_postprocess_effects"],
2461 true));
2462 Camera->SetTargetGamma(
2463 RetrieveActorAttributeToFloat("gamma", Description.Variations, 2.2f));
2464 Camera->SetMotionBlurIntensity(
2465 RetrieveActorAttributeToFloat("motion_blur_intensity", Description.Variations, 0.5f));
2467 RetrieveActorAttributeToFloat("motion_blur_max_distortion", Description.Variations, 5.0f));
2469 RetrieveActorAttributeToFloat("motion_blur_min_object_screen_size", Description.Variations, 0.5f));
2470 Camera->SetLensFlareIntensity(
2471 RetrieveActorAttributeToFloat("lens_flare_intensity", Description.Variations, 0.1f));
2472 Camera->SetBloomIntensity(
2473 RetrieveActorAttributeToFloat("bloom_intensity", Description.Variations, 0.675f));
2474 // Exposure, histogram mode by default
2475 if (RetrieveActorAttributeToString("exposure_mode", Description.Variations, "histogram") == "histogram")
2476 {
2477 Camera->SetExposureMethod(EAutoExposureMethod::AEM_Histogram);
2478 }
2479 else
2480 {
2481 Camera->SetExposureMethod(EAutoExposureMethod::AEM_Manual);
2482 }
2484 RetrieveActorAttributeToFloat("exposure_compensation", Description.Variations, 0.0f));
2485 Camera->SetShutterSpeed(
2486 RetrieveActorAttributeToFloat("shutter_speed", Description.Variations, 200.0f));
2487 Camera->SetISO(
2488 RetrieveActorAttributeToFloat("iso", Description.Variations, 100.0f));
2489 Camera->SetAperture(
2490 RetrieveActorAttributeToFloat("fstop", Description.Variations, 1.4f));
2491
2493 RetrieveActorAttributeToFloat("exposure_min_bright", Description.Variations, 7.0f));
2495 RetrieveActorAttributeToFloat("exposure_max_bright", Description.Variations, 9.0f));
2496 Camera->SetExposureSpeedUp(
2497 RetrieveActorAttributeToFloat("exposure_speed_up", Description.Variations, 3.0f));
2498 Camera->SetExposureSpeedDown(
2499 RetrieveActorAttributeToFloat("exposure_speed_down", Description.Variations, 1.0f));
2501 RetrieveActorAttributeToFloat("calibration_constant", Description.Variations, 16.0f));
2502
2503 Camera->SetFocalDistance(
2504 RetrieveActorAttributeToFloat("focal_distance", Description.Variations, 1000.0f));
2505 Camera->SetDepthBlurAmount(
2506 RetrieveActorAttributeToFloat("blur_amount", Description.Variations, 1.0f));
2507 Camera->SetDepthBlurRadius(
2508 RetrieveActorAttributeToFloat("blur_radius", Description.Variations, 0.0f));
2510 RetrieveActorAttributeToFloat("min_fstop", Description.Variations, 1.2f));
2511 Camera->SetBladeCount(
2512 RetrieveActorAttributeToInt("blade_count", Description.Variations, 5));
2513
2514 Camera->SetFilmSlope(
2515 RetrieveActorAttributeToFloat("slope", Description.Variations, 0.88f));
2516 Camera->SetFilmToe(
2517 RetrieveActorAttributeToFloat("toe", Description.Variations, 0.55f));
2518 Camera->SetFilmShoulder(
2519 RetrieveActorAttributeToFloat("shoulder", Description.Variations, 0.26f));
2520 Camera->SetFilmBlackClip(
2521 RetrieveActorAttributeToFloat("black_clip", Description.Variations, 0.0f));
2522 Camera->SetFilmWhiteClip(
2523 RetrieveActorAttributeToFloat("white_clip", Description.Variations, 0.04f));
2524
2525 Camera->SetWhiteTemp(
2526 RetrieveActorAttributeToFloat("temp", Description.Variations, 6500.0f));
2527 Camera->SetWhiteTint(
2528 RetrieveActorAttributeToFloat("tint", Description.Variations, 0.0f));
2529
2530 Camera->SetChromAberrIntensity(
2531 RetrieveActorAttributeToFloat("chromatic_aberration_intensity", Description.Variations, 0.0f));
2532 Camera->SetChromAberrOffset(
2533 RetrieveActorAttributeToFloat("chromatic_aberration_offset", Description.Variations, 0.0f));
2534 }
2535}
2536
2538 const FActorDescription &Description,
2539 AShaderBasedSensor *Camera)
2540{
2541 CARLA_ABFL_CHECK_ACTOR(Camera);
2542 Camera->SetFloatShaderParameter(0, TEXT("CircleFalloff_NState"),
2543 RetrieveActorAttributeToFloat("lens_circle_falloff", Description.Variations, 5.0f));
2544 Camera->SetFloatShaderParameter(0, TEXT("CircleMultiplier_NState"),
2545 RetrieveActorAttributeToFloat("lens_circle_multiplier", Description.Variations, 0.0f));
2546 Camera->SetFloatShaderParameter(0, TEXT("K_NState"),
2547 RetrieveActorAttributeToFloat("lens_k", Description.Variations, -1.0f));
2548 Camera->SetFloatShaderParameter(0, TEXT("kcube"),
2549 RetrieveActorAttributeToFloat("lens_kcube", Description.Variations, 0.0f));
2550 Camera->SetFloatShaderParameter(0, TEXT("XSize_NState"),
2551 RetrieveActorAttributeToFloat("lens_x_size", Description.Variations, 0.08f));
2552 Camera->SetFloatShaderParameter(0, TEXT("YSize_NState"),
2553 RetrieveActorAttributeToFloat("lens_y_size", Description.Variations, 0.08f));
2554}
2555
2557 const FActorDescription &Description,
2558 FLidarDescription &Lidar)
2559{
2560 constexpr float TO_CENTIMETERS = 1e2;
2561 Lidar.Channels =
2562 RetrieveActorAttributeToInt("channels", Description.Variations, Lidar.Channels);
2563 Lidar.Range =
2564 RetrieveActorAttributeToFloat("range", Description.Variations, 10.0f) * TO_CENTIMETERS;
2565 Lidar.PointsPerSecond =
2566 RetrieveActorAttributeToInt("points_per_second", Description.Variations, Lidar.PointsPerSecond);
2567 Lidar.RotationFrequency =
2568 RetrieveActorAttributeToFloat("rotation_frequency", Description.Variations, Lidar.RotationFrequency);
2569 Lidar.UpperFovLimit =
2570 RetrieveActorAttributeToFloat("upper_fov", Description.Variations, Lidar.UpperFovLimit);
2571 Lidar.LowerFovLimit =
2572 RetrieveActorAttributeToFloat("lower_fov", Description.Variations, Lidar.LowerFovLimit);
2573 Lidar.HorizontalFov =
2574 RetrieveActorAttributeToFloat("horizontal_fov", Description.Variations, Lidar.HorizontalFov);
2575 Lidar.AtmospAttenRate =
2576 RetrieveActorAttributeToFloat("atmosphere_attenuation_rate", Description.Variations, Lidar.AtmospAttenRate);
2577 Lidar.RandomSeed =
2578 RetrieveActorAttributeToInt("noise_seed", Description.Variations, Lidar.RandomSeed);
2579 Lidar.DropOffGenRate =
2580 RetrieveActorAttributeToFloat("dropoff_general_rate", Description.Variations, Lidar.DropOffGenRate);
2581 Lidar.DropOffIntensityLimit =
2582 RetrieveActorAttributeToFloat("dropoff_intensity_limit", Description.Variations, Lidar.DropOffIntensityLimit);
2584 RetrieveActorAttributeToFloat("dropoff_zero_intensity", Description.Variations, Lidar.DropOffAtZeroIntensity);
2585 Lidar.NoiseStdDev =
2586 RetrieveActorAttributeToFloat("noise_stddev", Description.Variations, Lidar.NoiseStdDev);
2587}
2588
2590 const FActorDescription &Description,
2591 AGnssSensor *Gnss)
2592{
2594 if (Description.Variations.Contains("noise_seed"))
2595 {
2596 Gnss->SetSeed(
2597 RetrieveActorAttributeToInt("noise_seed", Description.Variations, 0));
2598 }
2599 else
2600 {
2601 Gnss->SetSeed(Gnss->GetRandomEngine()->GenerateRandomSeed());
2602 }
2603
2605 RetrieveActorAttributeToFloat("noise_lat_stddev", Description.Variations, 0.0f));
2607 RetrieveActorAttributeToFloat("noise_lon_stddev", Description.Variations, 0.0f));
2609 RetrieveActorAttributeToFloat("noise_alt_stddev", Description.Variations, 0.0f));
2610 Gnss->SetLatitudeBias(
2611 RetrieveActorAttributeToFloat("noise_lat_bias", Description.Variations, 0.0f));
2612 Gnss->SetLongitudeBias(
2613 RetrieveActorAttributeToFloat("noise_lon_bias", Description.Variations, 0.0f));
2614 Gnss->SetAltitudeBias(
2615 RetrieveActorAttributeToFloat("noise_alt_bias", Description.Variations, 0.0f));
2616}
2617
2619 const FActorDescription &Description,
2621{
2623 if (Description.Variations.Contains("noise_seed"))
2624 {
2625 IMU->SetSeed(
2626 RetrieveActorAttributeToInt("noise_seed", Description.Variations, 0));
2627 }
2628 else
2629 {
2631 }
2632
2634 RetrieveActorAttributeToFloat("noise_accel_stddev_x", Description.Variations, 0.0f),
2635 RetrieveActorAttributeToFloat("noise_accel_stddev_y", Description.Variations, 0.0f),
2636 RetrieveActorAttributeToFloat("noise_accel_stddev_z", Description.Variations, 0.0f)});
2637
2639 RetrieveActorAttributeToFloat("noise_gyro_stddev_x", Description.Variations, 0.0f),
2640 RetrieveActorAttributeToFloat("noise_gyro_stddev_y", Description.Variations, 0.0f),
2641 RetrieveActorAttributeToFloat("noise_gyro_stddev_z", Description.Variations, 0.0f)});
2642
2643 IMU->SetGyroscopeBias({
2644 RetrieveActorAttributeToFloat("noise_gyro_bias_x", Description.Variations, 0.0f),
2645 RetrieveActorAttributeToFloat("noise_gyro_bias_y", Description.Variations, 0.0f),
2646 RetrieveActorAttributeToFloat("noise_gyro_bias_z", Description.Variations, 0.0f)});
2647}
2648
2650 const FActorDescription &Description,
2651 ARadar *Radar)
2652{
2654 constexpr float TO_CENTIMETERS = 1e2;
2655
2656 if (Description.Variations.Contains("noise_seed"))
2657 {
2658 Radar->SetSeed(
2659 RetrieveActorAttributeToInt("noise_seed", Description.Variations, 0));
2660 }
2661 else
2662 {
2663 Radar->SetSeed(Radar->GetRandomEngine()->GenerateRandomSeed());
2664 }
2665
2666 Radar->SetHorizontalFOV(
2667 RetrieveActorAttributeToFloat("horizontal_fov", Description.Variations, 30.0f));
2668 Radar->SetVerticalFOV(
2669 RetrieveActorAttributeToFloat("vertical_fov", Description.Variations, 30.0f));
2670 Radar->SetRange(
2671 RetrieveActorAttributeToFloat("range", Description.Variations, 100.0f) * TO_CENTIMETERS);
2672 Radar->SetPointsPerSecond(
2673 RetrieveActorAttributeToInt("points_per_second", Description.Variations, 1500));
2674}
2675
2677 const FActorDescription &Description,
2678 AV2XSensor* V2X)
2679{
2681 if (Description.Variations.Contains("noise_seed"))
2682 {
2683 V2X->SetSeed(
2684 RetrieveActorAttributeToInt("noise_seed", Description.Variations, 0));
2685 }
2686 else
2687 {
2689 }
2690
2692 RetrieveActorAttributeToFloat("transmit_power", Description.Variations, 21.5),
2693 RetrieveActorAttributeToFloat("receiver_sensitivity", Description.Variations, -99.0),
2694 RetrieveActorAttributeToFloat("frequency_ghz", Description.Variations, 5.9),
2695 RetrieveActorAttributeToFloat("combined_antenna_gain", Description.Variations, 10.0),
2696 RetrieveActorAttributeToFloat("path_loss_exponent", Description.Variations, 2.7),
2697 RetrieveActorAttributeToFloat("d_ref", Description.Variations, 1.0),
2698 RetrieveActorAttributeToFloat("filter_distance", Description.Variations, 500.0),
2699 RetrieveActorAttributeToBool("use_etsi_fading", Description.Variations, true),
2700 RetrieveActorAttributeToFloat("custom_fading_stddev", Description.Variations, 0.0f)
2701 );
2702
2703 if (RetrieveActorAttributeToString("scenario", Description.Variations, "urban") == "urban")
2704 {
2706 }
2707 else if (RetrieveActorAttributeToString("scenario", Description.Variations, "urban") == "rural")
2708 {
2710 }
2711 else
2712 {
2714 }
2715
2716 V2X->SetCaServiceParams(
2717 RetrieveActorAttributeToFloat("gen_cam_min", Description.Variations, 0.1),
2718 RetrieveActorAttributeToFloat("gen_cam_max", Description.Variations, 1.0),
2719 RetrieveActorAttributeToBool("fixed_rate", Description.Variations, false));
2720
2722 RetrieveActorAttributeToFloat("noise_accel_stddev_x", Description.Variations, 0.0f),
2723 RetrieveActorAttributeToFloat("noise_accel_stddev_y", Description.Variations, 0.0f),
2724 RetrieveActorAttributeToFloat("noise_accel_stddev_z", Description.Variations, 0.0f)});
2725
2726 V2X->SetGNSSDeviation(
2727 RetrieveActorAttributeToFloat("noise_lat_stddev", Description.Variations, 0.0f),
2728 RetrieveActorAttributeToFloat("noise_lon_stddev", Description.Variations, 0.0f),
2729 RetrieveActorAttributeToFloat("noise_alt_stddev", Description.Variations, 0.0f),
2730 RetrieveActorAttributeToFloat("noise_head_stddev", Description.Variations, 0.0f),
2731 RetrieveActorAttributeToFloat("noise_lat_bias", Description.Variations, 0.0f),
2732 RetrieveActorAttributeToFloat("noise_lon_bias", Description.Variations, 0.0f),
2733 RetrieveActorAttributeToFloat("noise_alt_bias", Description.Variations, 0.0f),
2734 RetrieveActorAttributeToFloat("noise_head_bias", Description.Variations, 0.0f));
2735
2736 V2X->SetVelDeviation(
2737 RetrieveActorAttributeToFloat("noise_vel_stddev_x", Description.Variations, 0.0f)
2738 );
2740 RetrieveActorAttributeToFloat("noise_yawrate_stddev", Description.Variations, 0.0f),
2741 RetrieveActorAttributeToFloat("noise_yawrate_bias", Description.Variations, 0.0f)
2742 );
2743
2744 if (RetrieveActorAttributeToString("path_loss_model", Description.Variations, "geometric") == "winner")
2745 {
2747 }
2748 else if(RetrieveActorAttributeToString("path_loss_model", Description.Variations, "geometric") == "geometric")
2749 {
2751 }
2752
2753
2754}
2755
2757 const FActorDescription &Description,
2758 ACustomV2XSensor* V2X)
2759{
2761 if (Description.Variations.Contains("noise_seed"))
2762 {
2763 V2X->SetSeed(
2764 RetrieveActorAttributeToInt("noise_seed", Description.Variations, 0));
2765 }
2766 else
2767 {
2769 }
2770
2772 RetrieveActorAttributeToFloat("transmit_power", Description.Variations, 21.5),
2773 RetrieveActorAttributeToFloat("receiver_sensitivity", Description.Variations, -99.0),
2774 RetrieveActorAttributeToFloat("frequency_ghz", Description.Variations, 5.9),
2775 RetrieveActorAttributeToFloat("combined_antenna_gain", Description.Variations, 10.0),
2776 RetrieveActorAttributeToFloat("path_loss_exponent", Description.Variations, 2.7),
2777 RetrieveActorAttributeToFloat("d_ref", Description.Variations, 1.0),
2778 RetrieveActorAttributeToFloat("filter_distance", Description.Variations, 500.0),
2779 RetrieveActorAttributeToBool("use_etsi_fading", Description.Variations, true),
2780 RetrieveActorAttributeToFloat("custom_fading_stddev", Description.Variations, 0.0f)
2781 );
2782
2783 if (RetrieveActorAttributeToString("scenario", Description.Variations, "urban") == "urban")
2784 {
2786 }
2787 else if (RetrieveActorAttributeToString("scenario", Description.Variations, "urban") == "rural")
2788 {
2790 }
2791 else
2792 {
2794 }
2795
2796
2797 if (RetrieveActorAttributeToString("path_loss_model", Description.Variations, "geometric") == "winner")
2798 {
2800 }
2801 else if(RetrieveActorAttributeToString("path_loss_model", Description.Variations, "geometric") == "geometric")
2802 {
2804 }
2805
2806
2807}
2808#undef CARLA_ABFL_CHECK_ACTOR
static FString JoinStrings(const FString &Separator, ARGS &&... Args)
static void AddVariationsForTrigger(FActorDefinition &Def)
static void AddRecommendedValuesForSensorRoleNames(FActorDefinition &Definition)
#define CARLA_ABFL_CHECK_ACTOR(ActorPtr)
static void AddRecommendedValuesForActorRoleName(FActorDefinition &Definition, TArray< FString > &&RecommendedValues)
static void AddVariationsForSensor(FActorDefinition &Def)
static FString ColorToFString(const FColor &Color)
static void FillIdAndTags(FActorDefinition &Def, TStrs &&... Strings)
============================================================================
UE_LOG(LogCarla, Log, TEXT("UActorDispatcher::Destroying actor: '%s' %x"), *Id, Actor)
#define DEBUG_ASSERT(predicate)
Definition Debug.h:68
@ Rural
@ Urban
@ Highway
@ Winner
@ Geometric
EPedestrianGender
EPropSize
EActorAttributeType
List of valid types for actor attributes.(角色属性有效类型的列表)
void SetPathLossModel(const EPathLossModel path_loss_model)
void SetPropagationParams(const float TransmitPower, const float ReceiverSensitivity, const float Frequency, const float combined_antenna_gain, const float path_loss_exponent, const float reference_distance_fspl, const float filter_distance, const bool use_etsi_fading, const float custom_fading_stddev)
void SetScenario(EScenario scenario)
GNSS传感器表示类 实际的位置信息计算是在服务器端进行的
Definition GnssSensor.h:24
void SetLatitudeDeviation(float Value)
void SetLongitudeBias(float Value)
void SetLongitudeDeviation(float Value)
void SetAltitudeDeviation(float Value)
void SetAltitudeBias(float Value)
void SetLatitudeBias(float Value)
void SetGyroscopeBias(const FVector &Vec)
void SetAccelerationStandardDeviation(const FVector &Vec)
void SetGyroscopeStandardDeviation(const FVector &Vec)
A ray-cast based Radar sensor.
Definition Radar.h:22
Base class for sensors using a USceneCaptureComponent2D for rendering the scene.
void SetExposureMethod(EAutoExposureMethod Method)
void SetFOVAngle(float FOVAngle)
void SetShutterSpeed(float Speed)
void SetImageSize(uint32 Width, uint32 Height)
void SetChromAberrIntensity(float Intensity)
void SetMotionBlurMinObjectScreenSize(float ScreenSize)
void SetFilmShoulder(float Shoulder)
void SetExposureCompensation(float Compensation)
void SetMotionBlurMaxDistortion(float MaxDistortion)
void SetDepthBlurAmount(float Amount)
void SetExposureMaxBrightness(float Brightness)
void SetWhiteTemp(float Temp)
void SetFilmBlackClip(float BlackClip)
void SetExposureCalibrationConstant(float Constant)
void SetAperture(float Aperture)
void EnablePostProcessingEffects(bool Enable=true)
void SetDepthBlurRadius(float Radius)
void SetFocalDistance(float Distance)
void SetChromAberrOffset(float ChromAberrOffset)
void SetLensFlareIntensity(float Intensity)
void SetBladeCount(int Count)
void SetFilmWhiteClip(float WhiteClip)
void SetBloomIntensity(float Intensity)
void SetMotionBlurIntensity(float Intensity)
void SetTargetGamma(float InTargetGamma)
void SetDepthOfFieldMinFstop(float MinFstop)
void SetWhiteTint(float Tint)
void SetExposureSpeedDown(float Speed)
void SetFilmSlope(float Slope)
void SetExposureSpeedUp(float Speed)
void SetExposureMinBrightness(float Brightness)
void SetSeed(int32 InSeed)
Definition Sensor.cpp:87
A sensor that produces data by applying post-process materials (shaders) to a scene capture image.
void SetFloatShaderParameter(uint8_t ShaderIndex, const FName &ParameterName, float Value)
void SetPropagationParams(const float TransmitPower, const float ReceiverSensitivity, const float Frequency, const float combined_antenna_gain, const float path_loss_exponent, const float reference_distance_fspl, const float filter_distance, const bool use_etsi_fading, const float custom_fading_stddev)
Definition V2XSensor.cpp:75
void SetGNSSDeviation(const float noise_lat_stddev, const float noise_lon_stddev, const float noise_alt_stddev, const float noise_head_stddev, const float noise_lat_bias, const float noise_lon_bias, const float noise_alt_bias, const float noise_head_bias)
void SetAccelerationStandardDeviation(const FVector &Vec)
void SetPathLossModel(const EPathLossModel path_loss_model)
Definition V2XSensor.cpp:89
void SetScenario(EScenario scenario)
Definition V2XSensor.cpp:94
void SetYawrateDeviation(const float noise_yawrate_stddev, const float noise_yawrate_bias)
void SetCaServiceParams(const float GenCamMin, const float GenCamMax, const bool FixedRate)
Definition V2XSensor.cpp:69
void SetVelDeviation(const float noise_vel_stddev)
Checks validity of FActorDefinition.(检查 FActorDefinition 的有效性)
bool IsValid(const FActorVariation &Variation)
bool OnScreenAssert(bool Predicate, const T &Format, ARGS &&... Args) const
If Predicate is false, print an error message.
bool AreTagsValid(const FString &Tags)
验证标签是否有效
FString GetDisplayId(const FString &Type, size_t Index, const T &Item)
为给定类型的项目生成显示ID。
bool SingleIsValid(const FActorDefinition &Definition)
Validate ActorDefinition and display messages on error.(验证ActorDefinition的有效性,并在出现错误时显示消息)
bool IsValid(const EActorAttributeType Type)
验证类型是否有效
bool AreValid(const FString &Type, const TArray< T > &Array)
Applies IsValid to each item in Array.
bool AreValid(const TArray< FActorDefinition > &ActorDefinitions)
Iterate all actor definitions and their properties and display messages on error.
bool ValueIsValid(const EActorAttributeType Type, const FString &Value)
验证值是否有效
bool IsIdValid(const FString &Id)
验证ID是否有效
bool IsValid(const FActorAttribute &Attribute)
bool ForEach(const FString &Type, const TArray< T > &Array, F Validator)
Applies Validator to each item in Array.
bool IsValid(const FActorDefinition &ActorDefinition)
FString GetDisplayId(const FString &Type, size_t Index, const FString &Item)
为给定类型的字符串项目生成显示ID的重载版本。
auto PushScope(V &&Value)
Definition ScopedStack.h:28
static FActorDefinition MakeIMUDefinition()
创建一个惯性测量单元参与者定义。
static void MakeTriggerDefinition(const FString &Id, bool &Success, FActorDefinition &Definition)
根据ID创建触发器参与者定义,并返回操作是否成功。
static FActorDefinition MakeCustomV2XDefinition()
创建一个自定义车对外界信息交换传感器参与者定义。
static void MakeVehicleDefinitions(const TArray< FVehicleParameters > &ParameterArray, TArray< FActorDefinition > &Definitions)
根据车辆参数数组创建多个车辆参与者定义。
static void MakePropDefinitions(const TArray< FPropParameters > &ParameterArray, TArray< FActorDefinition > &Definitions)
static void MakePedestrianDefinition(const FPedestrianParameters &Parameters, bool &Success, FActorDefinition &Definition)
根据行人参数创建行人参与者定义,并返回操作是否成功。
static int32 ActorAttributeToInt(const FActorAttribute &ActorAttribute, int32 Default)
将参与者属性转换为整数,如果不存在则返回默认值。
static FColor ActorAttributeToColor(const FActorAttribute &ActorAttribute, const FColor &Default)
将参与者属性转换为颜色,如果不存在则返回默认值。
static FColor RetrieveActorAttributeToColor(const FString &Id, const TMap< FString, FActorAttribute > &Attributes, const FColor &Default)
static void SetLidar(const FActorDescription &Description, FLidarDescription &Lidar)
static void SetRadar(const FActorDescription &Description, ARadar *Radar)
static void SetV2X(const FActorDescription &Description, AV2XSensor *V2X)
static void MakePedestrianDefinitions(const TArray< FPedestrianParameters > &ParameterArray, TArray< FActorDefinition > &Definitions)
根据行人参数数组创建多个行人参与者定义。
static int32 RetrieveActorAttributeToInt(const FString &Id, const TMap< FString, FActorAttribute > &Attributes, int32 Default)
从参与者属性映射中检索整数,如果不存在则返回默认值。
static FString ActorAttributeToString(const FActorAttribute &ActorAttribute, const FString &Default)
将参与者属性转换为字符串,如果不存在则返回默认值。
static bool RetrieveActorAttributeToBool(const FString &Id, const TMap< FString, FActorAttribute > &Attributes, bool Default)
从参与者属性映射中检索布尔值,如果不存在则返回默认值。
static FString RetrieveActorAttributeToString(const FString &Id, const TMap< FString, FActorAttribute > &Attributes, const FString &Default)
static FActorDefinition MakeCameraDefinition(const FString &Id, bool bEnableModifyingPostProcessEffects=false)
创建一个相机参与者定义。
static FActorDefinition MakeV2XDefinition()
创建一个车对外界信息交换传感器参与者定义。
static void MakeTriggerDefinitions(const TArray< FString > &ParameterArray, TArray< FActorDefinition > &Definitions)
根据ID数组创建触发器参与者定义。
static void MakePropDefinition(const FPropParameters &Parameters, bool &Success, FActorDefinition &Definition)
根据道具参数创建道具参与者定义,并返回操作是否成功。
static FActorDefinition MakeNormalsCameraDefinition()
创建一个法线相机参与者定义。
static FActorDefinition MakeRadarDefinition()
创建一个雷达参与者定义。
static FActorDefinition MakeLidarDefinition(const FString &Id)
创建一个激光雷达参与者定义。
static float RetrieveActorAttributeToFloat(const FString &Id, const TMap< FString, FActorAttribute > &Attributes, float Default)
static bool CheckActorDefinitions(const TArray< FActorDefinition > &ActorDefinitions)
返回演员定义列表是否有效。打印所有 发现错误
static void SetCustomV2X(const FActorDescription &Description, ACustomV2XSensor *V2X)
static FActorDefinition MakeGenericSensorDefinition(const FString &Type, const FString &Id)
创建一个通用的传感器参与者定义。
static float ActorAttributeToFloat(const FActorAttribute &ActorAttribute, float Default)
将参与者属性转换为浮点数,如果不存在则返回默认值。
static bool ActorAttributeToBool(const FActorAttribute &ActorAttribute, bool Default)
static FActorDefinition MakeGnssDefinition()
创建一个全球导航卫星系统传感器参与者定义。
static void SetGnss(const FActorDescription &Description, AGnssSensor *Gnss)
static FActorDefinition MakeGenericDefinition(const FString &Category, const FString &Type, const FString &Id)
创建一个通用的参与者定义。
static void SetIMU(const FActorDescription &Description, AInertialMeasurementUnit *IMU)
static void SetCamera(const FActorDescription &Description, ASceneCaptureSensor *Camera)
static void MakeVehicleDefinition(const FVehicleParameters &Parameters, bool &Success, FActorDefinition &Definition)
根据车辆参数创建车辆参与者定义,并返回操作是否成功。
static void MakeObstacleDetectorDefinitions(const FString &Type, const FString &Id, FActorDefinition &Definition)
static bool CheckActorDefinition(const FActorDefinition &ActorDefinitions)
返回角色定义是否有效。打印所有找到的错误
static int32 GenerateRandomSeed()
生成一个非确定性随机数种子。
An actor attribute, may be an intrinsic (non-modifiable) attribute of the actor or an user-defined ac...
TArray< FActorVariation > Variations
变体代表了用户可以修改的变量,以生成不同的变体 关于参与者
TArray< FActorAttribute > Attributes
属性表示参与者可能具有的不可修改的特性 帮助用户识别和过滤参与者
TSubclassOf< AActor > Class
要生成的参与者类(可选)
TMap< FString, FActorAttribute > Variations
用户选择了参与者的变化版本。请注意,此时是 由不可修改的属性表示
float DropOffAtZeroIntensity
对于基于强度的下降,每个零强度点被下降的概率。
float HorizontalFov
水平视野(以度为单位),0 - 360。
int RandomSeed
该传感器使用的噪声/丢弃的随机种子。
float LowerFovLimit
最低激光的角度(以度为单位),从水平开始计数,负值表示在水平线以下。
float Range
测量距离,单位:厘米
float DropOffGenRate
随机丢弃的点的一般比例。
uint32 Channels
激光雷达的线数
float DropOffIntensityLimit
对于基于强度的下降,高于该阈值的强度值没有任何点被下降。
uint32 PointsPerSecond
每秒钟所有激光产生的点。
float RotationFrequency
激光雷达旋转频率
float AtmospAttenRate
大气中的衰减率(单位:m^-1)
float UpperFovLimit
最高激光的角度(以度为单位),从水平线开始计数,正值表示水平线以上。
TArray< FColor > RecommendedColors
TArray< int32 > SupportedDrivers
此车辆支持的驾驶员(行人)的ID列表,如果没有任何驾驶员支持,则留空
TSubclassOf< ACarlaWheeledVehicle > Class
FString BaseType
(可选)用于车辆的基本分类(汽车/卡车/货车/自行车/摩托车)
FString ObjectType
(可选)用于车辆的自定义分类
FString SpecialType
(可选)用于对车辆进行更深入的分类(电动/应急/出租车等)