waiwaylee/radar_data_process
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: waiwaylee/radar_data_process:ae3ef84441628601cffedec83868db1d8cb9f6f5
Branches Tags
waiwaylee/radar_data_process:master
..
compare: waiwaylee/radar_data_process:b3e2f5226253469ee8effec25500de669c13be1f
Branches Tags
waiwaylee/radar_data_process:master
10 Commits
ae3ef84441 .. b3e2f52262
Author SHA1 Message Date
waiwaylee b3e2f52262 更新：1、修改TAS波束控制逻辑，现在按固定数据率调度TAS波束； 
Signed-off-by: waiwaylee <waiwaylee@foxmail.com>
 2026-08-27 16:19:47 +08:00
waiwaylee 93d39248e5 更新：1、新增README.md文件 
Signed-off-by: waiwaylee <waiwaylee@foxmail.com>
 2026-08-27 15:17:48 +08:00
waiwaylee 3500652a3b 更新：1、去掉1km以内航迹起批20dB门限 
Signed-off-by: waiwaylee <waiwaylee@foxmail.com>
 2026-08-21 14:15:34 +08:00
waiwaylee 01d28e0d28 更新：1、使用VS code+cmake重新编译，编译器保持不变； 
2、修复若干逻辑bug，具体参考BUG_FIX_REPORT.md

Signed-off-by: waiwaylee <waiwaylee@foxmail.com>
 2026-08-18 11:26:19 +08:00
waiwaylee 60ad5c136f 更新：增加TWS输出高度平滑处理 
Signed-off-by: waiwaylee <waiwaylee@foxmail.com>
 2026-08-17 14:37:02 +08:00
waiwaylee 0cb31b48ca 更新：1、删除不必要的文件； 
2、输入点迹、输出航迹的CPI时间和GNSS时间都改为64位整型；
3、修复TAS外推时间差计算可能为无效值的问题；

Signed-off-by: waiwaylee <waiwaylee@foxmail.com>
 2026-08-17 14:08:29 +08:00
waiwaylee d101fe92a4 更新：1、增加航迹清空功能，解决重连时大量航迹乱窜的问题； 
2、修改TAS时航迹外推逻辑，时间间隔按波束时间计算；
3、增加1km以内航迹起始限制，SNR低于20dB的航迹不起批；减少近距离航迹；

Signed-off-by: waiwaylee <waiwaylee@foxmail.com>
 2026-08-13 17:14:17 +08:00
waiwaylee 8636179bdf 更新：机扫和相扫程序合并，通过宏定义配置切换 
Signed-off-by: waiwaylee <waiwaylee@foxmail.com>
 2026-07-31 10:52:53 +08:00
waiwaylee 06d45f5917 更新：1、机扫跟踪时增加高度门限判断 
Signed-off-by: waiwaylee <waiwaylee@foxmail.com>
 2026-07-14 14:33:36 +08:00
waiwaylee 8b1896dd74 更新：1、适配四面阵机扫跟踪模式。 
Signed-off-by: waiwaylee <waiwaylee@foxmail.com>
 2026-07-13 10:20:32 +08:00
1678 changed files with 2954 additions and 333713 deletions
Expand all files Collapse all files
.gitignore
+2
View File
@@ -2,3 +2,5 @@
build-data_process_class_dll-Desktop_Qt_5_7_0_MSVC2013_32bit-Release/ build-data_process_class_dll-Desktop_Qt_5_7_0_MSVC2013_32bit-Release/
debug/ debug/
release/ release/
build/
.mnemon/
.vscode/c_cpp_properties.json
Vendored
+49
View File
@@ -0,0 +1,49 @@
{
"version": 4,
"configurations": [
{
"compilerPath": "D:\\APP\\VisualStudio2013\\VC\\bin\\cl.exe",
"cStandard": "c11",
"cppStandard": "c++11",
"intelliSenseMode": "windows-msvc-x86",
"defines": [
"WIN32",
"_WINDOWS",
"UNICODE",
"_UNICODE",
"NOMINMAX",
"DATA_PROCESS_CLASS_DLL_LIBRARY",
"PHASE_SCANNING"
],
"includePath": [
"${workspaceFolder}/data_process_class_dll",
"${workspaceFolder}/data_process_class_dll/Eigen",
"${workspaceFolder}/**"
],
"name": "X256_PS (MSVC2013 x86)",
"compileCommands": "${workspaceFolder}/build/X256_PS/compile_commands.json"
},
{
"compilerPath": "D:\\APP\\VisualStudio2013\\VC\\bin\\cl.exe",
"cStandard": "c11",
"cppStandard": "c++11",
"intelliSenseMode": "windows-msvc-x86",
"defines": [
"WIN32",
"_WINDOWS",
"UNICODE",
"_UNICODE",
"NOMINMAX",
"DATA_PROCESS_CLASS_DLL_LIBRARY",
"MECHANICAL_SCANNING"
],
"includePath": [
"${workspaceFolder}/data_process_class_dll",
"${workspaceFolder}/data_process_class_dll/Eigen",
"${workspaceFolder}/**"
],
"name": "X256_MS (MSVC2013 x86)",
"compileCommands": "${workspaceFolder}/build/X256_MS/compile_commands.json"
}
]
}
.vscode/cmake-variants.yaml
Vendored
+25
View File
@@ -0,0 +1,25 @@
buildType:
default: release
choices:
release:
short: Release
long: Release (MSVC2013 x86)
buildType: Release
debug:
short: Debug
long: Debug (MSVC2013 x86)
buildType: Debug
scanMode:
default: ps
choices:
ps:
short: X256_PS
long: X256_PS - PHASE_SCANNING
settings:
RADAR_SCAN_MODE: PHASE_SCANNING
ms:
short: X256_MS
long: X256_MS - MECHANICAL_SCANNING
settings:
RADAR_SCAN_MODE: MECHANICAL_SCANNING
.vscode/extensions.json
Vendored
+7
View File
@@ -0,0 +1,7 @@
{
"recommendations": [
"ms-vscode.cpptools",
"ms-vscode.cmake-tools",
"twxs.cmake"
]
}
.vscode/launch.json
Vendored
+24
View File
@@ -0,0 +1,24 @@
{
"version": "0.2.0",
"configurations": [
{
"name": "调试 DLL",
"type": "cppvsdbg",
"request": "launch",
"program": "${workspaceFolder}/build/X256_PS/bin/rdp_playback.exe",
"args": ["-d", "E:/Demo/QT/simianzhen256-v1.5.5-ms-vscode/build/X256_PS/bin/2026-07-18/15-34-32", "-i", "E:/Demo/QT/simianzhen256-v1.5.5-ms-vscode/build/X256_PS/bin/RadarConfigParam.ini", "-c", "E:/Demo/QT/simianzhen256-v1.5.5-ms-vscode/build/X256_PS/bin/2026-07-18/15-34-32/track.csv"],
"stopAtEntry": false,
"cwd": "${workspaceFolder}",
"environment": [],
"externalConsole": false,
"preLaunchTask": "CMake: 配置并构建 X256_PS (Debug)",
"symbolSearchPath": "${workspaceFolder}/build/X256_PS/bin"
},
{
"name": "附加到宿主进程（调试 DLL）",
"type": "cppvsdbg",
"request": "attach",
"processId": "${command:pickProcess}"
}
]
}
.vscode/scripts/build.bat
Vendored
+11
View File
@@ -0,0 +1,11 @@
@echo off
setlocal
set "BUILD_DIR=%~1"
if "%BUILD_DIR%"=="" (
echo Usage: build.bat ^<build-dir^>
exit /b 1
)
call D:\APP\VisualStudio2013\VC\vcvarsall.bat x86 >nul
if errorlevel 1 exit /b %errorlevel%
cmake --build "%BUILD_DIR%"
exit /b %errorlevel%
.vscode/scripts/clean.bat
Vendored
+11
View File
@@ -0,0 +1,11 @@
@echo off
setlocal
set "BUILD_DIR=%~1"
if "%BUILD_DIR%"=="" (
echo Usage: clean.bat ^<build-dir^>
exit /b 1
)
call D:\APP\VisualStudio2013\VC\vcvarsall.bat x86 >nul
if errorlevel 1 exit /b %errorlevel%
cmake --build "%BUILD_DIR%" --target clean
exit /b %errorlevel%
.vscode/scripts/configure.bat
Vendored
+21
View File
@@ -0,0 +1,21 @@
@echo off
setlocal
set "BUILD_DIR=%~1"
set "SCAN_MODE=%~2"
set "BUILD_TYPE=%~3"
if "%BUILD_DIR%"=="" (
echo Usage: configure.bat ^<build-dir^> ^<PHASE_SCANNING^|MECHANICAL_SCANNING^> [Debug^|Release]
exit /b 1
)
if "%SCAN_MODE%"=="" (
echo Usage: configure.bat ^<build-dir^> ^<PHASE_SCANNING^|MECHANICAL_SCANNING^> [Debug^|Release]
exit /b 1
)
if "%BUILD_TYPE%"=="" set "BUILD_TYPE=Release"
call D:\APP\VisualStudio2013\VC\vcvarsall.bat x86 >nul
if errorlevel 1 exit /b %errorlevel%
pushd "%~dp0..\.."
cmake -S . -B "%BUILD_DIR%" -G "NMake Makefiles" -DCMAKE_BUILD_TYPE=%BUILD_TYPE% -DRADAR_SCAN_MODE=%SCAN_MODE%
set "CMAKE_EXIT=%errorlevel%"
popd
exit /b %CMAKE_EXIT%
.vscode/settings.json
Vendored
+12
View File
@@ -0,0 +1,12 @@
{
"cmake.configureOnOpen": false,
"cmake.generator": "NMake Makefiles",
"cmake.buildDirectory": "${workspaceFolder}/build/X256_PS",
"cmake.environment": {
"PATH": "D:\\APP\\VisualStudio2013\\VC\\BIN;D:\\APP\\VisualStudio2013\\Common7\\IDE;C:\\Program Files (x86)\\Windows Kits\\8.1\\bin\\x86;${env:PATH}",
"INCLUDE": "D:\\APP\\VisualStudio2013\\VC\\INCLUDE;D:\\APP\\VisualStudio2013\\VC\\ATLMFC\\INCLUDE;C:\\Program Files (x86)\\Windows Kits\\8.1\\include\\shared;C:\\Program Files (x86)\\Windows Kits\\8.1\\include\\um;C:\\Program Files (x86)\\Windows Kits\\8.1\\include\\winrt;${env:INCLUDE}",
"LIB": "D:\\APP\\VisualStudio2013\\VC\\LIB;D:\\APP\\VisualStudio2013\\VC\\ATLMFC\\LIB;C:\\Program Files (x86)\\Windows Kits\\8.1\\lib\\winv6.3\\um\\x86;${env:LIB}"
},
"C_Cpp.default.cppStandard": "c++11",
"C_Cpp.default.compileCommands": "${workspaceFolder}/build/X256_PS/compile_commands.json"
}
.vscode/tasks.json
Vendored
+170
View File
@@ -0,0 +1,170 @@
{
"version": "2.0.0",
"options": {
"cwd": "${workspaceFolder}"
},
"tasks": [
{
"label": "CMake: 配置 X256_PS (Release, MSVC2013 x86)",
"type": "shell",
"command": "${workspaceFolder}\\.vscode\\scripts\\configure.bat",
"args": [
"${workspaceFolder}/build/X256_PS",
"PHASE_SCANNING",
"Release"
],
"problemMatcher": []
},
{
"label": "CMake: 配置 X256_PS (Debug, MSVC2013 x86)",
"type": "shell",
"command": "${workspaceFolder}\\.vscode\\scripts\\configure.bat",
"args": [
"${workspaceFolder}/build/X256_PS",
"PHASE_SCANNING",
"Debug"
],
"problemMatcher": []
},
{
"label": "CMake: 构建 X256_PS (Release)",
"type": "shell",
"command": "${workspaceFolder}\\.vscode\\scripts\\build.bat",
"args": [
"${workspaceFolder}/build/X256_PS"
],
"group": "build",
"problemMatcher": [
"$msCompile"
]
},
{
"label": "CMake: 构建 X256_PS (Debug)",
"type": "shell",
"command": "${workspaceFolder}\\.vscode\\scripts\\build.bat",
"args": [
"${workspaceFolder}/build/X256_PS"
],
"group": "build",
"problemMatcher": [
"$msCompile"
]
},
{
"label": "CMake: 清理 X256_PS",
"type": "shell",
"command": "${workspaceFolder}\\.vscode\\scripts\\clean.bat",
"args": [
"${workspaceFolder}/build/X256_PS"
],
"problemMatcher": []
},
{
"label": "CMake: 配置 X256_MS (Release, MSVC2013 x86)",
"type": "shell",
"command": "${workspaceFolder}\\.vscode\\scripts\\configure.bat",
"args": [
"${workspaceFolder}/build/X256_MS",
"MECHANICAL_SCANNING",
"Release"
],
"problemMatcher": []
},
{
"label": "CMake: 配置 X256_MS (Debug, MSVC2013 x86)",
"type": "shell",
"command": "${workspaceFolder}\\.vscode\\scripts\\configure.bat",
"args": [
"${workspaceFolder}/build/X256_MS",
"MECHANICAL_SCANNING",
"Debug"
],
"problemMatcher": []
},
{
"label": "CMake: 构建 X256_MS (Release)",
"type": "shell",
"command": "${workspaceFolder}\\.vscode\\scripts\\build.bat",
"args": [
"${workspaceFolder}/build/X256_MS"
],
"group": "build",
"problemMatcher": [
"$msCompile"
]
},
{
"label": "CMake: 构建 X256_MS (Debug)",
"type": "shell",
"command": "${workspaceFolder}\\.vscode\\scripts\\build.bat",
"args": [
"${workspaceFolder}/build/X256_MS"
],
"group": "build",
"problemMatcher": [
"$msCompile"
]
},
{
"label": "CMake: 清理 X256_MS",
"type": "shell",
"command": "${workspaceFolder}\\.vscode\\scripts\\clean.bat",
"args": [
"${workspaceFolder}/build/X256_MS"
],
"problemMatcher": []
},
{
"label": "CMake: 配置并构建 X256_PS (Release)",
"dependsOrder": "sequence",
"dependsOn": [
"CMake: 配置 X256_PS (Release, MSVC2013 x86)",
"CMake: 构建 X256_PS (Release)"
],
"group": {
"kind": "build",
"isDefault": true
},
"problemMatcher": []
},
{
"label": "CMake: 配置并构建 X256_PS (Debug)",
"dependsOrder": "sequence",
"dependsOn": [
"CMake: 配置 X256_PS (Debug, MSVC2013 x86)",
"CMake: 构建 X256_PS (Debug)"
],
"group": "build",
"problemMatcher": []
},
{
"label": "CMake: 配置并构建 X256_MS (Release)",
"dependsOrder": "sequence",
"dependsOn": [
"CMake: 配置 X256_MS (Release, MSVC2013 x86)",
"CMake: 构建 X256_MS (Release)"
],
"group": "build",
"problemMatcher": []
},
{
"label": "CMake: 配置并构建 X256_MS (Debug)",
"dependsOrder": "sequence",
"dependsOn": [
"CMake: 配置 X256_MS (Debug, MSVC2013 x86)",
"CMake: 构建 X256_MS (Debug)"
],
"group": "build",
"problemMatcher": []
},
{
"label": "CMake: 配置并构建全部 (X256_PS + X256_MS, Release)",
"dependsOrder": "sequence",
"dependsOn": [
"CMake: 配置并构建 X256_PS (Release)",
"CMake: 配置并构建 X256_MS (Release)"
],
"problemMatcher": []
}
]
}
BUG_FIX_REPORT.md
+186
View File
@@ -0,0 +1,186 @@
# Bug 修复报告
根据 `BUG_REPORT.md` 中的“是否修复”指示，本次完成了所有标记为“按建议修改/按建议修复”的项；标记为“暂不修复/暂不修改/暂不处理”的项保持原样未改动。
---
## 修复状态汇总
| 编号 | 标题 | 指示 | 状态 |
|---|---|---|---|
| BUG-01 | 基类无虚析构函数 | 暂不修复 | 未修改 |
| BUG-02 | Hight_smooth 无限增长 | 暂不修复 | 未修改 |
| BUG-03 | 工厂单例非线程安全 | 暂不修复 | 未修改 |
| BUG-04 | TAS Point_Sum 未限幅 | 按建议修复 | ✅ 已修复 |
| BUG-05 | Track_to_start.size()-1 下溢 | 按建议修复 | ✅ 已修复 |
| BUG-06 | track_start_point_num 未校验 | 按建议修复 | ✅ 已修复 |
| BUG-07 | 禁止区域个数未限制 | 暂不修复 | 未修改 |
| BUG-08 | 消亡航迹输出无容量检查 | 暂不修改 | 未修改 |
| BUG-09 | Beam_Ctrl 输出计数越界风险 | 按建议修改 | ✅ 已修复 |
| BUG-10 | 航迹号数组下标未校验 | 按建议修改 | ✅ 已修复 |
| BUG-11 | TAS model_filter 未初始化变量 | 按建议修改 | ✅ 已修复 |
| BUG-12 | tas_beam_output 未初始化变量 | 按建议修改 | ✅ 已修复 |
| BUG-13 | Work_Parameter 未初始化 | 暂不修复 | 未修改 |
| BUG-14 | lastest_index 未初始化 | 按建议修改 | ✅ 已修复 |
| BUG-15 | TWS delta_T<=0 仍关联 | 按建议修改 | ✅ 已修复 |
| BUG-16 | TAS 无 delta_T>0 检查 | 按建议修改 | ✅ 已修复 |
| BUG-17 | TAS 外推负时间差 | 按建议修改 | ✅ 已修复 |
| BUG-18 | 卡尔曼时间差除零 | 暂不修改 | 未修改 |
| BUG-19 | Bind_speed prt=0 除零 | 按建议修改 | ✅ 已修复 |
| BUG-20 | 门限重复平方 | 暂不修改 | 未修改 |
| BUG-21 | 近程模型 3 门限整数除法 | 按建议修改 | ✅ 已修复 |
| BUG-22 | EKF/凝聚方位角未环绕 | 按建议修改 | ✅ 已修复 |
| BUG-23 | IMM 概率零分母/奇异矩阵 | 按建议修改 | ✅ 已修复 |
| BUG-24 | EKF 似然只取 2x2 S | 按建议修改 | ✅ 已修复 |
| BUG-25 | TWS 处理 TAS 航迹 | 暂不处理 | 未修改 |
| BUG-26 | 输出航向角使用 atan | 按建议修改 | ✅ 已修复 |
| BUG-27 | asin(height/range) 未保护 | 按建议修改 | ✅ 已修复 |
| BUG-28 | track_clear_all 清理不彻底 | 按建议修改 | ✅ 已修复 |
| BUG-29 | tracking_stop 队列延迟 | 暂不修改 | 未修改 |
| BUG-30 | work_mode 注释不一致 | 注释有误 | ✅ 已修复注释 |
| BUG-31 | tracking_point/引导跟踪空实现 | 注释明确 | ✅ 已加注释 |
| BUG-32 | 凝聚内层未跳过已用点 | 按建议修改 | ✅ 已修复 |
| BUG-33 | 起批 delta_T 未校验 | 暂不修改 | 未修改 |
| BUG-34 | tmp_track_die 空向量越界 | 按建议修改 | ✅ 已修复 |
| BUG-35 | 航迹号 500 不复用 | 按建议修改 | ✅ 已修复 |
| BUG-36 | TAS 波束关闭字段未清 | 暂不修改 | 未修改 |
| BUG-37 | 局部结构体未完整初始化 | 按建议修改 | ✅ 已修复 |
---
## 已修复项明细
### BUG-04
- 文件：`data_process.cpp`
- 修改：TAS 分支 `data_num = min(max(Point_Sum,0), 150)`，避免 `Point_Sum > 150` 时越界读取输入数组。
### BUG-05
- 文件：`track_init.cpp`
- 修改：重复航迹去重循环改为 `for (size_t i = 0; i + 1 < Track_to_start.size(); ++i)`，避免空容器时 `size()-1` 下溢。
### BUG-06
- 文件：`data_process.cpp`、`track_init.cpp`、`track_init_direct_tracking.cpp`
- 修改：
- `track_process_parameters_initial/modify` 校验 `3 <= track_start_point_num <= 9`，非法参数返回 `-1`。
- 起批转可靠航迹前增加 `Track_to_start.empty()` 和每条航迹 `size() >= 3` 防御。
- 直接跟踪的 `tmp_track_to_trust_track` 也增加 `L >= 3` 保护。
### BUG-09
- 文件：`tas_ctrl.cpp`
- 修改：
- `tas_ctrl_process` 开始时校验 `Trust_track_num_Output` 非空并清零。
- `tas_target_add` 写入输出数组前检查 `*Trust_track_num_Output < MAX_TRACK_NUM`。
### BUG-10
- 文件：`track_index_mangement.cpp`
- 修改：写入 `List[]` 前校验 `Track_Index` 在 `[1, MAX_TRACK_INDEX]`。
### BUG-11
- 文件：`track_asso_tas.cpp`
- 修改：`model_filter` 增加 `found_tas_track` 标记；找不到目标时直接返回，局部变量均初始化。
### BUG-12
- 文件：`tas_ctrl.cpp`
- 修改：`tas_beam_output` 初始化 `H_track/X_now/CPI_time`，找不到目标时 `open_flag=0` 并返回。
### BUG-14
- 文件：`track_index_mangement.h`
- 修改：`lastest_index` 声明时初始化为 `0`。
### BUG-15
- 文件：`track_asso.cpp`
- 修改：TWS 关联中 `delta_T <= 0` 时从候选列表移除该无效配对并 `continue`，不再标记点迹已使用、不刷新航迹状态。
### BUG-16
- 文件：`track_asso_tas.cpp`
- 修改：TAS 关联点循环中 `delta_T <= 0` 时跳过该点。
### BUG-17
- 文件：`track_asso_tas.cpp`
- 修改：TAS 外推时 `delta_T <= 0` 直接跳过，避免航迹时间回退和负时间预测。
### BUG-19
- 文件：`kalman.cpp`、`data_process_class_dll.h`
- 修改：`Bind_speed` 对 `prt <= 0` 或 `freq <= 0` 返回安全非零值；接口注释改为“PRI 不允许为 0”。
### BUG-21
- 文件：`track_asso.cpp`
- 修改：近程门限中 `/1000`、`/100` 改为浮点除法，避免整数除零恒不成立；保留 `d*d` 比较方式（未修改 BUG-20）。
### BUG-22
- 文件：`kalman.cpp`、`dot_coh.cpp`、`dot_coh_tas.cpp`
- 修改：
- 新增 `wrapAnglePi()`，EKF 各残差计算后对方位角分量做 `[-π,π]` 环绕。
- 点迹凝聚 `work_mode==0` 分支和 TAS 凝聚统一使用最小角度差 `delta_F`。
### BUG-23
- 文件：`track_asso.cpp`、`track_asso_tas.cpp`、`track_asso_direct_tracking.cpp`
- 修改：
- IMM 交互中 `c[0..2]` 为 0/负时钳位到 `1e-12`。
- 模型概率更新增加分母保护，分母异常时保持上一拍概率。
- 似然计算对 `det_S <= 0` 返回 0，避免 NaN。
### BUG-24
- 文件：`kalman.h`、`kalman.cpp`、`track_asso.cpp`、`track_asso_tas.cpp`、`track_asso_direct_tracking.cpp`
- 修改：
- `kalman_filter_EKF` 的 `S_filter` 由 `[2][2]` 改为 `[3][3]`。
- 调用侧使用 `Matrix3f` 和 3x3 行列式，似然归一化改为 `1/sqrt(pow(2*PI,3)*detS)`。
### BUG-26
- 文件：`track_asso.cpp`、`track_asso_tas.cpp`、`track_asso_direct_tracking.cpp`
- 修改：航向角改用 `atan2(X[4], X[1])` 并归一化到 `[0,2π)`。
### BUG-27
- 文件：`track_asso_tas.cpp`、`track_asso_direct_tracking.cpp`、`track_init.cpp`
- 修改：计算 `asin` 前对 `height/range` 做定义域钳位，`range <= 0` 时按 0 处理。
### BUG-28
- 文件：`data_process.cpp`、`dot_coh.h/cpp`、`track_asso.h/cpp`、`track_asso_tas.h/cpp`、`track_init.h/cpp`、`tas_ctrl.h/cpp`、`track_index_mangement.h/cpp`
- 修改：
- 为 `Dot_Coh`、`Track_Asso`、`Track_Asso_Tas`、`Track_Init`、`TAS_Ctrl`、`Track_Ind_Mangement` 增加 `reset()`。
- `track_clear_all()` 调用上述 reset，并恢复 `last_beam_num = INT_MAX`。
- 直接跟踪相关类也补充了 `reset()`。
### BUG-30
- 文件：`data_process_class_dll.h`
- 修改：`work_mode` 注释由“0进程 1中程 3远程”改为“0进程 1中程 2远程”。
### BUG-31
- 文件：`data_process_class_dll.h`、`data_process.cpp`、`track_init_direct_tracking.cpp`
- 修改：在 `direct_tracking_process`、`tracking_point`、直接跟踪入口处注释明确“当前接口未启用，保留空实现”。
### BUG-32
- 文件：`dot_coh.cpp`、`dot_coh_tas.cpp`
- 修改：内层凝聚比较增加对 `i` 点 `Use_Flag` 的检查，已使用点不再参与凝聚。
### BUG-34
- 文件：`track_init.cpp`、`track_init_direct_tracking.cpp`
- 修改：`tmp_track_die` 先判断 `n <= 0`，空向量直接删除。
### BUG-35
- 文件：`track_index_mangement.cpp`
- 修改：两处回绕循环由 `i < MAX_TRACK_INDEX` 改为 `i <= MAX_TRACK_INDEX`，使 500 号可复用。
### BUG-37
- 文件：`track_init.cpp`、`track_init_direct_tracking.cpp`
- 修改：`Temp_track`、`Trust_Track` 局部变量改为 `= {}` 值初始化，避免未初始化字段。
---
## 编译与运行验证
使用 **MSVC 2013 (Visual Studio 12) x86** 实际编译：
| 配置 | 结果 |
|---|---|
| X256_PS Release | ✅ 编译链接通过 |
| X256_MS Release | ✅ 编译链接通过 |
| X256_PS Debug | ✅ 编译链接通过 |
| MSVC `/W4` Release | ✅ 编译通过，未再出现 C4700/C4701 未初始化变量告警 |
另编写临时宿主程序验证 DLL：
- 初始化 `RadarPara`，调用 `track_process_parameters_initial` 成功。
- 调用 `track_process`，返回 `1`，输出计数正常。
- 工厂创建/销毁流程正常。
> 说明：当前构建仍会输出原有代码的 C4244 转换告警、C4018 有符号/无符号比较告警、C4819 编码告警，均非本次修复引入，不影响链接和运行。
BUG_REPORT.md
+276
View File
@@ -0,0 +1,276 @@
# 雷达数据处理 DLL 逻辑 BUG 分析报告
分析范围：`data_process_class_dll/` 下全部源码（不含 `Eigen/`），以迁移后的当前代码行号为准。
严重级别定义：
- **P0**：可能导致崩溃、越界读写、内存破坏或长时间运行内存泄漏，建议优先修复。
- **P1**：在常见异常时序/边界输入下会出错，或属于明显算法逻辑错误。
- **P2**：健壮性、数值稳定性、状态一致性、功能缺失等问题。
- **P3**：代码质量/可维护性问题。
---
## 1. 内存与生命周期
### BUG-01 [P0] 基类没有虚析构函数，工厂按基类指针 delete 派生对象
- 位置：`data_process_class_dll.h:168`、`data_process_class_dll.cpp:25-32`
- 说明：`Data_process_class_dll` 没有声明虚析构函数，而 `Data_Process` 内部包含多个 `std::vector` 和若干成员对象。`Data_Process_Factory::Destroy()` 执行 `delete p` 时静态类型是基类指针，只会调用基类析构函数，派生类成员（`Data_buffer`、`trust_track`、`temp_track`、Eigen 相关对象等）的析构不会执行，属于未定义行为并造成内存泄漏。
- 建议：在基类中增加 `virtual ~Data_process_class_dll() {}`；同时让工厂支持重复销毁、销毁后返回 nullptr。
- 暂不修复
### BUG-02 [P1] `Hight_smooth` 高度平滑缓存只增不减，长时间运行内存持续增长
- 位置：`track_asso.cpp:890`、`track_asso_tas.cpp:722`、`track_asso_direct_tracking.cpp:639`
- 说明：每次高度更新都执行 `Hight_smooth.push_back(...)`，从未裁剪或清空。航迹存活时间越长，该 vector 越大；500 条航迹长时间运行时内存会持续增长。
- 建议：仅保留最近 `height_win_length` 个高度值（如 `resize`/`erase(begin)` 后再 push），或改用固定长度 `std::deque`；航迹消亡时随结构体释放。
- 暂不修复
### BUG-03 [P2] 工厂单例创建/销毁非线程安全
- 位置：`data_process_class_dll.cpp:15-32`
- 说明：`GetB()` 和 `Destroy()` 对静态指针 `p` 无任何同步。若宿主在多线程环境调用，可能创建两个实例（泄漏一个）或对同一对象重复销毁。
- 建议：用 C++11 `static Data_Process instance;` 返回地址，或对工厂方法加锁；明确 DLL 接口的线程模型。
- 暂不修复
---
## 2. 数组/向量越界
### BUG-04 [P0] TAS 输入点迹未限制 `Point_Sum <= 150`
- 位置：`data_process.cpp:66`
- 说明：TWS 分支使用 `min(Point_Sum, 150)`，但 TAS 分支直接 `data_num = Data_Input[0].Point_Sum` 并循环读取 `Data_Input[i]`。当协议传入 `Point_Sum > 150` 时，会越界读取 `Data_Input[150]`。
- 建议：与 TWS 分支一致，使用 `data_num = min(max(Point_Sum,0), 150)`，并校验 `Point_Sum >= 0`。
- 按建议修复
### BUG-05 [P0] `Track_to_start.size()-1` 在空容器时下溢导致越界
- 位置：`track_init.cpp:534`
- 说明：与已发现示例一致。`size()` 返回 `size_t`，空容器减 1 得到极大值，随后 `Track_to_start[i]` 越界。
- 建议：`if (Track_to_start.empty()) return;`，或改为 `for (size_t i = 0; i + 1 < Track_to_start.size(); ++i)`。
- 按建议修复，改为 `for (size_t i = 0; i + 1 < Track_to_start.size(); ++i)`
### BUG-06 [P0] `track_start_point_num` 未校验，取值 0/1/2 或大于 9 时多处越界
- 位置：`track_init.cpp:533,544-545,588-594`、`track_init_direct_tracking.cpp:316-322`
- 说明：重复航迹比较固定访问 `Track_to_start[i][1]`、`[2]`，三点初始化访问 `[L-3]/[L-2]/[L-1]`。该参数由外部 `RadarPara` 传入，若未初始化或配置为 0/1/2，会出现负下标或越界；若大于 9，`tmp_track_die` 会在 `n>=10` 时删除临时航迹，逻辑也无法起批。
- 建议：在 `track_process_parameters_initial/modify` 中校验 `3 <= track_start_point_num <= 9`；使用 `Track_to_start[i].size()` 作为实际长度并在访问前检查。
- 按建议修复
### BUG-07 [P0] 禁止区域个数未限制在 30 以内，外部配置过大时数组越界
- 位置：`track_init.cpp:711`（`track_prohibite_area_num`）、`tas_ctrl.cpp:123`（`TAS_prohibite_area_num`）
- 说明：循环上界直接使用外部传入的计数，而对应数组固定为 `[30]`。配置大于 30 时越界读。
- 建议：循环上界改为 `min(count, 30)`，并在参数初始化/修改时拒绝非法计数或截断。
- 暂不修复
### BUG-08 [P1] 消亡航迹号输出无数组容量检查
- 位置：`track_die.cpp:24`、`track_die_tas.cpp:26`
- 说明：`Track_die_Index_Output[*Track_die_num_Output-1] = ...` 不检查数组容量。正常流量下最多 500 条航迹，与 `MAX_TRACK_NUM` 一致，但接口没有把容量传入，一旦宿主传入较小数组、或计数被异常修改，就会越界写。
- 建议：接口增加 `die_array_capacity` 参数，或内部保证 `*Track_die_num_Output < MAX_TRACK_NUM` 后再写。
- 暂不修改
### BUG-09 [P1] `Beam_Ctrl` 路径中输出计数未初始化/无上界，可能越界写航迹输出数组
- 位置：`data_process.cpp:193-198`、`tas_ctrl.cpp:74-78`
- 说明：`Beam_Ctrl()` 直接使用宿主传入的 `Trust_track_num_Output`，而 `tas_ctrl_process` 不会先清零，`tas_target_add` 会基于旧值自增并写 `Trust_Track_Output[*Trust_track_num_Output-1]`。若调用方未清零或旧值接近 `MAX_TRACK_NUM`，会越界写。
- 建议：`tas_ctrl_process` 内部保存 `*count = 0` 或在每次写入前检查 `*count < MAX_TRACK_NUM`；同时校验指针非空。
- 按建议修改
### BUG-10 [P1] 航迹号直接作为数组下标，未校验范围
- 位置：`track_index_mangement.cpp:29`
- 说明：`List[(*trust_track)[i].Track_Index-1] = 1`，若航迹号不在 `[1, MAX_TRACK_INDEX]` 内（异常数据、内存损坏、外部修改），立即越界。
- 建议：写前检查 `Track_Index >= 1 && Track_Index <= MAX_TRACK_INDEX`，异常航迹号返回错误或跳过。
- 按建议修改
---
## 3. 未初始化变量
### BUG-11 [P1] `Track_Asso_Tas::model_filter` 在找不到 TAS 目标时使用未初始化变量
- 位置：`track_asso_tas.cpp:228-232`，随后在 `271/276/280/282` 等使用
- 说明：`X1/X2/X3/P1/P2/P3/T_track/v_track/r_track/h_track` 只在 `Track_Index == tas_track_idx` 时赋值。若 `tas_track_idx` 不存在（例如目标已被消亡、主程序传入失效批号），后续仍用这些未初始化值计算 IMM、距离门限和外推，结果不可预测。MSVC `/W4` 已报 C4701。
- 建议：函数开头初始化这些变量，并在找不到目标时直接 return；上层也应处理“TAS 目标不存在”的返回值。
- 按建议修改
### BUG-12 [P1] `tas_beam_output` 在队列目标不在航迹表中时使用未初始化变量
- 位置：`tas_ctrl.cpp:242-271`
- 说明：`H_track`、`X_now[]` 只在找到匹配航迹时赋值；若 `track_clear_all()` 后队列未清空、或目标已被删除而队列未同步，循环找不到目标，随后 `asin(H_track/range)`、`X_now[...]` 使用未初始化数据。Cppcheck 和 MSVC `/W4` 均报 C4701。
- 建议：找不到目标时立即 `open_flag=0` 并 return；变量声明时初始化。
- 按建议修改
### BUG-13 [P2] `Data_Process::Work_Parameter` 及若干成员在构造后未初始化
- 位置：`data_process.h:28-31,78-95`
- 说明：构造函数为空，`Work_Parameter`、`Beam_num`、`data_num`、`TAS_track_idx` 等未初始化。若宿主在调用 `track_process_parameters_initial` 前就调用 `data_preprocess/track_process/Beam_Ctrl`，`Work_Parameter.track_start_point_num`、`Sys_delay`、`V_MIN/V_MAX` 等是垃圾值，可能导致起批越界、除零或异常门限。
- 建议：构造函数中对 `Work_Parameter` 进行 `memset`/值初始化并设置安全默认参数；在处理函数入口检查“参数是否已初始化”。
- 暂不修复
### BUG-14 [P3] `Track_Ind_Mangement::lastest_index` 未初始化
- 位置：`track_index_mangement.h:17`、`track_index_mangement.cpp:33`
- 说明：只有空航迹表分支会赋值为 1；如果首次调用时航迹表非空，就会读取未初始化的 `lastest_index`。
- 建议：声明为 `int lastest_index = 0;` 或增加构造函数初始化。
- 按建议修改
---
## 4. 时间戳/时序处理
### BUG-15 [P1] TWS 关联在 `delta_T <= 0` 时仍把点迹标记为已关联并刷新航迹状态
- 位置：`track_asso.cpp:610-691`
- 说明：滤波和航迹信息更新在 `if (delta_T > 0)` 内，但 `Extrapolate_round=0`、`point_flag=1`、`associate_point_number++`、点迹 `Use_Flag=1` 都在 if 之外。重复/乱序时间戳的点仍会“占用”点迹、让航迹看起来已更新，实际状态未更新。
- 建议：`delta_T <= 0` 时直接跳过该关联候选（或作为无效量测处理），不要标记点迹已使用、不要刷新航迹新鲜度。
- 按建议修改
### BUG-16 [P1] TAS 关联完全没有 `delta_T > 0` 检查
- 位置：`track_asso_tas.cpp:271-335,385-452`
- 说明：TAS 路径计算 `delta_T` 后直接进入统计距离和滤波，即使 `delta_T <= 0` 也会生成 F/Q 并更新航迹，可能把航迹时间更新到过去。
- 建议：与 TWS 一致，只有 `delta_T > 0` 才允许关联；否则跳过该点。
- 按建议修改
### BUG-17 [P1] TAS 外推使用未校验的 `latest_timestamp - T_track`，负时间差导致反向预测
- 位置：`track_asso_tas.cpp:483-506`
- 说明：若 `latest_timestamp < T_track`（乱序/重复时间戳），`delta_T` 为负，`T_track += delta_T*1000` 会回退航迹时间，IMM F/Q 也按负时间生成。
- 建议：`delta_T = max(0, latest_timestamp - T_track)/1000.0`；若为 0 则直接返回或保持原状态。
- 按建议修改
### BUG-18 [P1] 卡尔曼初始化及统计距离函数对零/负时间差没有保护
- 位置：`kalman.cpp:13-46,126-130,158-168`；调用点 `track_init.cpp:275,450,593-594`、`track_init_direct_tracking.cpp:135,271,321-322`
- 说明：两点/三点初始化直接除以 `T/T1/T2`。同一 CPI 重复点、时间戳相等或乱序会产生除零、inf/NaN，随后污染航迹协方差和模型概率。
- 建议：调用前统一校验时间差大于最小阈值（如 >0 或 >1 ms）；`kalman_filter_init_2dots/3dots` 内部对非法时间返回错误。
- 暂不修改
### BUG-19 [P1] `Bind_speed` 对 `prt == 0` 无保护，而接口说明 PRI 可给 0
- 位置：`kalman.cpp:766-770`、`data_process_class_dll.h:29`
- 说明：`return 150000.0/(freq*prt)`，当 `PRI=0` 时除零；结果传给 `Round()` 会把 inf/NaN 转换为未定义整型。
- 建议：`prt <= 0` 时返回固定安全值或直接返回无效距离；统一约定 PRI 单位与默认值。
- 按建议修改，同时修改接口说明：PRI不可为0
---
## 5. 关联门限与滤波算法逻辑
### BUG-20 [P1] 统计距离 d 已经是平方形式，门限中又平方了一次
- 位置：`track_asso.cpp:544-546`、`track_asso_tas.cpp:335`、`track_asso_direct_tracking.cpp:286`、`track_init.cpp:221`
- 说明：`d_cal_EKF` 返回的是 `delta_z^T S^{-1} delta_z`（马氏距离平方），后续门限却写成 `d*d < THRESHOLD*THRESHOLD`。例如阈值 3 时本意是 `d < 9`，实际变成 `d < 3`，波门明显偏小。
- 建议：统一改为 `d < TRACK_START_THRESHOLD*TRACK_START_THRESHOLD` / `d < ASSO_THORD*ASSO_THORD`。
- 暂不修改
### BUG-21 [P1] 近程模型 3 门限因整数除法恒为 0
- 位置：`track_asso.cpp:544-545`
- 说明：`ASSO_THORD` 是 int 宏，`ASSO_THORD*ASSO_THORD/1000` 和 `/100` 按整数计算，结果均为 0，导致 `d3*d3 < 0` 永远不成立；近距离下模型 3 实际被禁用。
- 建议：写为 `ASSO_THORD*ASSO_THORD/1000.0`、`/100.0`，同时按 BUG-20 修正平方关系。
- 按建议修改，但不修改BUG-20
### BUG-22 [P1] EKF 方位角残差未按 0/2π 环绕处理
- 位置：`kalman.cpp:265-298,457-492,642-680`；凝聚 `dot_coh.cpp:35,44`（`work_mode==0` 分支）、`dot_coh_tas.cpp:33,42`
- 说明：预测方位被归一化到 `[0,2π)`，但量测方位未归一化，`delta_z = Z_mea - Z_pred` 未做 ±π 环绕。目标跨正北时残差会接近 2π，导致错误拒绝/错误滤波。凝聚中 `work_mode==0` 和 TAS 凝聚也直接 `fabs(angle)`，未处理 360° 环绕。
- 建议：方位差统一按 `wrapToPi()` 处理；`work_mode==0` 与 TAS 凝聚复用同一环绕角差函数。
- 按建议修改
### BUG-23 [P1] IMM 模型概率计算缺少零分母/奇异矩阵保护
- 位置：`track_asso.cpp:157-165,627-647`、`track_asso_tas.cpp:122-130,406-431`、`track_asso_direct_tracking.cpp:95-103,352-374`
- 说明：`c[0..2]`、`Possibility1*c[0]+...`、`det_S` 都可能为 0 或负；`1/sqrt(2*PI*det_S)` 对负/零行列式产生 NaN。一旦概率变 NaN，后续 `model_output` 会把整条航迹状态污染。
- 建议：计算前检查 `det_S > eps`、分母 > eps；异常时保持上一拍模型概率或回退为等概率 `{1/3,1/3,1/3}`。
- 按建议修改
### BUG-24 [P2] EKF 似然只取 3x3 新息协方差左上角 2x2 的行列式
- 位置：`kalman.cpp:515-519`（S 为 3x3，但输出只保存 2x2）；调用处 `track_asso.cpp:627-633`、`track_asso_tas.cpp:406-412`、`track_asso_direct_tracking.cpp:352-358`
- 说明：EKF 量测为距离/方位/径向速度三维，新息协方差 S 是 3x3，但接口 `S_filter[2][2]` 和似然计算只使用二维子块，模型似然不完整。
- 建议：将接口改为 3x3，并采用完整 3 维高斯归一化因子 `1/sqrt(pow(2*PI,3)*detS)`（若只比较相对大小，也至少应保持三个模型使用相同维数）。
- 按建议修改
### BUG-25 [P1] TWS 航迹关联/输出没有排除 TAS 航迹
- 位置：`track_asso.cpp:65-133`（输出）、`141-228`（交互
）、`414-570`（滤波）
- 说明：原代码中有 `// if manual_tracking_flag==0` 的过滤逻辑但被注释掉。当前 TWS 处理会遍历并更新所有航迹，包括 `Track_Mode==1` 的 TAS 航迹；TWS 输出循环也会把 TAS 航迹当作 `point_type=0` 输出，造成 TAS 航迹被 TWS 点迹错误更新和重复输出。
- 建议：TWS 的交互、关联、输出统一跳过 `Track_Mode == 1`（或 `manual_tracking_flag == 1`）的航迹；TAS 目标只在 TAS 流程中处理。
- 暂不处理
### BUG-26 [P2] 输出航向角使用 `atan(y/x)` 而不是 `atan2`
- 位置：`track_asso.cpp:100`、`track_asso_tas.cpp:66`、`track_asso_direct_tracking.cpp:59`
- 说明：当 `vx == 0` 时除法结果接近 ±inf，现有象限修正逻辑不完整，某些象限会输出负角度或 90° 偏差。
- 建议：统一使用 `atan2(X[4], X[1])` 并归一化到 `[0,2π)`。
- 按建议修改
### BUG-27 [P2] `asin(height/range)` 缺少定义域和零距离保护
- 位置：`track_asso_tas.cpp:54`、`track_asso_direct_tracking.cpp:48`、`track_init.cpp:646,673`
- 说明：`range` 为 0 或 `height > range` 时，`asin` 参数超出 `[-1,1]` 产生 NaN，并输出到 `Track.Elevation`。
- 建议：计算前钳位 `h/r` 到 `[-1,1]`，并对 `r <= eps` 特殊处理。
- 按建议修改
---
## 6. 状态清理与接口一致性
### BUG-28 [P1] `track_clear_all` 清理不彻底，重连后可能输出幽灵航迹/幽灵波束
- 位置：`data_process.cpp:219-229`
- 说明：只清空 6 个顶层 vector，未清理：
- `Dot_Coh::data_input_buff`（滑窗凝聚缓存）；
- `TAS_Ctrl::tas_target_queue` 和 `tas_target_num`；
- `last_beam_num`（扫描圈判断）；
- `Track_Ind_Mangement::lastest_index`；
- 各关联类的 `point_process` 成员。
清空后若立即调用 `Beam_Ctrl`，TAS 队列仍认为有目标，但 `trust_track` 已空，会触发 BUG-12 的未初始化路径并输出错误波束；下一次 TWS 处理也可能输出清空前的缓存点迹。
- 建议：为 `Dot_Coh`、`TAS_Ctrl`、`Track_Ind_Mangement` 增加 `reset()`，`track_clear_all` 调用所有 reset，并恢复 `last_beam_num=INT_MAX`。
- 按建议修改
### BUG-29 [P2] `tracking_stop` 后 TAS 队列要到下一次 `Beam_Ctrl` 才移除
- 位置：`data_process.cpp:260-270`、`tas_ctrl.cpp:138-162`
- 说明：`tracking_stop` 只清标志位和 `Track_Mode`，不会立即清 `tas_target_queue`。在调用 `Beam_Ctrl` 前，队列仍会输出该目标的跟踪波束。
- 建议：`tracking_stop` 内同步删除 TAS 队列项并更新 `tas_target_num`，或明确接口时序并文档化。
- 暂不修改
### BUG-30 [P2] 工作模式枚举与代码分支不一致
- 位置：`data_process_class_dll.h:140`（注释：0 进程、1 中程、3 远程）、`track_asso.cpp:729-744`（按 0/1/2/else 分支）
- 说明：注释定义远程模式为 3，但代码按 `work_mode==2` 使用远距数据率；当外部按注释传 3 时，会落入 else 使用近程数据率 `DATA_RATE_SHORT`。
- 建议：统一枚举定义，或代码改为 `work_mode==3` 使用 `DATA_RATE_FAR`。
- 注释有误，修改注释为：0 进程、1 中程、2 远程
### BUG-31 [P2] `tracking_point` 和引导跟踪处理是空实现
- 位置：`data_process.cpp:282-286`、`data_process_class_dll.h:200-213`、`track_init_direct_tracking.cpp:11-21`
- 说明：`tracking_point` 直接返回 0；`Data_Process` 没有重写 `direct_tracking_process`，基类默认返回 0；`Track_Init_Direct_Tracking::track_init_process_logic` 也是空函数。若接口已被主程序调用，则相关功能实际未生效。
- 建议：确认这两个接口是否已废弃；若仍需要，补齐实现或至少在文档中明确为未实现并返回错误码。
- 在注释中明确接口未启用，保留空实现
---
## 7. 其他逻辑与健壮性
### BUG-32 [P2] 凝聚内层循环没有跳过已标记使用的点
- 位置：`dot_coh.cpp:25,148`、`dot_coh_tas.cpp:25`
- 说明：内层只检查当前基准点 `loop_of_point` 的 `Use_Flag`，没有检查被比较点 `i` 的 `Use_Flag`。已被凝聚掉的点仍可参与后续比较，甚至反过来把高幅度基准点标记掉。
- 建议：内层同样判断 `(*data_input)[i].Use_Flag != 1`（以及 `data_tmp[i]`）。
- 按建议修改
### BUG-33 [P2] 起批/临时航迹关联未校验 `delta_T > 0`，重复时间戳可能产生非法卡尔曼初始化
- 位置：`track_init.cpp:189,381,450`、`track_init_direct_tracking.cpp:67,221,271`
- 说明：点迹与临时航迹、点迹与航迹头的关联均使用 `T_point - T_track_head`，未要求正时间差。`kalman_filter_init_2dots` 遇到 0/负 T 会产生除零。
- 建议：在关联条件中显式要求 `T_point > T_track_head`，且时间差需大于最小步长。
- 暂不修改
### BUG-34 [P2] 临时航迹消亡函数在空向量时直接取 `[n-1]`
- 位置：`track_init.cpp:694-695`、`track_init_direct_tracking.cpp:417-418`
- 说明：`int n = (*Iter).size();` 后立即 `(*Iter)[n-1]`。正常流程每条临时航迹至少 1 个点，但没有防御；一旦出现空内层向量，`n-1` 为负并越界。
- 建议：先判断 `n > 0`，空向量直接删除。
- 按建议修改
### BUG-35 [P3] 航迹号复用逻辑漏掉 `MAX_TRACK_INDEX`
- 位置：`track_index_mangement.cpp:44,56`
- 说明：回绕查找循环写作 `i < MAX_TRACK_INDEX`，因此 500 号航迹永远不会被复用；与第一段 `i <= MAX_TRACK_INDEX` 不一致。
- 建议：两处回绕循环改为 `i <= MAX_TRACK_INDEX`。
- 按建议修改
### BUG-36 [P3] TAS 波束关闭时只清 `open_flag`，其他字段保留旧值
- 位置：`tas_ctrl.cpp:277-284`
- 说明：当 `tas_target_queue[0].empty_flag==0` 时，仅设置 `Tracking_beam->open_flag=0`，`Range/Azi/Elev/type/TAS_track_index` 保留上一拍内容。主程序若只按 `open_flag` 判断则无问题，但字段语义不清晰。
- 建议：关闭时同时清零 `type/Range/Azi/Elev/TAS_track_index`。
- 暂不修改
### BUG-37 [P3] 部分结构体局部变量未完整初始化
- 位置：`track_init.cpp:80,598`、`track_init_direct_tracking.cpp:325`
- 说明：`Temp_track temp_track_tmp`、`Trust_Track trust_track_tmp` 的 `P` 矩阵等字段未显式初始化。当前流程部分字段未被读取，但依赖调用顺序；后续维护容易读到垃圾值。
- 建议：使用值初始化 `Temp_track tmp = {};` 或为结构体提供构造函数/`init()` 统一初始化所有字段。
- 按建议修改
---
## 建议修复顺序
1. 先修 P0：BUG-01、BUG-04、BUG-05、BUG-06、BUG-07、BUG-11、BUG-12。
2. 再修 P1 时间与关联逻辑：BUG-15~BUG-23、BUG-25、BUG-28。
3. 最后处理数值稳定性、状态一致性和未启用功能：BUG-24、BUG-26~BUG-37。
> 说明：`track_asso_direct_tracking.cpp` 和 `track_init_direct_tracking.cpp` 当前未加入 CMake 构建（与旧 .pro 一致），其中问题与主流程同类问题重复，修复主流程时可同步修改或暂缓。
CHANGELOG.md
+56
View File
@@ -0,0 +1,56 @@
# Changelog
本项目的所有重要变更记录于此文件。
格式遵循 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.1.0/)，
版本号遵循 [语义化版本（SemVer）](https://semver.org/lang/zh-CN/)。
## [Unreleased]
### Added
- 新增 CHANGELOG.md，采用 Keep a Changelog 格式记录项目变更历史。
- `RadarPara` 结构体新增 `DATA_RATE_TAS`（TAS 模式数据率）字段，由 DLL 调用者通过 `track_process_parameters_initial()` 输入。
### Changed
- TAS 波束控制增加数据率门控：`Beam_Ctrl()` 仅在队首目标航迹时间 `T_track` 与最新时间戳 `latest_timestamp` 的差值大于 `1 / DATA_RATE_TAS` 秒时输出 TAS 跟踪波束，使 TAS 目标数据率不再随波束时间（Beam_Ctrl 调用频率）变化；队列轮转逻辑保持不变。
- 波束门控使用 `Work_Parameter.DATA_RATE_TAS`（运行时参数）而非 `parameters.h` 中的 `DATA_RATE_TAS` 宏；参数 ≤ 0 时不做门控，保持原输出行为。
## [1.5.5] - 2026-08-27
初始版本记录：汇总仓库现有功能与自 2022 年以来的主要变更（依据 git 提交历史与 README.md 整理）。
### Added
- TWS/TAS 双通道雷达数据处理：输入点迹预处理、两帧滑窗点迹凝聚、逻辑法航迹起始（3～9 点起批，含屏蔽区）、IMM + EKF 航迹滤波、最近邻点航关联、航迹外推/消亡/航迹号管理、TAS 波束控制输出。
- 支持相扫（X256_PS）与机扫（X256_MS）两种扫描体制，通过 `RADAR_SCAN_MODE` / 编译宏配置切换。
- 适配四面阵机扫跟踪模式；机扫跟踪时增加高度门限判断。
- 输入点迹、输出航迹的 CPI 时间与 GNSS 时间改为 64 位整型（毫秒）。
- 增加航迹清空功能，解决重连时大量航迹乱窜的问题。
- TWS 输出增加高度平滑处理。
- TWS 点航关联增加俯仰门限与点航距离门限，限制大幅度跳变或突跳到远距离的点迹关联。
- 航迹起始增加屏蔽区域。
- 新增 README.md、BUG_REPORT.md、BUG_FIX_REPORT.md 等文档。
### Changed
- 工程由 Qt/qmake 迁移为 VS Code + CMake 构建，编译器保持 MSVC 2013 x86 不变。
- 机扫与相扫程序合并，通过宏定义配置切换。
- TAS 航迹外推时间间隔改为按波束时间计算。
- 扫描一圈完成的判断逻辑改为用“波位号变小”判断。
- 点迹凝聚角度约束放宽至 4 度；凝聚条件按近程/中程模式区分。
- 去掉自动转 TAS 功能，仅支持手动转 TAS。
- 去掉 1 km 以内航迹起批的 20 dB 信噪比门限。
- 统一代码缩进格式。
### Fixed
- 修复若干逻辑 BUG（数组越界/下溢、局部变量未初始化、时间差无效、方位角 ±π 环绕、IMM 概率奇异、输出数组容量越界等），明细见 `BUG_FIX_REPORT.md`。
- 修复 TAS 外推时间差可能为无效值的问题。
- 修复航迹起始时未输出跟踪类型、可靠航迹手动转跟踪标志未清零的问题。
- 修复量测噪声协方差矩阵 R 赋值错误、数据预处理波位号判断规则、点迹数量上限、雅可比矩阵取值、起批负索引等问题。
### Removed
- 移除 `requirements.md`、`CLAUDE.md`、Makefile 系列、Qt 工程用户文件、内置 Eigen 3.3.7 冗余文件及「航迹点迹区分区说明」等不必要文件。
CLAUDE.md
-134
View File
@@ -1,134 +0,0 @@
# CLAUDE.md
This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
## 项目概述
2003 雷达数据处理动态链接库。实现航迹跟踪处理、TAS/TWS 跟踪控制。将原始雷达点迹数据转换为稳定的目标航迹输出。
- **开发环境**: Qt 5.7 + MSVC 2013, C++
- **编译产物**: `data_process_class_dll.dll`（动态链接库）
- **线性代数**: 使用 Eigen 3.3.7 (`Eigen/Dense`)
## 构建
项目使用 qmake 生成 Makefile，然后通过 nmake 编译。
```bash
# 生成 Makefile（在项目根目录执行）
qmake.exe -spec win32-msvc2013 -o Makefile data_process_class_dll\data_process_class_dll.pro
# 编译 Release 版本
nmake release
# 编译 Debug 版本
nmake debug
# 清理
nmake clean
```
已生成的 Makefile 位于根目录：`Makefile`、`Makefile.Debug`、`Makefile.Release`。构建输出在 `release/` 和 `debug/` 目录。
## 架构
### 设计模式
- **接口/工厂模式**：`Data_process_class_dll` 是抽象基类（定义在 `data_process_class_dll.h`），`Data_Process` 是具体实现（`data_process.h/cpp`）。外部通过 `Data_Process_Factory::GetB()` 获取实例，`Destroy()` 销毁。
- 所有外部接口都是虚函数，主程序只需要链接 DLL 并调用这些接口。
### 数据处理三模式
`data_preprocess()` 根据输入点迹类型返回处理模式：
| 返回值 | 模式 | 条件 |
|--------|------|------|
| `0` | 无数据 | 既非 TWS 也非 TAS |
| `1` | TWS 航迹处理 | `point_type == 0` 且波位号 == 16 |
| `2` | TWS 蓄数据 | `point_type == 0` 但波位号 != 16（继续缓存） |
| `3` | TAS 处理 | `point_type == 1` |
### TWS 处理流水线（model=1）
```
data_preprocess() → 缓存点迹到 Data_buffer
→ dot_coh.dot_coh_process_buff() 点迹凝聚（滑窗聚合）
→ track_asso.track_asso_process() 航迹关联（IMM 卡尔曼滤波更新已有航迹）
→ track_die.track_die_process() 航迹消亡（清除超时未更新的航迹）
→ track_init.track_init_process_logic() 航迹起始（从未关联点迹创建新航迹，逻辑法）
```
### TAS 处理流水线（model=3）
```
data_preprocess() → 缓存点迹到 Data_buffer_tas
→ dot_coh_tas.dot_coh_tas_process() TAS 点迹凝聚
→ track_asso_tas.track_asso_process_tas() TAS 航迹关联
→ track_die_tas.track_die_process_tas() TAS 航迹消亡
```
### 核心算法模块
| 文件 | 职责 |
|------|------|
| `kalman.cpp/h` | 卡尔曼滤波（两点/三点初始化）、EKF（含多普勒）、IMM 统计距离计算 |
| `track_asso.cpp/h` | TWS 航迹关联：IMM 模型交互→三个子模型滤波→模型输出。3 个 Singer 模型（不同 Q 值应对不同机动性） |
| `track_asso_tas.cpp/h` | TAS 航迹关联（独立实现，因 TAS 数据率不同） |
| `track_init.cpp/h` | 逻辑法航迹起始：点迹→航迹头关联→临时航迹转可靠航迹（需满足角度/波门条件） |
| `track_init_direct_tracking.cpp/h` | 引导跟踪航迹起始 |
| `dot_coh.cpp/h` | TWS 点迹凝聚：滑窗方式在距离-方位-速度维聚合相近点迹 |
| `dot_coh_tas.cpp/h` | TAS 点迹凝聚 |
| `track_die.cpp/h` | TWS 航迹消亡：持续外推超过阈值（4 圈）则消亡 |
| `track_die_tas.cpp/h` | TAS 航迹消亡（5 圈阈值） |
| `tas_ctrl.cpp/h` | TAS 波束调度：管理 TAS 目标队列（最多 4 个），自动/手动开启和退出 |
| `track_index_mangement.cpp/h` | 航迹号分配管理 |
| `coor_trans.cpp/h` | 坐标转换（雷达球坐标系 ↔ 直角坐标系） |
### 关键数据结构
- **`DataRev`**（`data_process_class_dll.h`）— 输入：雷达原始点迹，含距离/方位/俯仰/速度/幅度/SNR/RCS/波位等
- **`PointRecv`**（`struct.h`）— 内部：预处理后的点迹，增加高度（由距离×sin(俯仰)计算）、使用标志
- **`Trust_Track`**（`struct.h`）— 内部：可靠航迹。含 IMM 全状态：X[6]/P[6][6] 总估计 + 三个子模型的 X1/P1、X2/P2、X3/P3 + 模型概率 u[3]
- **`Temp_track`**（`struct.h`）— 内部：临时航迹。简化卡尔曼 X[4]/P[4][4]（无加速度分量）
- **`Track`**（`data_process_class_dll.h`）— 输出：航迹信息（位置/速度/预测值/航迹号/跟踪模式等），二维数组 `[MAX_TRACK_NUM][10]` 每条航迹最多 10 个历史点
- **`RadarPara`**（`data_process_class_dll.h`）— 外部配置：雷达参数、跟踪门限、IMM 机动参数、禁止区域
- **`TrackingBeam`**（`data_process_class_dll.h`）— 输出：TAS 波束调度指令
### IMM 模型说明
TWS 航迹关联使用 3 模型 IMM（Interacting Multiple Model）处理目标机动：
- **Model 1**: Singer 模型，低过程噪声 Q（`Model1_Q_fast/slow`），适合匀速目标
- **Model 2**: Singer 模型，中过程噪声 Q（`Model2_Q_fast/slow`），适合中等机动
- **Model 3**: Singer 模型，高过程噪声 Q（`Model3_Q_fast/slow`），适合强机动
模型转移概率矩阵 `Pt[3][3]` 定义在 `Track_Asso` 类中。每个 CPI 周期执行：模型交互 → 各子模型卡尔曼预测+更新 → 模型概率更新 → 加权融合输出。
### 航迹区概念
按方位角将 360° 划分为 9 个航迹区（每个 40°），航迹按区组织以减少计算量。点迹区类似划分（每个区含 6 个波位）。相关参数在 `parameters.h` 中（当前版本大部分被注释，实际通过 `RadarPara` 动态配置）。
## 外部接口调用顺序
```
1. track_process_parameters_initial() — 初始化雷达参数
2. 每帧循环：
a. data_preprocess() — 输入原始点迹
b. 根据返回值调用 track_process() — 执行 TWS 或 TAS 处理
c. Beam_Ctrl() — TAS 波束调度
3. tracking_start() / track_delete() — 手动控制（按需）
4. track_clear_all() — 清空所有航迹
5. Data_Process_Factory::Destroy() — 销毁实例
```
## 参数配置
关键可调参数（通过 `RadarPara` 传入或 `parameters.h` 定义）：
- `track_start_point_num` / `track_start_threshold` — 起航所需点数和波门大小
- `track_asso_threshold` — TWS 关联波门（统计距离阈值）
- `track_asso_threshold_tas` — TAS 关联波门
- `TRACK_DIE_ROUND` (4) / `TRACK_DIE_ROUND_TAS` (5) — 航迹消亡圈数
- `DOT_COH_RANGE` / `DOT_COH_V` / `DOT_COH_AZI` — 凝聚门限（距离/速度/方位）
- `TAS_QUEUE_LENGTH` (4) / `MAX_TAS_NUM` (4) — TAS 队列长度和最大目标数
- `Model1/2/3_Q_fast/slow` — IMM Singer 模型过程噪声
CMakeLists.txt
+100
View File
@@ -0,0 +1,100 @@
cmake_minimum_required(VERSION 3.10)
# 雷达数据处理动态链接库
# 开发环境已由 Qt/qmake 迁移到 VS Code + CMake。
# 编译器保持为 Microsoft Visual C++ Compiler 12.0 (x86)。
project(data_process_class_dll LANGUAGES CXX)
# 扫描模式：
# PHASE_SCANNING -> 相扫雷达（X256_PS，原 Qt 工程默认激活配置）
# MECHANICAL_SCANNING -> 机扫雷达（X256_MS）
# 用法：cmake -S . -B build -DRADAR_SCAN_MODE=PHASE_SCANNING
set(RADAR_SCAN_MODE "PHASE_SCANNING" CACHE STRING "Radar scan mode (PHASE_SCANNING or MECHANICAL_SCANNING)")
set_property(CACHE RADAR_SCAN_MODE PROPERTY STRINGS PHASE_SCANNING MECHANICAL_SCANNING)
if(NOT RADAR_SCAN_MODE STREQUAL "PHASE_SCANNING" AND NOT RADAR_SCAN_MODE STREQUAL "MECHANICAL_SCANNING")
message(FATAL_ERROR "RADAR_SCAN_MODE 必须为 PHASE_SCANNING 或 MECHANICAL_SCANNING，当前值：${RADAR_SCAN_MODE}")
endif()
# 导出编译命令，便于 VS Code C/C++ 插件 IntelliSense 使用。
# Visual Studio 生成器不支持该选项，因此仅对 Makefile/Ninja 生成器开启。
if(NOT CMAKE_GENERATOR MATCHES "Visual Studio")
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
endif()
set(SOURCES
data_process_class_dll/data_process_class_dll.cpp
data_process_class_dll/data_process.cpp
data_process_class_dll/dot_coh.cpp
data_process_class_dll/kalman.cpp
data_process_class_dll/coor_trans.cpp
data_process_class_dll/track_asso.cpp
data_process_class_dll/track_init.cpp
data_process_class_dll/track_index_mangement.cpp
data_process_class_dll/tas_ctrl.cpp
data_process_class_dll/track_die.cpp
data_process_class_dll/dot_coh_tas.cpp
data_process_class_dll/track_asso_tas.cpp
data_process_class_dll/track_init_direct_tracking.cpp
data_process_class_dll/track_die_tas.cpp
)
set(PUBLIC_HEADERS
data_process_class_dll/data_process_class_dll.h
data_process_class_dll/data_process_class_dll_global.h
)
add_library(data_process_class_dll SHARED ${SOURCES})
# 编译 DLL 时定义导出宏；引用 DLL 的工程不应定义该宏。
target_compile_definitions(data_process_class_dll PRIVATE
DATA_PROCESS_CLASS_DLL_LIBRARY
${RADAR_SCAN_MODE}
)
# 与 qmake 工程保持一致的 Windows 编译定义
if(WIN32)
target_compile_definitions(data_process_class_dll PRIVATE
WIN32
_WINDOWS
_UNICODE
UNICODE
NOMINMAX
)
endif()
# Eigen 头文件位于源码目录下（<Eigen/Dense>）。
target_include_directories(data_process_class_dll PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/data_process_class_dll
)
# 原工程使用 MSVC 2013（Visual Studio 12）编译器；保持兼容，不强制更高 C++ 标准。
# 源码使用 C++11 特性（nullptr、类内成员初始化等），MSVC 2013 默认即可支持。
if(MSVC)
# 与原 qmake 生成的编译选项保持一致。
# 注意：MSVC 2013 的 Debug 运行库与 /Zc:strictStrings 同时使用会触发 STL 编译错误，
# 原 qmake 工程也仅在 Release 配置中使用该选项。
target_compile_options(data_process_class_dll PRIVATE
/Zc:wchar_t
/FS
$<$<CONFIG:Release>:/Zc:strictStrings>
)
endif()
# 输出目录：build/bin 下为 DLL/PDB，build/lib 下为导入库。
set_target_properties(data_process_class_dll PROPERTIES
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin"
ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib"
PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin"
PUBLIC_HEADER "${PUBLIC_HEADERS}"
)
# 安装规则：DLL/导入库 -> bin/lib，公开头文件 -> include。
include(GNUInstallDirs)
install(TARGETS data_process_class_dll
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
)
Makefile
-426
View File
@@ -1,426 +0,0 @@
#############################################################################
# Makefile for building: data_process_class_dll
# Generated by qmake (3.0) (Qt 5.7.0)
# Project: data_process_class_dll\data_process_class_dll.pro
# Template: lib
# Command: C:\Qt\Qt5.7.0\5.7\msvc2013\bin\qmake.exe -spec win32-msvc2013 -o Makefile data_process_class_dll\data_process_class_dll.pro
#############################################################################
MAKEFILE = Makefile
first: release
install: release-install
uninstall: release-uninstall
QMAKE = C:\Qt\Qt5.7.0\5.7\msvc2013\bin\qmake.exe
DEL_FILE = del
CHK_DIR_EXISTS= if not exist
MKDIR = mkdir
COPY = copy /y
COPY_FILE = copy /y
COPY_DIR = xcopy /s /q /y /i
INSTALL_FILE = copy /y
INSTALL_PROGRAM = copy /y
INSTALL_DIR = xcopy /s /q /y /i
DEL_FILE = del
SYMLINK = $(QMAKE) -install ln -f -s
DEL_DIR = rmdir
MOVE = move
SUBTARGETS = \
release \
debug
release: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Release
release-make_first: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Release
release-all: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Release all
release-clean: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Release clean
release-distclean: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Release distclean
release-install: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Release install
release-uninstall: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Release uninstall
debug: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Debug
debug-make_first: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Debug
debug-all: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Debug all
debug-clean: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Debug clean
debug-distclean: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Debug distclean
debug-install: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Debug install
debug-uninstall: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Debug uninstall
Makefile: data_process_class_dll\data_process_class_dll.pro C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\win32-msvc2013\qmake.conf C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\spec_pre.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\common\angle.conf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\common\msvc-base.conf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\common\msvc-desktop.conf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\qconfig.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dcore.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dcore_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dextras.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dextras_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dinput.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dinput_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dlogic.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dlogic_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dquick.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dquick_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickextras.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickextras_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickinput.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickinput_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickrender.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickrender_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3drender.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3drender_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_axbase.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_axbase_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_axcontainer.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_axcontainer_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_axserver.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_axserver_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_bluetooth.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_bluetooth_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_bootstrap_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_charts.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_charts_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_clucene_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_concurrent.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_concurrent_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_core.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_core_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_datavisualization.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_datavisualization_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_dbus.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_dbus_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_designer.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_designer_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_designercomponents_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_gamepad.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_gamepad_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_gui.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_gui_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_help.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_help_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_location.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_location_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_multimedia.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_multimedia_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_multimediawidgets.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_multimediawidgets_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_network.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_network_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_nfc.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_nfc_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_opengl.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_opengl_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_openglextensions.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_openglextensions_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_packetprotocol_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_platformsupport_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_positioning.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_positioning_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_printsupport.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_printsupport_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_purchasing.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_purchasing_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_qml.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_qml_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_qmldebug_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_qmldevtools_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_qmltest.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_qmltest_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_qtmultimediaquicktools_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_quick.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_quick_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_quickcontrols2.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_quickcontrols2_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_quickparticles_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_quicktemplates2_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_quickwidgets.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_quickwidgets_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_script.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_script_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_scripttools.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_scripttools_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_scxml.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_scxml_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_sensors.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_sensors_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_serialbus.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_serialbus_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_serialport.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_serialport_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_sql.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_sql_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_svg.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_svg_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_testlib.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_testlib_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_uiplugin.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_uitools.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_uitools_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webchannel.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webchannel_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webengine.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webengine_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webenginecore.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webenginecore_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webenginecoreheaders_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webenginewidgets.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webenginewidgets_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_websockets.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_websockets_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webview.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webview_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_widgets.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_widgets_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_winextras.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_winextras_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_xml.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_xml_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_xmlpatterns.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_xmlpatterns_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_zlib_private.pri \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\qt_functions.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\qt_config.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\win32\qt_config.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\win32-msvc2013\qmake.conf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\spec_post.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\exclusive_builds.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\default_pre.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\win32\default_pre.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\resolve_config.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\exclusive_builds_post.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\default_post.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\win32\rtti.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\precompile_header.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\warn_on.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\qt.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\resources.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\moc.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\file_copies.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\win32\windows.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\testcase_targets.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\exceptions.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\yacc.prf \
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\lex.prf \
data_process_class_dll\data_process_class_dll.pro \
C:\Qt\Qt5.7.0\5.7\msvc2013\lib\Qt5Core.prl
$(QMAKE) -spec win32-msvc2013 -o Makefile data_process_class_dll\data_process_class_dll.pro
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\spec_pre.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\common\angle.conf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\common\msvc-base.conf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\common\msvc-desktop.conf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\qconfig.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dcore.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dcore_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dextras.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dextras_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dinput.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dinput_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dlogic.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dlogic_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dquick.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dquick_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickextras.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickextras_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickinput.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickinput_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickrender.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickrender_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3drender.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_3drender_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_axbase.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_axbase_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_axcontainer.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_axcontainer_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_axserver.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_axserver_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_bluetooth.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_bluetooth_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_bootstrap_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_charts.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_charts_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_clucene_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_concurrent.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_concurrent_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_core.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_core_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_datavisualization.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_datavisualization_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_dbus.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_dbus_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_designer.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_designer_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_designercomponents_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_gamepad.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_gamepad_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_gui.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_gui_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_help.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_help_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_location.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_location_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_multimedia.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_multimedia_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_multimediawidgets.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_multimediawidgets_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_network.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_network_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_nfc.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_nfc_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_opengl.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_opengl_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_openglextensions.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_openglextensions_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_packetprotocol_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_platformsupport_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_positioning.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_positioning_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_printsupport.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_printsupport_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_purchasing.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_purchasing_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_qml.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_qml_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_qmldebug_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_qmldevtools_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_qmltest.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_qmltest_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_qtmultimediaquicktools_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_quick.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_quick_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_quickcontrols2.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_quickcontrols2_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_quickparticles_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_quicktemplates2_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_quickwidgets.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_quickwidgets_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_script.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_script_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_scripttools.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_scripttools_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_scxml.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_scxml_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_sensors.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_sensors_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_serialbus.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_serialbus_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_serialport.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_serialport_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_sql.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_sql_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_svg.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_svg_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_testlib.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_testlib_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_uiplugin.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_uitools.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_uitools_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webchannel.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webchannel_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webengine.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webengine_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webenginecore.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webenginecore_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webenginecoreheaders_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webenginewidgets.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webenginewidgets_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_websockets.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_websockets_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webview.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_webview_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_widgets.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_widgets_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_winextras.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_winextras_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_xml.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_xml_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_xmlpatterns.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_xmlpatterns_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\modules\qt_lib_zlib_private.pri:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\qt_functions.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\qt_config.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\win32\qt_config.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\win32-msvc2013\qmake.conf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\spec_post.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\exclusive_builds.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\default_pre.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\win32\default_pre.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\resolve_config.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\exclusive_builds_post.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\default_post.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\win32\rtti.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\precompile_header.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\warn_on.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\qt.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\resources.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\moc.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\file_copies.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\win32\windows.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\testcase_targets.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\exceptions.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\yacc.prf:
C:\Qt\Qt5.7.0\5.7\msvc2013\mkspecs\features\lex.prf:
data_process_class_dll\data_process_class_dll.pro:
C:\Qt\Qt5.7.0\5.7\msvc2013\lib\Qt5Core.prl:
qmake: FORCE
@$(QMAKE) -spec win32-msvc2013 -o Makefile data_process_class_dll\data_process_class_dll.pro
qmake_all: FORCE
make_first: release-make_first debug-make_first FORCE
all: release-all debug-all FORCE
clean: release-clean debug-clean FORCE
-$(DEL_FILE) data_process_class_dll.exp
distclean: release-distclean debug-distclean FORCE
-$(DEL_FILE) Makefile
-$(DEL_FILE) data_process_class_dll.lib
release-mocclean:
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Release mocclean
debug-mocclean:
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Debug mocclean
mocclean: release-mocclean debug-mocclean
release-mocables:
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Release mocables
debug-mocables:
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Debug mocables
mocables: release-mocables debug-mocables
check: first
benchmark: first
FORCE:
$(MAKEFILE).Release: Makefile
$(MAKEFILE).Debug: Makefile
Makefile.Debug
-2252
View File
File diff suppressed because one or more lines are too long
Makefile.Release
-2252
View File
File diff suppressed because one or more lines are too long
README.md
+827 -12
View File
@@ -1,33 +1,848 @@
2003雷达数据处理动态链接库程序 # 雷达数据处理 DLL（data_process_class_dll）
功能：航迹跟踪处理、TAS/TWS跟踪控制 > X256 雷达数据处理动态链接库：将雷达输出的原始点迹（TWS/TAS）处理为稳定可靠的目标航迹，并给出 TAS 跟踪波束控制指令。
> 仓库 simianzhen256-v1.5.5-ms-vscode（上游 simianzhen256，v1.5.5；已由 Qt/qmake 工程迁移为 VS Code + CMake 工程）。
开发环境： QT5.7 MSVC2013 c++ ---
使用方法：构建项目，添加data_process_class_dll.dll文件至界面 ## 目录
1. [项目简介](#1-项目简介)
2. [功能特性](#2-功能特性)
3. [目录结构](#3-目录结构)
4. [构建与环境](#4-构建与环境)
5. [总体架构](#5-总体架构)
6. [关键数据结构](#6-关键数据结构)
7. [外部接口与调用流程](#7-外部接口与调用流程)
8. [处理流程总览](#8-处理流程总览)
9. [算法实现详解](#9-算法实现详解)
10. [参数说明](#10-参数说明)
11. [已知问题与限制](#11-已知问题与限制)
12. [版本历史](#12-版本历史)
13. [参考文档](#13-参考文档)
---
## 1. 项目简介
改进的情况： 本仓库是一个 **Windows 动态链接库**，实现某型雷达（内部代号 X256，按扫描体制分为 **相扫 X256_PS** 与 **机扫 X256_MS** 两种构建）的 **航迹数据处理** 功能，包括：
1. 目标凝聚中考虑360°两侧点的凝聚；（已经改20260213） - 输入点迹预处理与点迹凝聚（滑窗凝聚）
- 边扫描边跟踪（TWS）与边跟踪边扫描（TAS）双通道处理
- 逻辑法航迹起始（3～9 点起批，含屏蔽区、角度/波门约束）
- IMM + 扩展卡尔曼滤波（EKF，含多普勒速度）航迹维持
- 最近邻（NN）点航关联
- 航迹外推、消亡与航迹号管理
- TAS 手动转跟踪与跟踪波束调度输出
float delta_F = fabs(point_0_F-point_1_F)<2*PI-fabs(point_0_F-point_1_F) ? fabs(point_0_F-point_1_F) :2*PI-fabs(point_0_F-point_1_F); **技术栈**：C++（MSVC 2013 兼容，C++11 特性）、Eigen 3（随仓库内置，仅用 Eigen/Dense）、CMake ≥ 3.10。
2. 起航的门限增大8（已经改20260213） **处理约定**：
3. 改了点迹凝聚的逻辑，每一包数据输入的时候滑窗凝聚（ 改了一下数据预处理函数的返回值程序才能执行，20260214） | 项目 | 约定 |
|---|---|
| 时间戳 | CPI 时间 / GNSS 时间均为 long long 毫秒（64 位）；航迹时间 T_track 同样为毫秒，参与运算时除以 1000 转秒 |
| 角度 | 外部接口用度（°），内部统一弧度；输出航向角/方位/俯仰为度 |
| 坐标 | 直角坐标系 x/y 为水平面投影，z = 目标高度 + 雷达平台高度 |
| 点迹类型 | point_type = 0 为 TWS，point_type = 1 为 TAS |
| 跟踪模式 | Track_Mode = 0 为 TWS，Track_Mode = 1 为 TAS |
4. 起航的时候要删除有重叠航迹（20260215 修改了，验证中） ---
## 2. 功能特性
- **双模式处理管线**：data_preprocess 按输入类型与扫描圈完成标志返回 0/1/2/3，track_process 据此调度 TWS 凝聚/关联/起始或 TAS 凝聚/关联。
- **两帧滑窗点迹凝聚**：TWS 点迹先与上一帧缓存合并凝聚，再进入关联，兼顾跨波位（CPI）相邻点迹的分裂问题；近程模式增加速度维约束。
- **逻辑法航迹起始**：航迹头（单点）→ 点-头速度法关联（两点）→ 点-临时航迹 EKF 波门 + 折角约束关联（三点及以上）→ 三点卡尔曼初始化转可靠航迹；带起批屏蔽区与重复航迹去重。
- **3 模型 IMM 滤波**：三个 Singer 模型（低/中/高过程噪声），量测为「距离-方位-径向速度」三维的 EKF，多普勒残差按盲速折叠，似然用 3×3 新息协方差。
- **最近邻数据关联**：TWS 按航迹距离分段收紧模型 3 波门并附加距离门限；TAS 附加按距离分段的高度门限。
- **高度维独立平滑**：按距离分段选择滑动平均窗长（5/6/7/9 点），抑制俯仰测量跳变。
- **TAS 波束控制**：手动转 TAS 目标入队（队列长度与容量随扫描体制切换），按最新时间戳外推输出跟踪波束（距离/方位/俯仰/批号）。
- **航迹生命周期管理**：外推轮数计数、超时消亡、手动删除、全清空（含各模块 reset，防重连后幽灵航迹）。
- **防御性加固**：见 BUG_FIX_REPORT.md——越界防护、时间戳正序校验、方位角 ±π 环绕、asin 定义域钳位、IMM 概率奇异保护等已修复项。
20260228 ---
v1.5.1 雷达通信协议修改后的新程序、加了TAS逻辑，待测试
## 3. 目录结构
```text
.
├── CMakeLists.txt # CMake 构建脚本（扫描模式切换、导出宏、输出目录）
├── BUG_REPORT.md # 全量逻辑 BUG 分析报告（P0~P3，37 项）
├── BUG_FIX_REPORT.md # BUG 修复报告（修复明细 + 编译验证结果）
├── .vscode/ # VS Code 工程配置
│ ├── settings.json # cmake.generator=NMake、MSVC2013 x86 环境变量、compile_commands
│ ├── cmake-variants.yaml # X256_PS / X256_MS × Release / Debug 变体
│ ├── tasks.json # 配置/构建/清理任务
│ └── scripts/{configure,build,clean}.bat
├── backup/
│ └── data_process_class_dll/
│ ├── data_process_class_dll.pro # 迁移前的 Qt/qmake 工程文件（备份）
│ └── data_process_class_dll.pro.user
├── data_process_class_dll/ # 源码目录
│ ├── data_process_class_dll.h # 对外接口：DataRev/Track/TrackingBeam/RadarPara 结构体、抽象基类、工厂类
│ ├── data_process_class_dll_global.h # DLL 导入导出宏
│ ├── data_process_class_dll.cpp # 工厂实现（GetB/Destroy 单例）
│ ├── data_process.h / .cpp # Data_Process 实现：接口分发、TWS/TAS 主流程、参数管理、清空/删除/转跟踪
│ ├── struct.h # 内部结构体：PointRecv / Trust_Track / Temp_track / Tracking_Target
│ ├── parameters.h # 编译期宏参数（按 MECHANICAL_SCANNING / PHASE_SCANNING 分两组）
│ ├── dot_coh.h / .cpp # TWS 点迹凝聚（含两帧滑窗缓冲）
│ ├── dot_coh_tas.h / .cpp # TAS 点迹凝聚
│ ├── coor_trans.h / .cpp # 极坐标 ↔ 直角坐标转换
│ ├── kalman.h / .cpp # 卡尔曼滤波：两点/三点初始化、线性 KF、EKF（含多普勒）、统计距离、盲速计算
│ ├── track_asso.h / .cpp # TWS 航迹关联：IMM 交互 → 滤波 → 输出、距离/俯仰门限、高度平滑
│ ├── track_asso_tas.h / .cpp # TAS 航迹关联（独立实现，量测门限与数据率不同）
│ ├── track_init.h / .cpp # 逻辑法航迹起始：点-临时航迹关联、点-航迹头关联、转可靠航迹、屏蔽区
│ ├── track_init_direct_tracking.h/.cpp# 引导跟踪航迹起始（当前入口为空实现，未启用）
│ ├── track_asso_direct_tracking.h/.cpp# 引导跟踪航迹关联（未加入 CMake 构建）
│ ├── track_die.h / .cpp # TWS 航迹消亡
│ ├── track_die_tas.h / .cpp # TAS 航迹消亡
│ ├── tas_ctrl.h / .cpp # TAS 波束控制：目标队列增删、波束输出、禁止区判断
│ ├── track_index_mangement.h / .cpp # 航迹号 1~500 分配/复用
│ └── Eigen/ # 内置 Eigen 3 头文件库（仅用 Eigen/Dense）
├── build/ # 构建产物（被 .gitignore 忽略）
│ ├── X256_PS/ # 相扫构建目录（含 bin/data_process_class_dll.dll、rdp_playback.exe 等）
│ ├── X256_MS/ # 机扫构建目录
│ └── output/ # 早期打包导出（其中 data_process_class_dll.h 为旧版 32 位时间戳接口，勿作为当前 API 依据）
└── .gitignore
```
---
## 4. 构建与环境
### 4.1 环境要求
| 组件 | 要求 |
|---|---|
| 操作系统 | Windows（构建脚本按 D:\APP\VisualStudio2013 与 Windows Kits 8.1 路径配置） |
| 编译器 | Microsoft Visual C++ 2013（Visual Studio 12）**x86**（与原 Qt 工程保持一致） |
| CMake | ≥ 3.10 |
| 生成器 | NMake Makefiles（VS Code 配置与脚本均使用该生成器） |
| 线性代数 | 无需安装——Eigen 头文件已内置在源码目录 |
### 4.2 扫描体制
通过 CMake 缓存变量 RADAR_SCAN_MODE 切换，对应 parameters.h 中的两组宏：
| 变量值 | 对应宏 | 构建目录 |
|---|---|---|
| PHASE_SCANNING | 相扫（X256_PS，默认） | build/X256_PS |
| MECHANICAL_SCANNING | 机扫（X256_MS） | build/X256_MS |
### 4.3 命令行构建
```bat
:: 需在 MSVC 2013 x86 环境中执行（先运行 vcvarsall.bat x86）
cmake -S . -B build/X256_PS -G "NMake Makefiles" -DCMAKE_BUILD_TYPE=Release -DRADAR_SCAN_MODE=PHASE_SCANNING
cmake --build build/X256_PS
```
或直接使用仓库提供的脚本（内部已调用 vcvarsall.bat）：
```bat
.vscode\scripts\configure.bat build/X256_PS PHASE_SCANNING Release
.vscode\scripts\build.bat build/X256_PS
.vscode\scripts\clean.bat build/X256_PS
```
在 VS Code 中可直接运行任务（tasks.json）：「CMake: 配置并构建 X256_PS (Release)」等，默认任务为 X256_PS Release。
### 4.4 产物
| 产物 | 位置 |
|---|---|
| data_process_class_dll.dll（+ .pdb） | build/<X256_XX>/bin/ |
| 导入库 data_process_class_dll.lib | build/<X256_XX>/lib/ |
| 安装（cmake --install） | DLL/导入库 → bin、lib，公开头文件 → include |
| compile_commands.json | 构建根目录（供 VS Code IntelliSense 使用） |
仓库 build/X256_PS/bin/ 内还带有 **rdp_playback.exe**（回放测试工具，依赖 Qt5Core.dll、sqlite3.dll，配置样例 RadarConfigParam.ini，可回放 .db 记录的点迹数据验证 DLL 输出），不在本仓库源码范围内。
---
## 5. 总体架构
### 5.1 设计模式
- **接口 + 工厂（单例）**：Data_process_class_dll（抽象基类，声明全部虚接口）→ Data_Process（具体实现）。宿主仅通过 Data_Process_Factory::GetB() / Destroy() 获取与销毁唯一实例。
- **模块化流水线**：Data_Process 按职责组合 Dot_Coh、Dot_Coh_TAS、Track_Asso、Track_Asso_Tas、Track_Init、Track_Die、Track_Die_Tas、TAS_Ctrl、Track_Ind_Mangement 等模块，各模块持有自身处理缓存并支持 reset()。
```mermaid
classDiagram
class Data_process_class_dll {
<<abstract, exported API>>
+data_preprocess(DataRev[150]) int
+track_process(Track[][10], int*, int[], int*, int) int
+Beam_Ctrl(TrackingBeam*, Track[][10], int*)
+direct_tracking_process(...) int
+track_clear_all() int
+track_delete(int, int[]) int
+tracking_start(int) int
+tracking_stop(int) int
+tracking_point(float) int
+track_process_parameters_initial(RadarPara) int
+track_process_parameters_modify(RadarPara) int
}
class Data_Process {
-Data_buffer / Data_buffer_tas : vector PointRecv
-point_recv / point_recv_tas : vector PointRecv
-trust_track : vector Trust_Track
-temp_track : vector Temp_track
-Work_Parameter : RadarPara
-dot_coh / dot_coh_tas / track_asso / track_asso_tas
-track_init / track_die / track_die_tas / tas_ctrl
}
class Data_Process_Factory {
-static p : Data_process_class_dll*
+static GetB() Data_process_class_dll*
+static Destroy()
}
class Dot_Coh
class Dot_Coh_TAS
class Track_Asso
class Track_Asso_Tas
class Track_Init
class Track_Die
class Track_Die_Tas
class TAS_Ctrl
class Track_Ind_Mangement
class kalman
class coor_trans
Data_process_class_dll <|-- Data_Process
Data_Process_Factory ..> Data_Process : creates
Data_Process *-- Dot_Coh
Data_Process *-- Dot_Coh_TAS
Data_Process *-- Track_Asso
Data_Process *-- Track_Asso_Tas
Data_Process *-- Track_Init
Data_Process *-- Track_Die
Data_Process *-- Track_Die_Tas
Data_Process *-- TAS_Ctrl
Track_Init *-- Track_Ind_Mangement
Track_Asso ..> kalman
Track_Asso_Tas ..> kalman
Track_Init ..> kalman
kalman ..> coor_trans
```
### 5.2 模块职责
| 类 / 文件 | 职责 |
|---|---|
| Data_Process（data_process.cpp） | 对外接口实现与流程编排：输入缓存、按 model 分发 TWS/TAS 流水线、参数管理、航迹清空/删除、手动转/停 TAS、波束控制转发 |
| Dot_Coh | TWS 点迹凝聚：两帧滑窗合并凝聚（dot_coh_process_buff） |
| Dot_Coh_TAS | TAS 点迹凝聚（单帧，距离/方位/速度三维门限） |
| Track_Asso | TWS 点航关联 + IMM 滤波：模型交互 → 门限筛选（NN）→ 各模型 EKF → 概率更新 → 模型输出；未关联航迹外推；高度平滑 |
| Track_Asso_Tas | TAS 航迹关联（只处理指定批号 tas_track_idx，门限与 TWS 略有差异） |
| Track_Init | 逻辑法航迹起始：航迹头维护、点-头关联（两点）、点-临时航迹关联（三点及以上）、起批（三点卡尔曼初始化）、屏蔽区判断、临时航迹消亡 |
| Track_Die / Track_Die_Tas | 可靠航迹消亡：外推轮数超限或手动删除标志置位时输出消亡批号并删除 |
| TAS_Ctrl | TAS 波束控制：手动目标入队（tas_target_add）、失效目标出队（tas_target_del）、跟踪波束预测输出（tas_beam_output，含数据率门控）、队列轮转 |
| Track_Ind_Mangement | 航迹号 1~500 的顺序分配与回绕复用 |
| kalman | 两点/三点滤波初始化、线性卡尔曼预测/滤波、EKF（3 维量测含多普勒）、马氏统计距离 d、盲速 Bind_speed |
| coor_trans | 极坐标 ↔ 直角坐标转换 |
| Track_Init_Direct_Tracking / Track_Asso_Direct_Tracking | 引导跟踪（direct tracking）专用起批/关联。**当前入口为空实现、未启用**；track_asso_direct_tracking.cpp 未加入 CMake 源列表 |
---
## 6. 关键数据结构
### 6.1 对外结构体（data_process_class_dll.h）
| 结构体 | 用途 | 要点 |
|---|---|---|
| DataRev | 输入点迹 | 距离(m)、方位/俯仰(°)、速度(m/s)、幅度/门限/SNR/RCS、码盘值、CPI/GNSS 时间(ms, long long)、方位波位(0-24)/俯仰波位(0-13)、PRI(µs，**不允许为 0**)、频点号、点数、点迹号、使用标记、TAS 批号、点迹类型、十字星数据 speed_dim[129]/range_dim[8] |
| Track | 输出航迹 | 位置/速度、极坐标量、航迹号、更新点数、方向/实虚点标志、一步预测、跟踪模式、航向角、目标类型、关联点信息、航迹时间(s)/GNSS、SNR/RCS、十字星数据透传 |
| TrackingBeam | TAS 跟踪波束指令 | open_flag、type、Range、Azi、Elev、TAS_track_index |
| Target_direct_tracking | 引导跟踪信息 | 批号、距离/方位/俯仰、开关（接口未启用） |
| RadarPara | 工作参数 | 见 [参数说明](#10-参数说明) |
### 6.2 内部结构体（struct.h）
| 结构体 | 用途 | 关键字段 |
|---|---|---|
| PointRecv | 内部点迹 | 距离/方位(弧度)/速度/幅度/高度/SNR/RCS/CPI/GNSS 时间、点迹号、使用标志、波位/PRF/频点、跟踪模式、点迹区号、十字星数据 |
| Trust_Track | 可靠航迹（IMM 全状态） | 航迹号、高度、航迹时间、更新标志、外推轮数 Extrapolate_round、实虚点标志、手动删除/手动 TAS 标志、关联点数、高度平滑缓冲 Hight_smooth、关联点信息、融合状态 X[6]/P[6][6]、三个子模型 X1/X2/X3、P1/P2/P3、模型概率 u[3] |
| Temp_track | 临时航迹（航迹起始阶段） | 4 维状态 X[4]/P[4][4]、极坐标点信息、时间戳、buff_round（已缓存圈数）、区号、关联标志 |
| Tracking_Target | TAS 队列元素 | 批号 Index、空标志 empty_flag |
| Direct_Tracking_Target | 引导跟踪目标 | ID、方位/俯仰/距离、空标志 |
> 说明：Trust_Track 的状态布局为 [x, vx, ax, y, vy, ay]，x/y 两轴解耦，每轴为「位置-速度-加速度」。
---
## 7. 外部接口与调用流程
### 7.1 接口一览
| 接口 | 返回值 | 说明 |
|---|---|---|
| Data_Process_Factory::GetB() | 实例指针 | 获取单例（首次调用时创建） |
| Data_Process_Factory::Destroy() | — | 销毁实例并将指针置空 |
| track_process_parameters_initial(RadarPara) | 0 成功 / -1 失败 | 初始化工作参数；校验 3 ≤ track_start_point_num ≤ 9 |
| track_process_parameters_modify(RadarPara) | 0 / -1 | 运行时修改参数（校验同上） |
| data_preprocess(DataRev[150]) | 0/1/2/3 | 输入一帧点迹并缓存，返回处理模式（见下表） |
| track_process(Track[][10], &num, dieIdx[], &dieNum, model) | 1 | 按 data_preprocess 的返回值执行 TWS/TAS 处理 |
| Beam_Ctrl(TrackingBeam*, Track[][10], &num) | — | TAS 波束控制（内部清零并重填航迹输出计数） |
| track_clear_all() | 0 | 清空全部航迹/缓存并复位各模块状态 |
| track_delete(n, idx[]) | 0 | 按批号标记手动删除（下一轮消亡输出） |
| tracking_start(track_index) | 0 | 手动转 TAS 跟踪（置 manual_tracking_flag，由 Beam_Ctrl 入队） |
| tracking_stop(track_index) | 0 | 手动取消 TAS（清标志并 Track_Mode=0；队列项延至下一次 Beam_Ctrl 移除） |
| tracking_point(azimuth) | 0 | 手动打跟踪波束——**未实现（保留空实现）** |
| direct_tracking_process(...) | 0 | 引导跟踪——**未实现（保留空实现）** |
### 7.2 data_preprocess 返回值的含义
| 返回值 | 含义 | 触发条件 |
|---|---|---|
| 0 | 无效数据 | point_type 既非 0 也非 1 |
| 1 | **TWS 满一圈，执行航迹处理** | point_type==0 且当前方位波位号 < 上一帧波位号（波位号由大变小判为扫描一圈完成） |
| 2 | **TWS 未满一圈，继续蓄数据** | point_type==0 且波位号未变小；调用 track_process(model=2) 做滑窗凝聚 |
| 3 | **TAS 处理** | point_type==1；同时记录 TAS_track_idx 与最新时间戳 |
> 首次调用时 last_beam_num 为 INT_MAX，因此必然返回 1；track_clear_all() 后同样复位为 INT_MAX。
### 7.3 典型调用序列
```mermaid
flowchart TD
A["Data_Process_Factory::GetB()"] --> B["track_process_parameters_initial(RadarPara)"]
B --> C{"接收一帧点迹"}
C --> D["model = data_preprocess(DataRev[150])"]
D --> E{"model ?"}
E -- "2 (TWS 蓄数据)" --> F["track_process(model=2) 滑窗凝聚"]
E -- "1 (TWS 一圈)" --> G["track_process(model=1) 关联/起批/消亡"]
E -- "3 (TAS)" --> H["track_process(model=3) TAS 关联/消亡"]
E -- "0" --> C
F --> C
G --> I["Beam_Ctrl() 输出跟踪波束"]
H --> I
I --> J{"手动操作?"}
J -- 是 --> K["tracking_start / tracking_stop / track_delete"]
K --> C
J -- 否 --> C
C -. "结束/重连" .-> L["track_clear_all() / Factory::Destroy()"]
```
---
## 8. 处理流程总览
### 8.1 TWS 流程（model=1）
```mermaid
flowchart TD
A["data_preprocess: 点迹入 Data_buffer（度→弧度、高度=Range·sin(Elev)、时间戳缓存）"] --> B["波位号变小（一圈完成）→ model=1"]
B --> C["track_process(1)"]
C --> D["dot_coh 两帧滑窗凝聚 → point_recv"]
D --> E["track_asso: IMM 交互 → 点航波门筛选（NN）→ EKF 滤波 → 模型输出"]
E --> F["track_die: 外推超限/手动删除 → 输出消亡批号"]
F --> G["track_init: 点-临时航迹关联 → 点-航迹头关联 → 起批转可靠航迹"]
G --> H["输出 Trust_Track_Output（含起批历史点）"]
H --> I["Beam_Ctrl: 手动 TAS 目标入队 / 波束输出"]
```
其中 model=2（未满一圈）只执行滑窗凝聚 dot_coh_process_buff，把上一帧凝聚完成的点输出到 point_recv 供下一圈的关联/起批使用，当前帧未凝聚点作为下一次的缓存——即「凝聚在前、关联在后、缓存一帧」的两帧滑窗结构。
### 8.2 TAS 流程（model=3）
```mermaid
flowchart TD
A["data_preprocess: 点迹入 Data_buffer_tas，记录 TAS_track_idx/latest_timestamp → model=3"] --> B["track_process(3)"]
B --> C["dot_coh_tas 单帧凝聚 → point_recv_tas"]
C --> D["track_asso_tas: 仅对 tas_track_idx 批号做 IMM+EKF 关联（含高度门限）"]
D --> E["未关联 → 按 latest_timestamp 外推（ΔT≤0 跳过）"]
E --> F["track_die_tas: TAS 超时/手动删除 → 消亡输出"]
F --> G["输出该批号航迹（point_type=1）"]
G --> H["Beam_Ctrl: 队列轮转 + 预测波束输出"]
```
### 8.3 航迹起始流程（逻辑法）
```mermaid
flowchart TD
A["未关联点迹"] --> B["转航迹头 Temp_track(1点) buff_round=1"]
B --> C{"下一帧点迹"}
C --> D["点-航迹头关联：速度区间门限 + 径向速度同号 → 两点卡尔曼初始化（航迹头→2 点临时航迹）"]
D --> E{"后续点迹"}
E --> F["点-临时航迹关联：EKF 统计距离波门 d²≤64、折角<60°、径向速度同号、|Δr|≥5m"]
F --> G{"长度 ≥ track_start_point_num(3~9) 且 ≤10"}
G -- 是 --> H["屏蔽区判断 → 重复航迹去重（保留末点 d 更小者）→ 三点卡尔曼初始化"]
H --> I["转可靠航迹：分配航迹号 1~500，IMM 三模型同状态初始化 u=1/3"]
I --> J["按历史点数输出 Trust_Track_Output[i][0..L-1]"]
G -- 否 --> K{"buff_round>2 或 长度≥10 ?"}
K -- 是 --> L["临时航迹消亡"]
K -- 否 --> E
```
---
## 9. 算法实现详解
### 9.1 坐标与量测转换
极坐标（距离 r、方位 θ，弧度）与直角坐标互转（coor_trans.cpp）：
$$
x=r\cos\theta,\qquad y=r\sin\theta
\qquad\qquad
r=\sqrt{x^2+y^2},\qquad \theta=\operatorname{atan2}(y,x)\ \bmod 2\pi
$$
输入点高度由量测俯仰直接折算：h = R·sin(ε)（data_preprocess 中完成）。输出时航迹高度加雷达平台高度：z = h + H_radar。
**转换量测协方差**（用于以直角坐标为量测的线性滤波，kalman.cpp 中多处使用）。设 λθ = exp(-σa²/2)、λθ' = exp(-2σa²)，则在量测 (r,θ) 处转换后的直角坐标量测噪声协方差为：
$$
R_{xx}=\left(\lambda_\theta^{-2}-2\right)r^2\cos^2\theta+\tfrac12\left(r^2+\sigma_r^2\right)\left(1+\lambda'_\theta\cos 2\theta\right)
$$
$$
R_{yy}=\left(\lambda_\theta^{-2}-2\right)r^2\sin^2\theta+\tfrac12\left(r^2+\sigma_r^2\right)\left(1-\lambda'_\theta\cos 2\theta\right)
$$
$$
R_{xy}=\left(\lambda_\theta^{-2}-2\right)r^2\sin\theta\cos\theta+\tfrac12\left(r^2+\sigma_r^2\right)\lambda'_\theta\sin 2\theta
$$
其中 σr、σa 由 SIGMA_R / SIGMA_A 宏给定（10 m / 0.02 rad）。
### 9.2 点迹凝聚
对同一 CPI（TWS 为相邻两 CPI 合并后）内所有点迹两两比较，门限满足且幅度较小者被标记删除（Use_Flag=1）：
| 模式 | 距离门限 | 方位门限（环绕最小角差） | 速度门限 |
|---|---|---|---|
| work_mode==0（近程） | ≤ 80 m（DOT_COH_RANGE） | ≤ 6°（DOT_COH_AZI） | ≤ 2 m/s（DOT_COH_V） |
| work_mode!=0（中/远程） | ≤ 80 m | ≤ 6° | 不约束 |
方位差按环绕角处理：
$$
\Delta\theta = \min\left(|\theta_0-\theta_1|,\ 2\pi-|\theta_0-\theta_1|\right)
$$
凝聚后删除 r<100 m 或 r>100000 m 的量程外点。TWS 的 dot_coh_process_buff 将上一帧缓存点标记区号 1、当前帧点标记区号 2，合并凝聚后：区号 1 的点输出到 point_recv（进入关联），区号 2 的点存入 data_input_buff 供下一帧凝聚——形成两帧滑窗。
### 9.3 航迹起始（逻辑法）
#### (1) 点-航迹头关联（两点起始）
对单点航迹头（buff_round ≥ 2），量测点需同时满足**速度区间门限**与**径向速度同号**：
- 近程（work_mode==0）：
$$
r_p \ge 1000:\ V_{min}\Delta T \le d_{12} \le V_{max}\Delta T;\qquad
r_p < 1000:\ \tfrac12 V_{min}\Delta T \le d_{12} \le \tfrac12 V_{max}\Delta T
$$
- 中/远程（work_mode!=0）：
$$
r_p \ge 2000:\ V_{min}\Delta T \le d_{12} \le V_{max}\Delta T;\qquad
r_p < 2000:\ \tfrac12 V_{min}\Delta T \le d_{12} \le \tfrac13 V_{max}\Delta T
$$
其中 d12 为两点间平面距离，ΔT 为时间差（秒），并需 vr_point · vr_head > 0。关联成功用 **两点卡尔曼初始化**（见 9.5.2）。
#### (2) 点-临时航迹关联（三点及以上）
对 ≥ 2 点的临时航迹，用航迹末点状态做 EKF 一步预测，计算三维（距离-方位-径向速度）马氏统计距离 d（见 9.5.3），并要求 |r_point − r_head| ≥ 5 m，同时满足：
$$
d^2 \le TRACK\_START\_THRESHOLD^2 = 64,\qquad
\alpha < ALPHA\_START = 60°,\qquad
v_{r,point}\cdot v_{r,track}>0
$$
折角 α 为最近三点连线夹角（度）：
$$
\alpha=\arccos\left(\frac{\vec{D_{12}}\cdot\vec{D_{23}}}{\|\vec{D_{12}}\|\,\|\vec{D_{23}}\|}\right)\cdot\frac{180}{\pi}
$$
#### (3) 转可靠航迹（起批）
临时航迹长度 L 满足 track_start_point_num ≤ L ≤ 10（起批点数由参数给定，典型 3~4，接口层校验 3~9）且不在起批屏蔽区内（屏蔽区为距离-方位矩形区域，最多 30 个）时进入起批队列；同源（共享前三点）的重复航迹只保留末点 d 最小者。起批时用 **最近三点卡尔曼初始化** 得到 6 维状态，构造 Trust_Track：
- 三个 IMM 子模型用同一状态/协方差初始化，模型概率 u = [1/3, 1/3, 1/3]；
- 分配航迹号（1~500，见 9.8）；
- 将临时航迹的全部 L 个点写入 Trust_Track_Output（每条航迹最多 10 个历史点）。
### 9.4 IMM 框架（3 个 Singer 模型）
TWS/TAS 关联共用同一套 IMM 结构（代码各自实现一份）。状态 [x, vx, ax, y, vy, ay]，x/y 两轴解耦，机动相关时间常数固定 α = 0.2。
**模型转移概率矩阵**：
$$
P_t=\begin{bmatrix}0.8&0.15&0.05\\0.3&0.4&0.3\\0.05&0.15&0.8\end{bmatrix}
$$
**交互（mix）**：归一化常数与混合概率
$$
\bar c_j=\sum_{i}p_{ij}\,\mu_i,\qquad
\mu_{i|j}=\frac{p_{ij}\,\mu_i}{\bar c_j}
$$
混合状态 X0j = Σ μ(i|j) Xi，混合协方差 P0j = Σ μ(i|j) [Pi + (Xi − X0j)(Xi − X0j)ᵀ]（实现中对 c̄j 做了 ≥ 1e-12 钳位防除零）。
**子模型滤波**：每个模型以各自的 F、Qj 做 EKF 预测/更新（9.5）。
**模型概率更新**：以新息协方差行列式归一化的高斯似然
$$
\Lambda_j=\frac{1}{\sqrt{(2\pi)^3\det S_j}}\exp\left(-\tfrac12 d_j\right),\qquad
\mu_j'=\frac{\Lambda_j\,\bar c_j}{\sum_k \Lambda_k\,\bar c_k}
$$
其中 dj 为该模型的马氏距离平方。实现中 det Sj ≤ 1e-12 时 Λj = 0，分母 ≤ 1e-12 时保持上一拍概率。
**输出融合**：
$$
\hat X=\sum_j\mu_j'\hat X_j,\qquad
P=\sum_j\mu_j'\left[P_j+\left(\hat X_j-\hat X\right)\left(\hat X_j-\hat X\right)^T\right]
$$
### 9.5 卡尔曼滤波
#### 9.5.1 Singer 模型状态转移与过程噪声
每轴状态转移矩阵（α = 0.2，T = ΔT 为时间差，秒）：
$$
F_{axis}=\begin{bmatrix}
1 & T & \dfrac{\alpha T-1+e^{-\alpha T}}{\alpha^2}\\[2mm]
0 & 1 & \dfrac{1-e^{-\alpha T}}{\alpha}\\[2mm]
0 & 0 & e^{-\alpha T}
\end{bmatrix}
,\qquad
F=\begin{bmatrix}F_{axis}&0\\0&F_{axis}\end{bmatrix}
$$
过程噪声 Qj = qj · Q̄，Q̄ 每轴为对称矩阵，元素为 Singer 模型离散化的标准结果：
$$
\bar q_{11}=\frac{1}{2\alpha^5}\left[1-e^{-2\alpha T}+2\alpha T+\frac{2\alpha^3T^3}{3}-2\alpha^2T^2-4\alpha T e^{-\alpha T}\right]
$$
$$
\bar q_{12}=\frac{1}{2\alpha^4}\left[e^{-2\alpha T}+1-2e^{-\alpha T}+2\alpha T e^{-\alpha T}-2\alpha T+\alpha^2T^2\right]
$$
$$
\bar q_{13}=\frac{1}{2\alpha^3}\left[1-e^{-2\alpha T}-2\alpha T e^{-\alpha T}\right]
$$
$$
\bar q_{22}=\frac{1}{2\alpha^3}\left[4e^{-\alpha T}-3-e^{-2\alpha T}+2\alpha T\right]
$$
$$
\bar q_{23}=\frac{1}{2\alpha^2}\left[e^{-2\alpha T}+1-2e^{-\alpha T}\right],
\qquad
\bar q_{33}=\frac{1}{2\alpha}\left[1-e^{-2\alpha T}\right]
$$
过程噪声强度 qj 按航迹速度分档（对应三个机动等级）：
| 模型 | TWS 版（track_asso.cpp） | TAS 版（track_asso_tas.cpp） |
|---|---|---|
| 模型 1（低机动） | q1 = Model1_Q_slow（恒定） | 同左 |
| 模型 2（中机动） | v≤5: slow/20；5<v≤30: slow；v>30: fast | v≤5: slow/20；50<v≤100: 10·fast；其余: fast |
| 模型 3（高机动） | v≤5: slow/20；5<v≤20: slow；20<v≤50: fast；50<v≤100: 2·fast；v>100: 10·fast | v≤5: slow/20；50<v≤100: 10·fast；其余: fast |
> 注意：Model1_Q_fast 字段当前未参与计算（模型 1 只用 slow）；各档系数以源码为准。
#### 9.5.2 两点初始化（临时航迹，4 维）
两直角量测 Z0=(x0,y0)、Z1=(x1,y1)，时间差 T：
$$
X=[x_1,\ (x_1-x_0)/T,\ y_1,\ (y_1-y_0)/T]^T,\qquad
P_{axis}=\begin{bmatrix}R&R/T\\R/T&2R/T^2\end{bmatrix}
$$
其中 R 为 Z1 处的转换量测协方差（9.1）。x/y 轴独立填充 P[4][4]。
#### 9.5.3 三点初始化（可靠航迹，6 维）
三点 Z0, Z1, Z2，时间差 T1, T2，取末点与差分近似速度/加速度：
$$
X=\left[x_2,\ \frac{x_2-x_1}{T_2},\ \frac{(x_2-x_1)/T_2-(x_1-x_0)/T_1}{(T_2+T_1)/2},\
y_2,\ \frac{y_2-y_1}{T_2},\ \frac{(y_2-y_1)/T_2-(y_1-y_0)/T_1}{(T_2+T_1)/2}\right]^T
$$
协方差按误差传播由 R0, R1, R2（各点转换量测协方差）构造，x 轴块 P11 形式为：
$$
P_{11}=\begin{bmatrix}
R_2^{xx} & R_2^{xx}/T_2 & \dfrac{R_2^{xx}/T_2}{(T_2+T_1)/2}\\[1mm]
R_2^{xx}/T_2 & \dfrac{R_2^{xx}+R_1^{xx}}{T_2^2} & \dfrac{(R_2^{xx}+R_1^{xx})/T_2^2+R_1^{xx}/(T_1T_2)}{(T_1+T_2)/2}\\[1mm]
\dfrac{R_2^{xx}/T_2}{(T_2+T_1)/2} & \dfrac{(R_2^{xx}+R_1^{xx})/T_2^2+R_1^{xx}/(T_1T_2)}{(T_1+T_2)/2} & \dfrac{4\left[(R_2^{xx}+R_1^{xx})/T_2^2+(R_1^{xx}+R_0^{xx})/T_1^2+2R_1^{xx}/(T_1T_2)\right]}{(T_1+T_2)^2}
\end{bmatrix}
$$
P12（x-y 交叉块）、P22（y 轴块）同构，把 Rxx 换成 Rxy、Ryy。
> ⚠ 当前实现未对 T=0 的重复时间戳做除零保护（BUG-18，暂不修复），调用方需保证点迹时间严格递增。
#### 9.5.4 线性卡尔曼滤波（二维直角量测）
标准预测/更新：
$$
\hat X_{k|k-1}=F\hat X_{k-1},\qquad
P_{k|k-1}=FP_{k-1}F^T+Q
$$
$$
S=HP_{k|k-1}H^T+R,\qquad
K=P_{k|k-1}H^TS^{-1}
$$
$$
\hat X_k=\hat X_{k|k-1}+K\left(Z-H\hat X_{k|k-1}\right),\qquad
P_k=\left(I-KH\right)P_{k|k-1}
$$
H 为位置选择矩阵（6 维状态取 x/y）。统计距离（马氏距离平方）：
$$
d=\nu^T S^{-1}\nu,\qquad \nu=Z-H\hat X_{k|k-1}
$$
此形式用于两点临时航迹的门限 d_cal_track_init（CV 模型 FCV、Q=(0.03)²I）。
#### 9.5.5 扩展卡尔曼滤波（距离-方位-径向速度量测）
量测向量 Z = [r, θ, vr]，非线性量测函数（由预测状态计算）：
$$
h(\hat X)=\begin{bmatrix}r\\\theta\\v_r\end{bmatrix}=
\begin{bmatrix}\sqrt{x^2+y^2}\\ \operatorname{atan2}(y,x)\bmod 2\pi\\ -\dfrac{x\,v_x+y\,v_y}{\sqrt{x^2+y^2}}\end{bmatrix}
$$
雅可比（在预测点处线性化）：
$$
H=\frac{\partial h}{\partial X}=
\begin{bmatrix}
\dfrac{x}{r}&0&0&\dfrac{y}{r}&0&0\\[2mm]
-\dfrac{y}{r^2}&0&0&\dfrac{x}{r^2}&0&0\\[2mm]
-\dfrac{y(v_xy-v_yx)}{r^3}&-\dfrac{x}{r}&0&-\dfrac{x(v_yx-v_xy)}{r^3}&-\dfrac{y}{r}&0
\end{bmatrix}
$$
量测噪声 R = diag(σr², σa², σv²)。新息与增益/更新同 9.5.4，并做两项残差修正：
- **方位环绕**：νθ = wrapToPi(θ_mea − θ_pred)，归一到 [-π, π)；
- **多普勒盲速折叠**：νv = νv − Round(νv / v_bind)·v_bind，其中盲速
$$
v_{bind}=\frac{150000}{f_{GHz}\cdot PRI_{µs}}\quad(\mathrm{m/s}),\qquad
f_{GHz}=16.8+0.02\cdot f_{ind}
$$
（PRI ≤ 0 或 f ≤ 0 时返回安全值 1.0，接口约定 PRI 不允许为 0。）
关联判定与模型似然共用 d = νᵀS⁻¹ν，滤波后输出完整 3×3 新息协方差 S 供似然归一化使用（BUG-24 已修复）。
### 9.6 点航关联（最近邻）
#### TWS（track_asso.cpp）
对每条航迹 × 每个点计算三模型 d1, d2, d3，波门按航迹距离分段：
| 航迹距离 | 模型 1/2 门限 | 模型 3 门限 |
|---|---|---|
| r_track ≤ 500 m | d_i² < 9 | d_3² < 9/1000（≈关闭） |
| 500 < r_track < 1000 m | d_i² < 9 | d_3² < 9/100（收紧） |
| r_track ≥ 1000 m | d_i² < 9 | d_3² < 9 |
同时满足两个附加门限：
- **俯仰门限 d_p**：当前恒为 true（分距离段 7°/5°/10° 的逻辑在源码中被注释停用）；
- **距离门限 d_r**：以航迹-点迹弦距 R = √(r_t² + r_p² − 2·r_t·r_p·cos Δθ)（Δθ 为环绕方位差）与航迹速度位移 VT = v_track·ΔT 判断：
$$
VT<100\ \text{且}\ R>300\ \Rightarrow 拒绝;\qquad
100\le VT\le300\ \text{且}\ R/VT>3\ \Rightarrow 拒绝;\qquad
VT>300\ \text{且}\ R>1200\ \Rightarrow 拒绝
$$
候选对按 d_min = min(d1,d2,d3) 全局排序，**最近邻**原则逐个取点：每条航迹每圈最多关联一个点、每个点只属于一条航迹。关联成功后：三模型分别 EKF 更新 → 模型概率更新 → 更新航迹时间/幅度/SNR/RCS/十字星数据 → 高度平滑。ΔT ≤ 0（乱序/重复时间戳）的候选被剔除且不占用点迹、不刷新航迹状态（BUG-15 修复）。
#### TAS（track_asso_tas.cpp）
只处理 tas_track_idx 指定的航迹，门限：
$$
d_i^2 < ASSO\_THORD^2 = 9\ \ \text{且高度门限}\ d_h=1
$$
高度门限按航迹距离分段：≤1000 m：|h_t−h_p| ≤ 150 m；1000~2000 m：≤ 200 m；2000~3000 m：≤ 200 m；3000~5000 m：≤ 300 m；>5000 m：不约束。
> ⚠ **波门语义提示**：代码中 d 本身已是马氏距离平方，但门限写作 d*d < ASSO_THORD*ASSO_THORD，等效于 d < 3（而非 √d < 3）。该行为在 BUG-20 中被识别，**有意保留未改**；ASSO_THORD/1000、/100 已改为浮点除法（BUG-21 修复）。
### 9.7 高度平滑
关联实点后，点迹高度入滑窗 Hight_smooth，输出高度取最近 w 个值的平均（不足 w 个则全平均）：
$$
\hat h=\frac{1}{w}\sum_{i=N-w+1}^{N} h_i,\qquad
w=\begin{cases}5,&r\le1000\\6,&1000<r\le2000\\7,&2000<r\le4000\\9,&r>4000\end{cases}
$$
> 已知问题（BUG-02）：缓存只增不减，航迹存活越久内存占用越大，当前有意保留。
### 9.8 航迹号管理（track_index_mangement.cpp）
- 空航迹表时从 1 开始；否则从 lastest_index+1 向上找第一个未占用号（含 500，BUG-35 已修复），找不到则从 1 回绕；全满（500 条）返回 0（不起批）。
- 写占用表前校验 1 ≤ Track_Index ≤ 500，防御异常批号越界（BUG-10 修复）。
### 9.9 航迹外推与消亡
**外推**：未关联到实点的 TWS 航迹（manual_tracking_flag==0）按工作模式数据率 DATA_RATE_SHORT/MIDDLE/FAR 预测一帧；TAS 通道按 latest_timestamp − T_track 预测（ΔT ≤ 0 跳过）；预测用各子模型 Singer F/Qj 推进，Extrapolate_round+1，point_flag=0（虚点/补点），航迹时间同步推进。
**消亡**：
| 通道 | 条件 |
|---|---|
| TWS | Track_Mode==0 且 Extrapolate_round ≥ TRACK_DIE_ROUND（=4），或 manual_delete_flag==1 |
| TAS | Track_Mode==1 且 Extrapolate_round ≥ TRACK_DIE_ROUND_TAS（相扫 5 / 机扫 96），或 manual_delete_flag==1 |
消亡批号写入 Track_die_Index_Output 并删除本地航迹。
### 9.10 TAS 波束控制（tas_ctrl.cpp）
- **入队条件**（仅手动）：manual_tracking_flag==1 且 Track_Mode==0 且队列未满（MAX_TAS_NUM，相扫 4 / 机扫 1）且不在 TAS 禁止区内。入队即置 Track_Mode=1 并输出一次航迹更新。
- **出队**：队列中目标在航迹表中不存在、或不再处于手动 TAS 状态时清除。（自动转 TAS / 自动退出的 tas_auto_start/tas_auto_end 逻辑全部注释停用——只支持手动。）
- **波束输出**：取队首目标，先用**数据率门控**：航迹时间 T_track 与当前最新时间戳 latest_timestamp 的差值必须大于 `1 / DATA_RATE_TAS` 秒才输出（保证 TAS 目标数据率不随波束时间变化；DATA_RATE_TAS ≤ 0 时不做门控，按原逻辑输出）。门控通过后，用其状态外推到 latest_timestamp：
$$
x_p=x+v_x\Delta T,\quad y_p=y+v_y\Delta T,\quad
r_p=\sqrt{x_p^2+y_p^2},\quad \theta_p=\operatorname{atan2}(y_p,x_p)
$$
输出 TrackingBeam{open_flag=1, type=1, Range=rp, Azi=θp(°), Elev=asin(h/rp)(°), TAS_track_index}；队空、目标不在航迹表或数据率门控未通过时 open_flag=0。每次 Beam_Ctrl 末尾做队列轮转（实现 TAS_QUEUE_LENGTH 深度的循环跟踪）。
- tas_ctrl_process 入口强制 *Trust_track_num_Output=0 并在写入前检查容量，防止输出数组越界（BUG-09 修复）。
---
## 10. 参数说明
### 10.1 编译期宏（parameters.h，随扫描体制切换）
| 宏 | 相扫 PHASE_SCANNING | 机扫 MECHANICAL_SCANNING | 含义 |
|---|---|---|---|
| DATA_RATE_TAS | 0.3 | 0.0625 | TAS 数据率（1/s）。**TAS 波束输出门控已改用运行时参数 RadarPara.DATA_RATE_TAS（见 10.2），不再使用该宏**；宏目前仅被未加入 CMake 的 track_asso_direct_tracking.cpp 引用 |
| SIGMA_R / SIGMA_A / SIGMA_E / SIGMA_V | 10.0 / 0.02 / 0.2 / 2.0（两体制相同） | 同左 | 量测误差：距离 m / 方位 rad / 俯仰 rad / 速度 m/s |
| DOT_COH_RANGE / DOT_COH_V / DOT_COH_AZI | 80 / 2 / 6 | 同左 | 凝聚门限：距离 m / 速度 m/s / 方位 ° |
| MAX_BEAM_NUM | 100 | 同左 | 最大波位数 |
| MAX_TRACK_NUM / MAX_TRACK_INDEX | 500 / 500 | 同左 | 航迹数上限 / 航迹号上限 |
| R_MIN / R_MAX | 100 / 100000 | 同左 | 有效量程（m） |
| TRACK_START_THRESHOLD | 8 | 同左 | 起批波门（d² 门限 64；越大越容易起批） |
| ALPHA_START | 60 | 同左 | 起批折角（°） |
| TRACK_DIE_ROUND | 4 | 4 | TWS 航迹消亡外推轮数 |
| TRACK_DIE_ROUND_TAS | 5 | 96 | TAS 航迹消亡外推轮数 |
| ASSO_THORD | 3 | 同左 | 关联波门 |
| H_F_WIN_LEN | 3 | 同左 | 高度平滑窗长基数（实际 +2/+3/+4/+6） |
| TAS_QUEUE_LENGTH / MAX_TAS_NUM | 4 / 4 | 1 / 1 | TAS 队列长度 / 最大 TAS 目标数 |
| FREQ0~FREQ20 | 16.8 GHz | 同左 | 各频点频率 |
### 10.2 运行时参数（RadarPara）
| 字段 | 含义 | 备注 |
|---|---|---|
| Beam_num | 波位数 | |
| Height | 雷达平台高度（m） | 输出 z 叠加 |
| Sys_delay | 系统延迟（s） | 输出航迹位置做 x + vx·Sys_delay 补偿 |
| R_TAS_max/min、V_TAS_max/min、TAS_Height_1~5 | TAS 自动开启/退出条件 | 自动逻辑已停用，字段保留 |
| track_prohibite_area_num + 4×30 数组 | 起批屏蔽区（最多 30 个） | 数量未做上限校验（BUG-07） |
| TAS_prohibite_area_num + 4×30 数组 | TAS 禁止区（最多 30 个） | 同上 |
| cfar_th | CFAR 门限 | 当前未参与处理 |
| work_mode | 0 近程 / 1 中程 / 2 远程 | 决定数据率与门限分支 |
| north_angle | 北偏角 | 保留 |
| V_MAX / V_MIN | 目标速度上下限（m/s） | 航迹头关联速度区间门限 |
| DATA_RATE_SHORT / MIDDLE / FAR | 三模式数据率（s） | TWS 外推步长 |
| DATA_RATE_TAS | TAS 模式数据率（1/s） | 由调用者经 track_process_parameters_initial 输入；TAS 波束输出门控阈值 1/DATA_RATE_TAS 秒，≤0 时不做门控 |
| track_start_point_num | 起批点数 | 校验范围 3~9 |
| track_start_threshold / track_asso_threshold / track_asso_threshold_tas | 起批/关联波门 | **⚠ 声明但当前实现未使用**，实际门限为宏 TRACK_START_THRESHOLD / ASSO_THORD |
| Model1/2/3_Q_fast/slow | 三个 Singer 模型过程噪声强度 | Model1_Q_fast 未使用；分档规则见 9.5.1 |
---
## 11. 已知问题与限制
详见 BUG_REPORT.md（37 项分析）与 BUG_FIX_REPORT.md（修复明细）。要点：
### 11.1 已修复（BUG_FIX_REPORT.md）
- **越界/防御**：TAS Point_Sum 限幅 150（BUG-04）；size()-1 下溢（BUG-05）；起批点数校验（BUG-06）；航迹号下标校验（BUG-10）；Beam_Ctrl 输出计数清零+容量检查（BUG-09）；消亡空向量保护（BUG-34）；航迹号 500 可复用（BUG-35）；局部结构体值初始化（BUG-37）。
- **时间戳/时序**：TWS/TAS 关联 ΔT≤0 拒绝（BUG-15/16）；TAS 外推负时间差跳过（BUG-17）；Bind_speed 除零保护（BUG-19）。
- **数值稳定性**：方位残差 ±π 环绕（BUG-22）；IMM 概率零分母/奇异保护（BUG-23）；EKF 似然 3×3 新息协方差（BUG-24）；航向角 atan2（BUG-26）；asin 定义域钳位（BUG-27）；近程模型 3 门限浮点除法（BUG-21）；track_clear_all 全模块 reset（BUG-28）；未初始化变量修复（BUG-11/12/14）。
### 11.2 有意保留 / 未修复（标注于 BUG_REPORT）
- **BUG-01**：基类无虚析构，Destroy() 按基类指针 delete。
- **BUG-02**：Hight_smooth 只增不减，长时运行内存持续增长。
- **BUG-03**：工厂 GetB/Destroy 非线程安全，接口线程模型未定义（宿主应单线程调用）。
- **BUG-07**：禁止区个数未限制在 30 内，配置过大越界读。
- **BUG-08**：消亡航迹输出数组容量未传入，仅约定 ≤500。
- **BUG-13**：Work_Parameter 等成员构造后未初始化，必须先调 track_process_parameters_initial 再处理。
- **BUG-18**：卡尔曼两点/三点初始化对零/负时间差无保护（起批时间戳必须严格递增）。
- **BUG-20**：门限对马氏距离平方再次平方（等效 d<3），有意保留。
- **BUG-25**：TWS 关联/输出未排除 Track_Mode==1 的 TAS 航迹（原过滤逻辑被注释）。
- **BUG-29**：tracking_stop 后 TAS 队列项延迟到下一次 Beam_Ctrl 才移除。
- **BUG-33**：起批关联未显式校验 ΔT>0。
- **BUG-36**：TAS 波束关闭时只清 open_flag，其余字段保留旧值。
### 11.3 未启用功能
- direct_tracking_process（引导跟踪）、tracking_point（手动打波束）为**空实现**；Track_Init_Direct_Tracking::track_init_process_logic 同样为空。
- track_asso_direct_tracking.cpp **未加入 CMake 源列表**（与旧 .pro 一致）。
- TAS **自动**开启/退出逻辑（tas_auto_start/tas_auto_end）注释停用，仅支持手动 tracking_start/tracking_stop。
- RadarPara 中的起批/关联波门字段未被实现读取（见 10.2）。
- build/output/ 下为早期打包导出物，其 data_process_class_dll.h 时间戳仍为 32 位 int，与当前 64 位接口不一致，勿作为对接依据。
---
## 12. 版本历史
近期提交（git log --oneline，新→旧）：
| 提交 | 内容 |
|---|---|
| 3500652 | 去掉 1 km 以内航迹起批的 20 dB 信噪比门限 |
| 01d28e0 | 改用 VS Code + CMake 重新编译（编译器不变）；修复若干逻辑 BUG（见 BUG_FIX_REPORT.md） |
| 0cb31b4 | 删除不必要文件；输入点迹/输出航迹的 CPI 与 GNSS 时间改为 64 位整型；修复 TAS 外推时间差可能无效的问题 |
| d101fe9 | 增加航迹清空功能（解决重连乱窜）；TAS 外推时间间隔按波束时间计算；增加 1 km 内 SNR<20 dB 不起批限制（后于 3500652 移除） |
| 8636179 | 机扫/相扫程序合并，宏定义配置切换 |
| 06d45f5 | 机扫跟踪增加高度门限判断 |
| 8b1896d | 适配四面阵机扫跟踪模式 |
| ae3ef84 | 扫描一圈完成判断改为「波位号变小」 |
| e9b8a32 | 修复 R 矩阵赋值、波位号判断、点数上限、空容器、雅可比取值、起批负索引、容器 push_back 后修改失效、机扫参数等 8 项 |
| 28fcf06 | 统一代码缩进格式 |
| 7c10ae9 / 958ff6b | TWS 关联增加俯仰门限 / 点航距离门限（限制远距离突跳关联） |
| 2b1293a / 167fa79 | 去掉自动转 TAS，只保留手动转 TAS；起批时手动转跟踪标志清零 |
| 6008959 | 添加「航迹点迹区分区说明.vsdx」（后随 0cb31b4 删除不必要文件而移除） |
| d6e43d6 / 199ae34 | 点迹凝聚角度约束调整；凝聚条件按模式区分（近程：距离/速度/方位；中远程：距离/方位） |
| 06938b2 | 航迹起始增加屏蔽区域 |
---
## 13. 参考文档
| 文档 | 内容 |
|---|---|
| BUG_REPORT.md | 全量逻辑 BUG 分析（P0~P3 共 37 项，含位置、说明、建议、处置结论） |
| BUG_FIX_REPORT.md | 本次修复明细、修复状态汇总表与 MSVC 2013 x86 编译验证记录 |
| backup/data_process_class_dll/data_process_class_dll.pro | 迁移前的 Qt/qmake 工程文件（源文件清单参考） |
| .vscode/tasks.json、.vscode/cmake-variants.yaml | VS Code 构建任务与变体定义 |
| build/X256_PS/bin/RadarConfigParam.ini | 回放测试工具（rdp_playback.exe）配置样例 |
data_process_class_dll/data_process_class_dll.pro → backup/data_process_class_dll/data_process_class_dll.pro
View File
data_process_class_dll/data_process_class_dll.pro.user → backup/data_process_class_dll/data_process_class_dll.pro.user
+13 -67
View File
@@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE QtCreatorProject> <!DOCTYPE QtCreatorProject>
<!-- Written by QtCreator 4.0.2, 2026-07-06T14:25:51. --> <!-- Written by QtCreator 4.0.2, 2026-08-14T14:09:13. -->
<qtcreator> <qtcreator>
<data> <data>
<variable>EnvironmentId</variable> <variable>EnvironmentId</variable>
@@ -64,65 +64,11 @@
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop Qt 5.7.0 MSVC2013 32bit</value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop Qt 5.7.0 MSVC2013 32bit</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Desktop Qt 5.7.0 MSVC2013 32bit</value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Desktop Qt 5.7.0 MSVC2013 32bit</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">qt.57.win32_msvc2013_kit</value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">qt.57.win32_msvc2013_kit</value>
<value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">1</value> <value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">0</value>
<value type="int" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value> <value type="int" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
<value type="int" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value> <value type="int" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0"> <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">E:/data_process_qt_vision_2003/build-data_process_class_dll-Desktop_Qt_5_7_0_MSVC2013_32bit-Debug</value> <value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">E:/Demo/QT/simianzhen256-v1.5.5-ms/build/X256_PS</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">true</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Debug</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">2</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.1">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">E:/Demo/QT/simianzhen256-v1.5.5-ms/build</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0"> <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0"> <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value> <value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
@@ -130,7 +76,7 @@
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value> <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value> <value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments">&quot;DEFINES += PHASE_SCANNING&quot;</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value> <value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">false</value> <value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value> <value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
@@ -170,23 +116,23 @@
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value> <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/> <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Release</value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Release</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">X256_PS</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value> <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value> <value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
</valuemap> </valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.2"> <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.1">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">E:/data_process_qt_vision_2003/build-data_process_class_dll-Desktop_Qt_5_7_0_MSVC2013_32bit-Profile</value> <value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">E:/Demo/QT/simianzhen256-v1.5.5-ms/build/X256_MS</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0"> <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0"> <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value> <value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">true</value> <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value> <value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments">&quot;DEFINES += MECHANICAL_SCANNING&quot;</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value> <value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">true</value> <value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value> <value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
</valuemap> </valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1"> <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
@@ -223,13 +169,13 @@
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value> <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value> <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/> <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Profile</value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Release</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">X256_MS</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value> <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value> <value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
</valuemap> </valuemap>
<value type="int" key="ProjectExplorer.Target.BuildConfigurationCount">3</value> <value type="int" key="ProjectExplorer.Target.BuildConfigurationCount">2</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.DeployConfiguration.0"> <valuemap type="QVariantMap" key="ProjectExplorer.Target.DeployConfiguration.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0"> <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">0</value> <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">0</value>
build/Makefile
-410
View File
@@ -1,410 +0,0 @@
#############################################################################
# Makefile for building: data_process_class_dll
# Generated by qmake (3.0) (Qt 5.7.0)
# Project: ..\data_process_class_dll\data_process_class_dll.pro
# Template: lib
# Command: D:\APP\QT5_7\5.7\msvc2013\bin\qmake.exe -spec win32-msvc2013 -o Makefile ..\data_process_class_dll\data_process_class_dll.pro
#############################################################################
MAKEFILE = Makefile
first: release
install: release-install
uninstall: release-uninstall
QMAKE = D:\APP\QT5_7\5.7\msvc2013\bin\qmake.exe
DEL_FILE = del
CHK_DIR_EXISTS= if not exist
MKDIR = mkdir
COPY = copy /y
COPY_FILE = copy /y
COPY_DIR = xcopy /s /q /y /i
INSTALL_FILE = copy /y
INSTALL_PROGRAM = copy /y
INSTALL_DIR = xcopy /s /q /y /i
DEL_FILE = del
SYMLINK = $(QMAKE) -install ln -f -s
DEL_DIR = rmdir
MOVE = move
SUBTARGETS = \
release \
debug
release: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Release
release-make_first: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Release
release-all: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Release all
release-clean: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Release clean
release-distclean: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Release distclean
release-install: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Release install
release-uninstall: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Release uninstall
debug: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Debug
debug-make_first: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Debug
debug-all: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Debug all
debug-clean: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Debug clean
debug-distclean: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Debug distclean
debug-install: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Debug install
debug-uninstall: FORCE
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Debug uninstall
Makefile: ..\data_process_class_dll\data_process_class_dll.pro D:\APP\QT5_7\5.7\msvc2013\mkspecs\win32-msvc2013\qmake.conf D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\spec_pre.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\common\angle.conf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\common\msvc-base.conf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\common\msvc-desktop.conf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\qconfig.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dcore.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dcore_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dextras.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dextras_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dinput.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dinput_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dlogic.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dlogic_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dquick.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dquick_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickextras.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickextras_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickinput.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickinput_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickrender.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickrender_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3drender.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3drender_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_axbase.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_axbase_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_axcontainer.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_axcontainer_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_axserver.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_axserver_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_bluetooth.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_bluetooth_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_bootstrap_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_clucene_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_concurrent.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_concurrent_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_core.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_core_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_dbus.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_dbus_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_designer.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_designer_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_designercomponents_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_gui.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_gui_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_help.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_help_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_location.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_location_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_multimedia.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_multimedia_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_multimediawidgets.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_multimediawidgets_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_network.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_network_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_nfc.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_nfc_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_opengl.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_opengl_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_openglextensions.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_openglextensions_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_packetprotocol_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_platformsupport_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_positioning.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_positioning_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_printsupport.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_printsupport_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_qml.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_qml_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_qmldebug_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_qmldevtools_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_qmltest.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_qmltest_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_qtmultimediaquicktools_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_quick.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_quick_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_quickcontrols2.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_quickcontrols2_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_quickparticles_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_quicktemplates2_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_quickwidgets.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_quickwidgets_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_script.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_script_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_scripttools.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_scripttools_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_scxml.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_scxml_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_sensors.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_sensors_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_serialbus.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_serialbus_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_serialport.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_serialport_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_sql.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_sql_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_svg.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_svg_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_testlib.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_testlib_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_uiplugin.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_uitools.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_uitools_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webchannel.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webchannel_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webengine.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webengine_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webenginecore.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webenginecore_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webenginecoreheaders_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webenginewidgets.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webenginewidgets_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_websockets.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_websockets_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webview.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webview_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_widgets.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_widgets_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_winextras.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_winextras_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_xml.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_xml_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_xmlpatterns.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_xmlpatterns_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_zlib_private.pri \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\qt_functions.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\qt_config.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\win32\qt_config.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\win32-msvc2013\qmake.conf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\spec_post.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\exclusive_builds.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\default_pre.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\win32\default_pre.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\resolve_config.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\exclusive_builds_post.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\default_post.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\win32\rtti.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\precompile_header.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\warn_on.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\qt.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\resources.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\moc.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\file_copies.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\win32\windows.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\testcase_targets.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\exceptions.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\yacc.prf \
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\lex.prf \
..\data_process_class_dll\data_process_class_dll.pro \
D:\APP\QT5_7\5.7\msvc2013\lib\Qt5Core.prl
$(QMAKE) -spec win32-msvc2013 -o Makefile ..\data_process_class_dll\data_process_class_dll.pro
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\spec_pre.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\common\angle.conf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\common\msvc-base.conf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\common\msvc-desktop.conf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\qconfig.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dcore.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dcore_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dextras.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dextras_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dinput.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dinput_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dlogic.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dlogic_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dquick.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dquick_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickextras.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickextras_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickinput.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickinput_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickrender.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3dquickrender_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3drender.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_3drender_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_axbase.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_axbase_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_axcontainer.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_axcontainer_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_axserver.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_axserver_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_bluetooth.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_bluetooth_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_bootstrap_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_clucene_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_concurrent.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_concurrent_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_core.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_core_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_dbus.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_dbus_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_designer.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_designer_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_designercomponents_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_gui.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_gui_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_help.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_help_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_location.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_location_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_multimedia.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_multimedia_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_multimediawidgets.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_multimediawidgets_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_network.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_network_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_nfc.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_nfc_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_opengl.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_opengl_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_openglextensions.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_openglextensions_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_packetprotocol_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_platformsupport_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_positioning.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_positioning_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_printsupport.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_printsupport_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_qml.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_qml_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_qmldebug_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_qmldevtools_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_qmltest.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_qmltest_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_qtmultimediaquicktools_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_quick.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_quick_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_quickcontrols2.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_quickcontrols2_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_quickparticles_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_quicktemplates2_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_quickwidgets.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_quickwidgets_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_script.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_script_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_scripttools.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_scripttools_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_scxml.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_scxml_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_sensors.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_sensors_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_serialbus.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_serialbus_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_serialport.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_serialport_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_sql.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_sql_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_svg.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_svg_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_testlib.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_testlib_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_uiplugin.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_uitools.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_uitools_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webchannel.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webchannel_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webengine.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webengine_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webenginecore.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webenginecore_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webenginecoreheaders_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webenginewidgets.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webenginewidgets_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_websockets.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_websockets_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webview.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_webview_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_widgets.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_widgets_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_winextras.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_winextras_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_xml.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_xml_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_xmlpatterns.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_xmlpatterns_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\modules\qt_lib_zlib_private.pri:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\qt_functions.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\qt_config.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\win32\qt_config.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\win32-msvc2013\qmake.conf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\spec_post.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\exclusive_builds.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\default_pre.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\win32\default_pre.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\resolve_config.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\exclusive_builds_post.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\default_post.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\win32\rtti.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\precompile_header.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\warn_on.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\qt.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\resources.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\moc.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\file_copies.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\win32\windows.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\testcase_targets.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\exceptions.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\yacc.prf:
D:\APP\QT5_7\5.7\msvc2013\mkspecs\features\lex.prf:
..\data_process_class_dll\data_process_class_dll.pro:
D:\APP\QT5_7\5.7\msvc2013\lib\Qt5Core.prl:
qmake: FORCE
@$(QMAKE) -spec win32-msvc2013 -o Makefile ..\data_process_class_dll\data_process_class_dll.pro
qmake_all: FORCE
make_first: release-make_first debug-make_first FORCE
all: release-all debug-all FORCE
clean: release-clean debug-clean FORCE
-$(DEL_FILE) data_process_class_dll.exp
distclean: release-distclean debug-distclean FORCE
-$(DEL_FILE) Makefile
-$(DEL_FILE) data_process_class_dll.lib
release-mocclean:
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Release mocclean
debug-mocclean:
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Debug mocclean
mocclean: release-mocclean debug-mocclean
release-mocables:
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Release mocables
debug-mocables:
@set MAKEFLAGS=$(MAKEFLAGS)
$(MAKE) -f $(MAKEFILE).Debug mocables
mocables: release-mocables debug-mocables
check: first
benchmark: first
FORCE:
$(MAKEFILE).Release: Makefile
$(MAKEFILE).Debug: Makefile
build/Makefile.Debug
-2908
View File
File diff suppressed because one or more lines are too long
build/Makefile.Release
-2908
View File
File diff suppressed because one or more lines are too long
build/output/data_process_class_dll.dll
BIN
View File
Binary file not shown.
build/output/data_process_class_dll.h
-285
View File
@@ -1,285 +0,0 @@
#pragma once
#ifndef DATA_PROCESS_CLASS_DLL_H
#define DATA_PROCESS_CLASS_DLL_H
#include "data_process_class_dll_global.h"
/***************************************************** 结构体 ********************************************************/
// 输入点迹的数据结构 用户可见
struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT DataRev
{
float Range; //径向距离 （米）
float Azimuth; //方位 （度）
float Elevation; //俯仰 （度）
float Velocity; //速度 （m/s）
float Amplitude; //幅度
float Threshold; //目标门限
float Snr; //目标信噪比
float RCS; //目标RCS
float Encoder_value; //码盘值
int CPI_time; //CPI时间 该波位无点迹输入时也需要给出当前时间
int Beam_index_azi_0; //上一个cpi波位
int Beam_index_aiz; //方位波位号（0-24） 该波位无输入点迹时 也需要给出当前波位
int Beam_index_elev; //俯仰波位号（0-13）
int PRI; //PRI(us) 给0
int Freq_index; //频点号 给0
int Point_Sum; //输入点迹总数 若该波位无点迹输入 置为0
int Point_Num; //点迹号(1,2,3,4...)
int UseFlag; //点迹使用标记 使用1/未使用0 主程序存入数据时置为0
int TAS_track_index; //TAS的航迹号
int point_type; //点迹类型 TAS 1/TWS 0
int pitch_num; // 俯仰波位号
float speed_dim[129]; // 目标的十字星数据,目标点速度维129个点
float range_dim[8]; // 目标的十字星数据,目标点距离维8个点
};
//输出航迹的数据结构 用户可见
struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT Track
{
float x; //x坐标
float y; //y坐标
float z; //z坐标
float v_x; //x速度
float v_y; //y速度
float v_z; //z速度
float Range; //径向距离
float Azimuth; //方位
float Elevation; //俯仰
float Range_V; //速度
float Amplitude; //幅度
int Track_Index; //航迹号
int Point_Sum; //本条航迹更新点的数目
int Flag_Direction; //方向标志1靠近/0远离
int Flag_Point; //点迹类型1实点/0补点
float x_Predict; //x坐标的一步预测
float y_Predict; //y坐标的一步预测
float z_Predict; //z坐标的一步预测
float Range_Predict; //径向距离的一步预测
float Azimuth_Predict; //方位的一步预测
float Elevation_Predict; //俯仰的一步预测
int Track_Mode; //跟踪模式,TAS 1/TWS 0
float Direction_Angle; //目标航向角
int Target_Type; //目标类型
int point_type; //点迹类型 TAS 1/TWS 0
float range_point; //关联上的点迹信息（距离、方位、俯仰、径向速度）
float azi_point;
float elev_point;
float vr_point;
float prf_point;
float track_time; //航迹时间 (单位 s)
float track_snr; //信噪比
float track_rcs; //rcs
int pitch_num; // 俯仰波位号
float speed_dim[129]; // 目标的十字星数据,目标点速度维129个点
float range_dim[8]; // 目标的十字星数据,目标点距离维8个点
};
// 跟踪波束信息的结构体
struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT TrackingBeam
{
int open_flag; //是否开启 1开启 0不开启
int type; //类型
float Range; //跟踪目标距离
float Azi; //跟踪目标方位
float Elev; //跟踪目标俯仰
int TAS_track_index; //目标批号
};
//引导跟踪信息的结构体
struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT Target_direct_tracking
{
int Track_ID; //引导目标批号
float Range; //引导目标距离
float Azi; //引导目标方位
float Elev; //引导目标俯仰
int open_flag; // 1 引导跟踪 0 结束引导跟踪
};
// 雷达参数结构体
struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT RadarPara
{
int Beam_num; //波位数
float Height; //雷达平台高度 （m）
float Sys_delay; //系统延迟 (s)
float R_TAS_max; //TAS最大距离 （m）
float R_TAS_min; //TAS最小距离 (m)
float V_TAS_max; //TAS最大速度 (m/s)
float V_TAS_min; //TAS最小速度 (m/s)
float TAS_Height_1; //TAS跟踪高度1 (m)
float TAS_Height_2; //TAS跟踪高度2 (m)
float TAS_Height_3; //TAS跟踪高度3 (m)
float TAS_Height_4; //TAS跟踪高度4 (m)
float TAS_Height_5; //TAS跟踪高度5 (m)
int track_prohibite_area_num; //禁止航迹起始的区域数目
float R_max_track_prohibited[30]; //最大距离 (m)
float R_min_track_prohibited[30]; //最小距离 (m)
float Azimuth_max_track_prohibited[30]; //最大方位角 (度)
float Azimuth_min_track_prohibited[30]; //最小方位角 （度）
int TAS_prohibite_area_num; //禁止TAS的区域数目
float R_max_TAS_prohibited[30]; //最大距离 （m）
float R_min_TAS_prohibited[30]; //最小距离 (m)
float Azimuth_max_TAS_prohibited[30]; //最大方位角 (度)
float Azimuth_min_TAS_prohibited[30]; //最小方位角 (度)
int cfar_th; //cfar门限
int work_mode; //工作模式 0进程 1中程 3远程
int north_angle; //北偏角
float V_MAX; //最大速度
float V_MIN; //最小速度
float DATA_RATE_SHORT; //三种不同模式下的 数据率
float DATA_RATE_MIDDLE;
float DATA_RATE_FAR;
//数据关联参数
int track_start_point_num; //起批点数(典型值 3或4)
float track_start_threshold; //起航波门大小(典型值 3)
float track_asso_threshold; //关联波门大小(典型值 3)
float track_asso_threshold_tas; //关联波门大小tas (典型值 3)
//singer模型机动参数
float Model1_Q_fast; //0.00001
float Model1_Q_slow; //0.00001
float Model2_Q_fast; //0.1
float Model2_Q_slow; //0.001
float Model3_Q_fast; //0.8
float Model3_Q_slow; //0.4
};
class DATA_PROCESS_CLASS_DLLSHARED_EXPORT Data_process_class_dll
{
public:
// Data_process_class_dll();
//数据预处理函数
virtual int data_preprocess(struct DataRev Data_Input[150]) //雷达的输入点迹 主程序创建全局变量 输入数据
{
return 0;
}
//数据处理函数
virtual int track_process(struct Track Trust_Track_Output[][10], //数据处理输出的航迹更新信息 主程序创建全局变量 数据处理函数更新其中数据
int *Trust_track_num_Output, //数据处理后输出的航迹数目 主程序创建全局变量 数据处理函数更新其中数据
int Track_die_Index_Output[], //数据处理后要消亡的航迹 主程序创建全局变量 数据处理函数更新其中数据
int *Track_die_num_Output, //数据处理后要消亡的航迹数目
int model //模式 输入data_preprocess的返回值
)
{
return 0;
}
//波束控制
virtual void Beam_Ctrl(struct TrackingBeam *Tracking_beam,
struct Track Trust_Track_Output[][10],
int *Trust_track_num_Output)
{
}
//引导跟踪处理函数
virtual int direct_tracking_process(struct Target_direct_tracking Target_direct_info, //引导信息
struct DataRev Data_Input[150], //雷达的输入点迹
struct Track Trust_Track_Output[][10], //数据处理输出的航迹更新信息 主程序创建全局变量 数据处理函数更新其中数据
int *Trust_track_num_Output, //数据处理后输出的航迹数目 主程序创建全局变量 数据处理函数更新其中数据
int Track_die_Index_Output[], //数据处理后要消亡的航迹 主程序创建全局变量 数据处理函数更新其中数据
int *Track_die_num_Output, //数据处理后要消亡的航迹数目
struct TrackingBeam *Tracking_beam //波束控制信息
)
{
return 0;
}
//航迹清空函数
virtual int track_clear_all(void)
{
return 0;
}
//手动航迹删除函数
virtual int track_delete(int delete_track_num, //手动删除的航迹数目
int delete_track_index[]) //手动删除的航迹号
{
return 0;
}
//手动转TAS跟踪函数
virtual int tracking_start(int track_index) //需要手动转入TAS跟踪的航迹号
{
return 0;
}
//手动打跟踪波束
virtual int tracking_point(float Azimuth) //方位角
{
return 0;
}
//参数设置初始化函数
virtual int track_process_parameters_initial(struct RadarPara Radar_Parameter)
{
return 0;
}
//参数设置修改函数
virtual int track_process_parameters_modify(struct RadarPara Radar_Parameter)
{
return 0;
}
};
//工厂类 用户可见
class DATA_PROCESS_CLASS_DLLSHARED_EXPORT Data_Process_Factory
{
public:
static Data_process_class_dll *GetB(); //创建
static void Destroy(); //销毁
private:
static Data_process_class_dll *p;
};
#endif // DATA_PROCESS_CLASS_DLL_H
build/output/data_process_class_dll.lib
BIN
View File
Binary file not shown.
build/output/data_process_class_dll_global.h
-26
View File
@@ -1,26 +0,0 @@
#ifndef DATA_PROCESS_CLASS_DLL_GLOBAL_H
#define DATA_PROCESS_CLASS_DLL_GLOBAL_H
#include <QtCore/qglobal.h>
#if defined(DATA_PROCESS_CLASS_DLL_LIBRARY)
# define DATA_PROCESS_CLASS_DLLSHARED_EXPORT Q_DECL_EXPORT
#else
# define DATA_PROCESS_CLASS_DLLSHARED_EXPORT Q_DECL_IMPORT
#endif
//#if defined(DATA_PROCESS_CLASS_DLL_LIBRARY)
//# define DATA_PROCESS_CLASS_DLLSHARED_EXPORT __declspec(dllexport)
//#else
//# define DATA_PROCESS_CLASS_DLLSHARED_EXPORT __declspec(dllexport)
//#endif
//#if defined(DATA_PROCESS_CLASS_DLL_LIBRARY)
//#define DATA_PROCESS_CLASS_DLLSHARED_EXPORT __declspec(dllexport)
//#else
//#define DATA_PROCESS_CLASS_DLLSHARED_EXPORT __declspec(dllimport)
//#endif
#endif // DATA_PROCESS_CLASS_DLL_GLOBAL_H
build/output/output.rar
BIN
View File
Binary file not shown.
data_process_class_dll/coor_trans.cpp
+3 -3
View File
@@ -1,7 +1,7 @@
#include "coor_trans.h" #include "coor_trans.h"
#include <qmath.h> #include <cmath>
#include"memory.h" #include <cstring>
#include <QVector> #include <vector>
using namespace std; using namespace std;
//极坐标转直角坐标 //极坐标转直角坐标
data_process_class_dll/coor_trans.h
-1
View File
@@ -10,6 +10,5 @@ public:
void cart2polar(double x, double y, double *Range, double *Azimuth); void cart2polar(double x, double y, double *Range, double *Azimuth);
}; };
#endif // COOR_TRANS_H #endif // COOR_TRANS_H
data_process_class_dll/data_process.cpp
+65 -51
View File
@@ -1,7 +1,7 @@
#include "data_process.h" #include "data_process.h"
#include "memory.h" #include <cstring>
#include <QVector> #include <vector>
#include <qmath.h> #include <cmath>
#include <iostream> #include <iostream>
using namespace std; using namespace std;
@@ -11,15 +11,17 @@ using namespace std;
/*******************************************************************************/ /*******************************************************************************/
/*******************************************************************************/ /*******************************************************************************/
//数据预处理 //数据预处理
int Data_Process::data_preprocess(struct DataRev Data_Input[150]) int Data_Process::data_preprocess(struct DataRev Data_Input[150])
{ {
// 更新当前系统时间
latest_timestamp = Data_Input[0].CPI_time;
//数据存入缓存区域 Data_buffer //数据存入缓存区域 Data_buffer
if(Data_Input[0].point_type == 0) //tws数据 if(Data_Input[0].point_type == 0) //tws数据
{ {
data_num=min(Data_Input[0].Point_Sum, 150); data_num=min(Data_Input[0].Point_Sum, 150);
//qDebug() << "TARGET azi beam idx:" <<Data_Input[0].Beam_index_aiz; //std::cout << "TARGET azi beam idx:" <<Data_Input[0].Beam_index_aiz;
for (int i=0; i<data_num;i++) for (int i=0; i<data_num;i++)
{ {
PointRecv Data_buffer_temp; PointRecv Data_buffer_temp;
@@ -28,6 +30,7 @@ int Data_Process::data_preprocess(struct DataRev Data_Input[150])
Data_buffer_temp.snr = Data_Input[i].Snr; Data_buffer_temp.snr = Data_Input[i].Snr;
Data_buffer_temp.RCS = Data_Input[i].RCS; Data_buffer_temp.RCS = Data_Input[i].RCS;
Data_buffer_temp.CPI_Time = Data_Input[i].CPI_time; Data_buffer_temp.CPI_Time = Data_Input[i].CPI_time;
Data_buffer_temp.GNSS_time = Data_Input[i].GNSS_time;
Data_buffer_temp.Freq_index = Data_Input[i].Freq_index; Data_buffer_temp.Freq_index = Data_Input[i].Freq_index;
Data_buffer_temp.PRF_index = Data_Input[i].PRI; Data_buffer_temp.PRF_index = Data_Input[i].PRI;
Data_buffer_temp.Range = Data_Input[i].Range; Data_buffer_temp.Range = Data_Input[i].Range;
@@ -45,6 +48,7 @@ int Data_Process::data_preprocess(struct DataRev Data_Input[150])
if(Data_Input[0].Beam_index_aiz < last_beam_num) //TWS if(Data_Input[0].Beam_index_aiz < last_beam_num) //TWS
{ {
last_beam_num = Data_Input[0].Beam_index_aiz; last_beam_num = Data_Input[0].Beam_index_aiz;
return 1; return 1;
} }
else else
@@ -56,11 +60,12 @@ int Data_Process::data_preprocess(struct DataRev Data_Input[150])
else if(Data_Input[0].point_type == 1) //tas数据 else if(Data_Input[0].point_type == 1) //tas数据
{ {
// qDebug() << "TAS TARGET :" <<Data_Input[0].TAS_track_index; // std::cout << "TAS TARGET :" <<Data_Input[0].TAS_track_index;
// qDebug() << "TAS POINT :" <<Data_Input[0].Point_Sum; //std::cout << "TAS time :" <<Data_Input[0].CPI_time;
data_num=Data_Input[0].Point_Sum; data_num = min(max(Data_Input[0].Point_Sum, 0), 150);
TAS_track_idx = Data_Input[0].TAS_track_index; TAS_track_idx = Data_Input[0].TAS_track_index;
latest_timestamp = Data_Input[0].CPI_time;
for (int i=0; i<data_num;i++) for (int i=0; i<data_num;i++)
{ {
PointRecv Data_buffer_temp; PointRecv Data_buffer_temp;
@@ -69,6 +74,7 @@ int Data_Process::data_preprocess(struct DataRev Data_Input[150])
Data_buffer_temp.snr = Data_Input[i].Snr; Data_buffer_temp.snr = Data_Input[i].Snr;
Data_buffer_temp.RCS = Data_Input[i].RCS; Data_buffer_temp.RCS = Data_Input[i].RCS;
Data_buffer_temp.CPI_Time = Data_Input[i].CPI_time; Data_buffer_temp.CPI_Time = Data_Input[i].CPI_time;
Data_buffer_temp.GNSS_time = Data_Input[i].GNSS_time;
Data_buffer_temp.Freq_index = Data_Input[i].Freq_index; Data_buffer_temp.Freq_index = Data_Input[i].Freq_index;
Data_buffer_temp.PRF_index = Data_Input[i].PRI; Data_buffer_temp.PRF_index = Data_Input[i].PRI;
Data_buffer_temp.Range = Data_Input[i].Range; Data_buffer_temp.Range = Data_Input[i].Range;
@@ -81,7 +87,7 @@ int Data_Process::data_preprocess(struct DataRev Data_Input[150])
Data_buffer_tas.push_back(Data_buffer_temp); Data_buffer_tas.push_back(Data_buffer_temp);
// qDebug() << "Azimuth:" << Data_Input[i].Azimuth // std::cout << "Azimuth:" << Data_Input[i].Azimuth
// << "Range:" << Data_Input[i].Range // << "Range:" << Data_Input[i].Range
// << "EL:" << Data_Input[i].Elevation // << "EL:" << Data_Input[i].Elevation
// << "CPI_Time"<< Data_Input[i].CPI_time // << "CPI_Time"<< Data_Input[i].CPI_time
@@ -99,8 +105,6 @@ int Data_Process::data_preprocess(struct DataRev Data_Input[150])
} }
//数据处理 //数据处理
int Data_Process::track_process(struct Track Trust_Track_Output[MAX_TRACK_NUM][10], int Data_Process::track_process(struct Track Trust_Track_Output[MAX_TRACK_NUM][10],
int *Trust_track_num_Output, int *Trust_track_num_Output,
@@ -114,12 +118,10 @@ int Data_Process::track_process(struct Track Trust_Track_Output[MAX_TRACK_NUM][1
{ {
dot_coh.dot_coh_process_buff(&Data_buffer,&point_recv,Work_Parameter); dot_coh.dot_coh_process_buff(&Data_buffer,&point_recv,Work_Parameter);
//qDebug() << "point_recv :" <<point_recv.size(); //std::cout << "point_recv :" <<point_recv.size();
QVector<PointRecv>().swap(Data_buffer); std::vector<PointRecv>().swap(Data_buffer);
} }
if(model==1) if(model==1)
{ {
*Trust_track_num_Output=0; //航迹更新数 *Trust_track_num_Output=0; //航迹更新数
@@ -142,11 +144,11 @@ int Data_Process::track_process(struct Track Trust_Track_Output[MAX_TRACK_NUM][1
Trust_Track_Output, Trust_Track_Output,
Trust_track_num_Output, Trust_track_num_Output,
Work_Parameter); Work_Parameter);
// qDebug() << "point_recv: " <<point_recv.size(); // std::cout << "point_recv: " <<point_recv.size();
// qDebug() << "trust_track: " <<trust_track.size(); // std::cout << "trust_track: " <<trust_track.size();
// qDebug() << "temp_track: " <<temp_track.size(); // std::cout << "temp_track: " <<temp_track.size();
// qDebug() << "Trust_track_num_Output: " <<*Trust_track_num_Output; // std::cout << "Trust_track_num_Output: " <<*Trust_track_num_Output;
// qDebug() << "Track_die_num_Output: " <<*Track_die_num_Output; // std::cout << "Track_die_num_Output: " <<*Track_die_num_Output;
} }
@@ -160,83 +162,85 @@ int Data_Process::track_process(struct Track Trust_Track_Output[MAX_TRACK_NUM][1
// if(point_recv_tas.size()>0) // if(point_recv_tas.size()>0)
// { // {
// qDebug() << "point_recv_tas :" <<point_recv_tas[0].Azimuth/PI*180<<" "<<point_recv_tas[0].Range; // std::cout << "point_recv_tas :" <<point_recv_tas[0].Azimuth/PI*180<<" "<<point_recv_tas[0].Range;
// } // }
//std::cout << "TAS process :" << TAS_track_idx << "p a r:"<<point_recv_tas[0].Point_Sum<<" " <<point_recv_tas[0].Azimuth/PI*180<<" "<<point_recv_tas[0].Range;
std::vector<PointRecv>().swap(Data_buffer_tas);//凝聚完毕 清除Data_buffer
QVector<PointRecv>().swap(Data_buffer_tas);//凝聚完毕 清除Data_buffer
track_asso_tas.track_asso_process_tas(&point_recv_tas, //点迹文件 track_asso_tas.track_asso_process_tas(&point_recv_tas, //点迹文件
&trust_track, //航迹文件 &trust_track, //航迹文件
Trust_Track_Output, //更新航迹信息 Trust_Track_Output, //更新航迹信息
Trust_track_num_Output, //更新航迹数 Trust_track_num_Output, //更新航迹数
Work_Parameter, //工作参数 Work_Parameter, //工作参数
TAS_track_idx); TAS_track_idx,
latest_timestamp //最新时间戳
);
std::vector<PointRecv>().swap(point_recv_tas); //清除 point_recv_tas
QVector<PointRecv>().swap(point_recv_tas); //清除 point_recv_tas
track_die_tas.track_die_process_tas( &trust_track, track_die_tas.track_die_process_tas( &trust_track,
Track_die_Index_Output, Track_die_Index_Output,
Track_die_num_Output); Track_die_num_Output);
//std::cout << "Extrapolate_round :" << trust_track[TAS_track_idx].Extrapolate_round;
} }
return 1; return 1;
} }
//波束控制 //波束控制
void Data_Process::Beam_Ctrl(struct TrackingBeam *Tracking_beam, void Data_Process::Beam_Ctrl(struct TrackingBeam *Tracking_beam,
struct Track Trust_Track_Output[][10], struct Track Trust_Track_Output[][10],
int *Trust_track_num_Output) int *Trust_track_num_Output)
{ {
tas_ctrl.tas_ctrl_process(&trust_track,Tracking_beam, Trust_Track_Output, Trust_track_num_Output,Work_Parameter); tas_ctrl.tas_ctrl_process(&trust_track,Tracking_beam, Trust_Track_Output, Trust_track_num_Output,Work_Parameter, latest_timestamp);
} }
//数据处理参数初始化 //数据处理参数初始化
int Data_Process::track_process_parameters_initial(struct RadarPara Radar_Parameter) int Data_Process::track_process_parameters_initial(struct RadarPara Radar_Parameter)
{ {
//工作参数设置 //工作参数设置
if (Radar_Parameter.track_start_point_num < 3 || Radar_Parameter.track_start_point_num > 9)
return -1;
memcpy(&Work_Parameter, &Radar_Parameter, sizeof(RadarPara)); memcpy(&Work_Parameter, &Radar_Parameter, sizeof(RadarPara));
return 0; return 0;
} }
//数据处理参数修改 //数据处理参数修改
int Data_Process::track_process_parameters_modify(struct RadarPara Radar_Parameter) int Data_Process::track_process_parameters_modify(struct RadarPara Radar_Parameter)
{ {
if (Radar_Parameter.track_start_point_num < 3 || Radar_Parameter.track_start_point_num > 9)
return -1;
memcpy(&Work_Parameter, &Radar_Parameter, sizeof(RadarPara)); memcpy(&Work_Parameter, &Radar_Parameter, sizeof(RadarPara));
return 0; return 0;
} }
//航迹清空函数 //航迹清空函数
int Data_Process::track_clear_all(void) int Data_Process::track_clear_all(void)
{ {
//清空可靠航迹 //清空可靠航迹
Data_buffer.clear();
Data_buffer_tas.clear();
point_recv.clear();
point_recv_tas.clear();
trust_track.clear();
temp_track.clear();
// 同步清理内部缓存和状态，避免重连后输出幽灵航迹/幽灵波束
dot_coh.reset();
track_asso.reset();
track_asso_tas.reset();
track_init.reset();
tas_ctrl.reset();
last_beam_num = INT_MAX;
return 0; return 0;
} }
//手动航迹删除函数 //手动航迹删除函数
int Data_Process:: track_delete(int delete_track_num, //手动删除的航迹数目 int Data_Process:: track_delete(int delete_track_num, //手动删除的航迹数目
int delete_track_index[]) //手动删除的航迹号 int delete_track_index[]) //手动删除的航迹号
@@ -249,12 +253,12 @@ int Data_Process:: track_delete(int delete_track_num, //手动
{ {
trust_track[j].manual_delete_flag=1; trust_track[j].manual_delete_flag=1;
std::cout << "Delete :" << trust_track[j].Track_Index << std::endl;
} }
} }
} }
return 0; return 0;
} }
@@ -268,17 +272,27 @@ int Data_Process:: tracking_start(int track_index) //需要手动
trust_track[i].manual_tracking_flag = 1; trust_track[i].manual_tracking_flag = 1;
} }
return 0;
}
//手动取消TAS跟踪函数
int Data_Process:: tracking_stop(int track_index) //需要手动转入TAS跟踪的航迹号
{
for ( int i=0; i<trust_track.size();i++){
if(trust_track[i].Track_Index==track_index)
{
trust_track[i].manual_tracking_flag = 0;
trust_track[i].Track_Mode = 0;
}
}
return 0; return 0;
} }
//手动打跟踪波束 //手动打跟踪波束
int Data_Process::tracking_point(float Azimuth)//方位角 int Data_Process::tracking_point(float Azimuth)//方位角（当前接口未启用，保留空实现）
{ {
return 0; return 0;
} }
data_process_class_dll/data_process.h
+14 -15
View File
@@ -12,9 +12,10 @@
#include "track_die.h" #include "track_die.h"
#include "track_die_tas.h" #include "track_die_tas.h"
#include "tas_ctrl.h" #include "tas_ctrl.h"
#include <QVector> #include <vector>
#include <climits>
#include <Eigen/Dense> #include <Eigen/Dense>
#include <QDebug>
using namespace Eigen; using namespace Eigen;
using namespace std; using namespace std;
@@ -29,7 +30,6 @@ public:
} }
//数据预处理函数 //数据预处理函数
int data_preprocess(struct DataRev Data_Input[150]); int data_preprocess(struct DataRev Data_Input[150]);
@@ -49,7 +49,6 @@ public:
//航迹清空函数 //航迹清空函数
int track_clear_all(void); int track_clear_all(void);
//手动航迹删除函数 //手动航迹删除函数
int track_delete(int delete_track_num, //手动删除的航迹数目 int track_delete(int delete_track_num, //手动删除的航迹数目
int delete_track_index[]); //手动删除的航迹号 int delete_track_index[]); //手动删除的航迹号
@@ -57,6 +56,9 @@ public:
//手动转TAS跟踪函数 //手动转TAS跟踪函数
int tracking_start(int track_index); //需要手动转入TAS跟踪的航迹号 int tracking_start(int track_index); //需要手动转入TAS跟踪的航迹号
//手动取消TAS跟踪函数
int tracking_stop(int track_index); //需要取消TAS跟踪的航迹号
//手动打跟踪波束 //手动打跟踪波束
int tracking_point(float Azimuth); //方位角 int tracking_point(float Azimuth); //方位角
@@ -66,17 +68,15 @@ public:
//参数设置修改函数 //参数设置修改函数
int track_process_parameters_modify(struct RadarPara Radar_Parameter); int track_process_parameters_modify(struct RadarPara Radar_Parameter);
private: private:
QVector <PointRecv> Data_buffer; //接收点迹 TWS 输入凝聚 std::vector <PointRecv> Data_buffer; //接收点迹 TWS 输入凝聚
QVector <PointRecv> Data_buffer_tas; //接收点迹 TAS 输入凝聚 std::vector <PointRecv> Data_buffer_tas; //接收点迹 TAS 输入凝聚
QVector <PointRecv> point_recv; //凝聚后输出的点迹 按点迹区存入 输入航迹关联、起始
QVector <PointRecv> point_recv_tas; //凝聚后输出的点迹 TAS
QVector <Trust_Track> trust_track; //可靠航迹 按航迹区存入
QVector <QVector<Temp_track>> temp_track; //临时航迹 按临时航迹区存入
std::vector <PointRecv> point_recv; //凝聚后输出的点迹 按点迹区存入 输入航迹关联、起始
std::vector <PointRecv> point_recv_tas; //凝聚后输出的点迹 TAS
std::vector <Trust_Track> trust_track; //可靠航迹 按航迹区存入
std::vector <std::vector<Temp_track>> temp_track; //临时航迹 按临时航迹区存入
int Beam_num; //波位数 int Beam_num; //波位数
int beam_count; //波位计数 int beam_count; //波位计数
@@ -88,8 +88,9 @@ private:
int Track_Mode; //跟踪模式 1TAS 0TWS int Track_Mode; //跟踪模式 1TAS 0TWS
int last_beam_num = INT_MIN; //上一个波位号，用于判断是否搜索完一圈 int last_beam_num = INT_MAX; //上一个波位号，用于判断是否搜索完一圈
long long latest_timestamp = 0; //最新时间戳
struct RadarPara Work_Parameter; //工作参数 参数设置函数外部输入 struct RadarPara Work_Parameter; //工作参数 参数设置函数外部输入
@@ -111,6 +112,4 @@ private:
}; };
#endif // DATA_PROCESS_H #endif // DATA_PROCESS_H
data_process_class_dll/data_process_class_dll.cpp
+2 -1
View File
@@ -1,4 +1,6 @@
#ifndef DATA_PROCESS_CLASS_DLL_LIBRARY
#define DATA_PROCESS_CLASS_DLL_LIBRARY #define DATA_PROCESS_CLASS_DLL_LIBRARY
#endif
#include "data_process_class_dll.h" #include "data_process_class_dll.h"
#include "data_process.h" #include "data_process.h"
@@ -8,7 +10,6 @@ Data_process_class_dll::Data_process_class_dll()
} }
*/ */
Data_process_class_dll *Data_Process_Factory::p = 0; Data_process_class_dll *Data_Process_Factory::p = 0;
Data_process_class_dll *Data_Process_Factory::GetB() Data_process_class_dll *Data_Process_Factory::GetB()
data_process_class_dll/data_process_class_dll.h
+14 -29
View File
@@ -17,11 +17,12 @@ struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT DataRev
float Snr; //目标信噪比 float Snr; //目标信噪比
float RCS; //目标RCS float RCS; //目标RCS
float Encoder_value; //码盘值 float Encoder_value; //码盘值
int CPI_time; //CPI时间 该波位无点迹输入时也需要给出当前时间 long long CPI_time; //CPI时间 该波位无点迹输入时也需要给出当前时间
long long GNSS_time; //GNSS时间
int Beam_index_azi_0; //上一个cpi波位 int Beam_index_azi_0; //上一个cpi波位
int Beam_index_aiz; //方位波位号（0-24） 该波位无输入点迹时 也需要给出当前波位 int Beam_index_aiz; //方位波位号（0-24） 该波位无输入点迹时 也需要给出当前波位
int Beam_index_elev; //俯仰波位号（0-13） int Beam_index_elev; //俯仰波位号（0-13）
int PRI; //PRI(us) 给0 int PRI; //PRI(us) 不允许为0
int Freq_index; //频点号 给0 int Freq_index; //频点号 给0
int Point_Sum; //输入点迹总数 若该波位无点迹输入 置为0 int Point_Sum; //输入点迹总数 若该波位无点迹输入 置为0
int Point_Num; //点迹号(1,2,3,4...) int Point_Num; //点迹号(1,2,3,4...)
@@ -33,7 +34,6 @@ struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT DataRev
float range_dim[8]; // 目标的十字星数据,目标点距离维8个点 float range_dim[8]; // 目标的十字星数据,目标点距离维8个点
}; };
//输出航迹的数据结构 用户可见 //输出航迹的数据结构 用户可见
struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT Track struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT Track
{ {
@@ -75,12 +75,11 @@ struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT Track
float track_rcs; //rcs float track_rcs; //rcs
int pitch_num; // 俯仰波位号 int pitch_num; // 俯仰波位号
long long GNSS_time; //GNSS时间
float speed_dim[129]; // 目标的十字星数据,目标点速度维129个点 float speed_dim[129]; // 目标的十字星数据,目标点速度维129个点
float range_dim[8]; // 目标的十字星数据,目标点距离维8个点 float range_dim[8]; // 目标的十字星数据,目标点距离维8个点
}; };
// 跟踪波束信息的结构体 // 跟踪波束信息的结构体
struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT TrackingBeam struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT TrackingBeam
{ {
@@ -104,8 +103,6 @@ struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT Target_direct_tracking
int open_flag; // 1 引导跟踪 0 结束引导跟踪 int open_flag; // 1 引导跟踪 0 结束引导跟踪
}; };
// 雷达参数结构体 // 雷达参数结构体
struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT RadarPara struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT RadarPara
{ {
@@ -126,14 +123,12 @@ struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT RadarPara
float TAS_Height_4; //TAS跟踪高度4 (m) float TAS_Height_4; //TAS跟踪高度4 (m)
float TAS_Height_5; //TAS跟踪高度5 (m) float TAS_Height_5; //TAS跟踪高度5 (m)
int track_prohibite_area_num; //禁止航迹起始的区域数目 int track_prohibite_area_num; //禁止航迹起始的区域数目
float R_max_track_prohibited[30]; //最大距离 (m) float R_max_track_prohibited[30]; //最大距离 (m)
float R_min_track_prohibited[30]; //最小距离 (m) float R_min_track_prohibited[30]; //最小距离 (m)
float Azimuth_max_track_prohibited[30]; //最大方位角 (度) float Azimuth_max_track_prohibited[30]; //最大方位角 (度)
float Azimuth_min_track_prohibited[30]; //最小方位角 （度） float Azimuth_min_track_prohibited[30]; //最小方位角 （度）
int TAS_prohibite_area_num; //禁止TAS的区域数目 int TAS_prohibite_area_num; //禁止TAS的区域数目
float R_max_TAS_prohibited[30]; //最大距离 （m） float R_max_TAS_prohibited[30]; //最大距离 （m）
float R_min_TAS_prohibited[30]; //最小距离 (m) float R_min_TAS_prohibited[30]; //最小距离 (m)
@@ -142,7 +137,7 @@ struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT RadarPara
int cfar_th; //cfar门限 int cfar_th; //cfar门限
int work_mode; //工作模式 0进程 1中程 3远程 int work_mode; //工作模式 0进程 1中程 2远程
int north_angle; //北偏角 int north_angle; //北偏角
float V_MAX; //最大速度 float V_MAX; //最大速度
@@ -152,6 +147,7 @@ struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT RadarPara
float DATA_RATE_MIDDLE; float DATA_RATE_MIDDLE;
float DATA_RATE_FAR; float DATA_RATE_FAR;
float DATA_RATE_TAS; //TAS模式数据率，由dll调用者输入；TAS波束输出间隔阈值为 1/DATA_RATE_TAS 秒
//数据关联参数 //数据关联参数
int track_start_point_num; //起批点数(典型值 3或4) int track_start_point_num; //起批点数(典型值 3或4)
@@ -171,8 +167,6 @@ struct DATA_PROCESS_CLASS_DLLSHARED_EXPORT RadarPara
}; };
class DATA_PROCESS_CLASS_DLLSHARED_EXPORT Data_process_class_dll class DATA_PROCESS_CLASS_DLLSHARED_EXPORT Data_process_class_dll
{ {
@@ -185,7 +179,6 @@ public:
return 0; return 0;
} }
//数据处理函数 //数据处理函数
virtual int track_process(struct Track Trust_Track_Output[][10], //数据处理输出的航迹更新信息 主程序创建全局变量 数据处理函数更新其中数据 virtual int track_process(struct Track Trust_Track_Output[][10], //数据处理输出的航迹更新信息 主程序创建全局变量 数据处理函数更新其中数据
int *Trust_track_num_Output, //数据处理后输出的航迹数目 主程序创建全局变量 数据处理函数更新其中数据 int *Trust_track_num_Output, //数据处理后输出的航迹数目 主程序创建全局变量 数据处理函数更新其中数据
@@ -206,7 +199,7 @@ public:
} }
//引导跟踪处理函数 //引导跟踪处理函数
virtual int direct_tracking_process(struct Target_direct_tracking Target_direct_info, //引导信息 virtual int direct_tracking_process(struct Target_direct_tracking Target_direct_info, //引导信息（当前接口未启用，保留空实现）
struct DataRev Data_Input[150], //雷达的输入点迹 struct DataRev Data_Input[150], //雷达的输入点迹
struct Track Trust_Track_Output[][10], //数据处理输出的航迹更新信息 主程序创建全局变量 数据处理函数更新其中数据 struct Track Trust_Track_Output[][10], //数据处理输出的航迹更新信息 主程序创建全局变量 数据处理函数更新其中数据
int *Trust_track_num_Output, //数据处理后输出的航迹数目 主程序创建全局变量 数据处理函数更新其中数据 int *Trust_track_num_Output, //数据处理后输出的航迹数目 主程序创建全局变量 数据处理函数更新其中数据
@@ -218,16 +211,12 @@ public:
return 0; return 0;
} }
//航迹清空函数 //航迹清空函数
virtual int track_clear_all(void) virtual int track_clear_all(void)
{ {
return 0; return 0;
} }
//手动航迹删除函数 //手动航迹删除函数
virtual int track_delete(int delete_track_num, //手动删除的航迹数目 virtual int track_delete(int delete_track_num, //手动删除的航迹数目
int delete_track_index[]) //手动删除的航迹号 int delete_track_index[]) //手动删除的航迹号
@@ -235,21 +224,23 @@ public:
return 0; return 0;
} }
//手动转TAS跟踪函数 //手动转TAS跟踪函数
virtual int tracking_start(int track_index) //需要手动转入TAS跟踪的航迹号 virtual int tracking_start(int track_index) //需要手动转入TAS跟踪的航迹号
{ {
return 0; return 0;
} }
//手动取消TAS跟踪函数
//手动打跟踪波束 virtual int tracking_stop(int track_index) //需要手动转入TAS跟踪的航迹号
virtual int tracking_point(float Azimuth) //方位角
{ {
return 0; return 0;
} }
//手动打跟踪波束
virtual int tracking_point(float Azimuth) //方位角（当前接口未启用，保留空实现）
{
return 0;
}
//参数设置初始化函数 //参数设置初始化函数
virtual int track_process_parameters_initial(struct RadarPara Radar_Parameter) virtual int track_process_parameters_initial(struct RadarPara Radar_Parameter)
@@ -257,18 +248,14 @@ public:
return 0; return 0;
} }
//参数设置修改函数 //参数设置修改函数
virtual int track_process_parameters_modify(struct RadarPara Radar_Parameter) virtual int track_process_parameters_modify(struct RadarPara Radar_Parameter)
{ {
return 0; return 0;
} }
}; };
//工厂类 用户可见 //工厂类 用户可见
class DATA_PROCESS_CLASS_DLLSHARED_EXPORT Data_Process_Factory class DATA_PROCESS_CLASS_DLLSHARED_EXPORT Data_Process_Factory
{ {
@@ -280,6 +267,4 @@ private:
static Data_process_class_dll *p; static Data_process_class_dll *p;
}; };
#endif // DATA_PROCESS_CLASS_DLL_H #endif // DATA_PROCESS_CLASS_DLL_H
data_process_class_dll/data_process_class_dll.pro.user.0b80abb
-317
View File
@@ -1,317 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE QtCreatorProject>
<!-- Written by QtCreator 4.0.2, 2025-04-27T16:03:48. -->
<qtcreator>
<data>
<variable>EnvironmentId</variable>
<value type="QByteArray">{0b80abbd-012d-4338-8c64-507c85ad099b}</value>
</data>
<data>
<variable>ProjectExplorer.Project.ActiveTarget</variable>
<value type="int">0</value>
</data>
<data>
<variable>ProjectExplorer.Project.EditorSettings</variable>
<valuemap type="QVariantMap">
<value type="bool" key="EditorConfiguration.AutoIndent">true</value>
<value type="bool" key="EditorConfiguration.AutoSpacesForTabs">false</value>
<value type="bool" key="EditorConfiguration.CamelCaseNavigation">true</value>
<valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.0">
<value type="QString" key="language">Cpp</value>
<valuemap type="QVariantMap" key="value">
<value type="QByteArray" key="CurrentPreferences">CppGlobal</value>
</valuemap>
</valuemap>
<valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.1">
<value type="QString" key="language">QmlJS</value>
<valuemap type="QVariantMap" key="value">
<value type="QByteArray" key="CurrentPreferences">QmlJSGlobal</value>
</valuemap>
</valuemap>
<value type="int" key="EditorConfiguration.CodeStyle.Count">2</value>
<value type="QByteArray" key="EditorConfiguration.Codec">UTF-8</value>
<value type="bool" key="EditorConfiguration.ConstrainTooltips">false</value>
<value type="int" key="EditorConfiguration.IndentSize">4</value>
<value type="bool" key="EditorConfiguration.KeyboardTooltips">false</value>
<value type="int" key="EditorConfiguration.MarginColumn">80</value>
<value type="bool" key="EditorConfiguration.MouseHiding">true</value>
<value type="bool" key="EditorConfiguration.MouseNavigation">true</value>
<value type="int" key="EditorConfiguration.PaddingMode">1</value>
<value type="bool" key="EditorConfiguration.ScrollWheelZooming">true</value>
<value type="bool" key="EditorConfiguration.ShowMargin">false</value>
<value type="int" key="EditorConfiguration.SmartBackspaceBehavior">0</value>
<value type="bool" key="EditorConfiguration.SmartSelectionChanging">true</value>
<value type="bool" key="EditorConfiguration.SpacesForTabs">true</value>
<value type="int" key="EditorConfiguration.TabKeyBehavior">0</value>
<value type="int" key="EditorConfiguration.TabSize">8</value>
<value type="bool" key="EditorConfiguration.UseGlobal">true</value>
<value type="int" key="EditorConfiguration.Utf8BomBehavior">1</value>
<value type="bool" key="EditorConfiguration.addFinalNewLine">true</value>
<value type="bool" key="EditorConfiguration.cleanIndentation">true</value>
<value type="bool" key="EditorConfiguration.cleanWhitespace">true</value>
<value type="bool" key="EditorConfiguration.inEntireDocument">false</value>
</valuemap>
</data>
<data>
<variable>ProjectExplorer.Project.PluginSettings</variable>
<valuemap type="QVariantMap">
<valuelist type="QVariantList" key="ClangStaticAnalyzer.SuppressedDiagnostics"/>
</valuemap>
</data>
<data>
<variable>ProjectExplorer.Project.Target.0</variable>
<valuemap type="QVariantMap">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop Qt 5.7.0 MSVC2013 32bit</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Desktop Qt 5.7.0 MSVC2013 32bit</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">qt.57.win32_msvc2013_kit</value>
<value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">1</value>
<value type="int" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
<value type="int" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">E:/data_process_qt_vision_2003/build-data_process_class_dll-Desktop_Qt_5_7_0_MSVC2013_32bit-Debug</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">true</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Debug</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">2</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.1">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">D:/007_hhyk_data_process/data_process_mianzhen576/mianzhen576-v1.4.2/build-data_process_class_dll-Desktop_Qt_5_7_0_MSVC2013_32bit-Release</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Release</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.2">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">E:/data_process_qt_vision_2003/build-data_process_class_dll-Desktop_Qt_5_7_0_MSVC2013_32bit-Profile</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">true</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">true</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Profile</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
</valuemap>
<value type="int" key="ProjectExplorer.Target.BuildConfigurationCount">3</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.DeployConfiguration.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">0</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">部署</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Deploy</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">在本地部署</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.DefaultDeployConfiguration</value>
</valuemap>
<value type="int" key="ProjectExplorer.Target.DeployConfigurationCount">1</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.PluginSettings"/>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.RunConfiguration.0">
<value type="bool" key="Analyzer.QmlProfiler.AggregateTraces">false</value>
<value type="bool" key="Analyzer.QmlProfiler.FlushEnabled">false</value>
<value type="uint" key="Analyzer.QmlProfiler.FlushInterval">1000</value>
<value type="QString" key="Analyzer.QmlProfiler.LastTraceFile"></value>
<value type="bool" key="Analyzer.QmlProfiler.Settings.UseGlobalSettings">true</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.AddedSuppressionFiles"/>
<value type="bool" key="Analyzer.Valgrind.Callgrind.CollectBusEvents">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.CollectSystime">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableBranchSim">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableCacheSim">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableEventToolTips">true</value>
<value type="double" key="Analyzer.Valgrind.Callgrind.MinimumCostRatio">0.01</value>
<value type="double" key="Analyzer.Valgrind.Callgrind.VisualisationMinimumCostRatio">10</value>
<value type="bool" key="Analyzer.Valgrind.FilterExternalIssues">true</value>
<value type="int" key="Analyzer.Valgrind.LeakCheckOnFinish">1</value>
<value type="int" key="Analyzer.Valgrind.NumCallers">25</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.RemovedSuppressionFiles"/>
<value type="int" key="Analyzer.Valgrind.SelfModifyingCodeDetection">1</value>
<value type="bool" key="Analyzer.Valgrind.Settings.UseGlobalSettings">true</value>
<value type="bool" key="Analyzer.Valgrind.ShowReachable">false</value>
<value type="bool" key="Analyzer.Valgrind.TrackOrigins">true</value>
<value type="QString" key="Analyzer.Valgrind.ValgrindExecutable">valgrind</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.VisibleErrorKinds">
<value type="int">0</value>
<value type="int">1</value>
<value type="int">2</value>
<value type="int">3</value>
<value type="int">4</value>
<value type="int">5</value>
<value type="int">6</value>
<value type="int">7</value>
<value type="int">8</value>
<value type="int">9</value>
<value type="int">10</value>
<value type="int">11</value>
<value type="int">12</value>
<value type="int">13</value>
<value type="int">14</value>
</valuelist>
<value type="int" key="PE.EnvironmentAspect.Base">2</value>
<valuelist type="QVariantList" key="PE.EnvironmentAspect.Changes"/>
<value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.Arguments"></value>
<value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.Executable"></value>
<value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.WorkingDirectory">%{buildDir}</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">自定义执行档</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.CustomExecutableRunConfiguration</value>
<value type="uint" key="RunConfiguration.QmlDebugServerPort">3768</value>
<value type="bool" key="RunConfiguration.UseCppDebugger">false</value>
<value type="bool" key="RunConfiguration.UseCppDebuggerAuto">true</value>
<value type="bool" key="RunConfiguration.UseMultiProcess">false</value>
<value type="bool" key="RunConfiguration.UseQmlDebugger">false</value>
<value type="bool" key="RunConfiguration.UseQmlDebuggerAuto">true</value>
</valuemap>
<value type="int" key="ProjectExplorer.Target.RunConfigurationCount">1</value>
</valuemap>
</data>
<data>
<variable>ProjectExplorer.Project.TargetCount</variable>
<value type="int">1</value>
</data>
<data>
<variable>ProjectExplorer.Project.Updater.FileVersion</variable>
<value type="int">18</value>
</data>
<data>
<variable>Version</variable>
<value type="int">18</value>
</data>
</qtcreator>
data_process_class_dll/data_process_class_dll.pro.user.1b3223c
-333
View File
@@ -1,333 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE QtCreatorProject>
<!-- Written by QtCreator 4.0.2, 2021-06-08T20:12:37. -->
<qtcreator>
<data>
<variable>EnvironmentId</variable>
<value type="QByteArray">{1b3223cf-63bd-47b4-8c6d-4e129469feee}</value>
</data>
<data>
<variable>ProjectExplorer.Project.ActiveTarget</variable>
<value type="int">0</value>
</data>
<data>
<variable>ProjectExplorer.Project.EditorSettings</variable>
<valuemap type="QVariantMap">
<value type="bool" key="EditorConfiguration.AutoIndent">true</value>
<value type="bool" key="EditorConfiguration.AutoSpacesForTabs">false</value>
<value type="bool" key="EditorConfiguration.CamelCaseNavigation">true</value>
<valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.0">
<value type="QString" key="language">Cpp</value>
<valuemap type="QVariantMap" key="value">
<value type="QByteArray" key="CurrentPreferences">CppGlobal</value>
</valuemap>
</valuemap>
<valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.1">
<value type="QString" key="language">QmlJS</value>
<valuemap type="QVariantMap" key="value">
<value type="QByteArray" key="CurrentPreferences">QmlJSGlobal</value>
</valuemap>
</valuemap>
<value type="int" key="EditorConfiguration.CodeStyle.Count">2</value>
<value type="QByteArray" key="EditorConfiguration.Codec">UTF-8</value>
<value type="bool" key="EditorConfiguration.ConstrainTooltips">false</value>
<value type="int" key="EditorConfiguration.IndentSize">4</value>
<value type="bool" key="EditorConfiguration.KeyboardTooltips">false</value>
<value type="int" key="EditorConfiguration.MarginColumn">80</value>
<value type="bool" key="EditorConfiguration.MouseHiding">true</value>
<value type="bool" key="EditorConfiguration.MouseNavigation">true</value>
<value type="int" key="EditorConfiguration.PaddingMode">1</value>
<value type="bool" key="EditorConfiguration.ScrollWheelZooming">true</value>
<value type="bool" key="EditorConfiguration.ShowMargin">false</value>
<value type="int" key="EditorConfiguration.SmartBackspaceBehavior">0</value>
<value type="bool" key="EditorConfiguration.SmartSelectionChanging">true</value>
<value type="bool" key="EditorConfiguration.SpacesForTabs">true</value>
<value type="int" key="EditorConfiguration.TabKeyBehavior">0</value>
<value type="int" key="EditorConfiguration.TabSize">8</value>
<value type="bool" key="EditorConfiguration.UseGlobal">true</value>
<value type="int" key="EditorConfiguration.Utf8BomBehavior">1</value>
<value type="bool" key="EditorConfiguration.addFinalNewLine">true</value>
<value type="bool" key="EditorConfiguration.cleanIndentation">true</value>
<value type="bool" key="EditorConfiguration.cleanWhitespace">true</value>
<value type="bool" key="EditorConfiguration.inEntireDocument">false</value>
</valuemap>
</data>
<data>
<variable>ProjectExplorer.Project.PluginSettings</variable>
<valuemap type="QVariantMap"/>
</data>
<data>
<variable>ProjectExplorer.Project.Target.0</variable>
<valuemap type="QVariantMap">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop Qt 5.7.0 GCC 64bit</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Desktop Qt 5.7.0 GCC 64bit</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">qt.57.gcc_64_kit</value>
<value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">1</value>
<value type="int" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
<value type="int" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">/home/xu/2003/QT_process/build-data_process_class_dll-Desktop_Qt_5_7_0_MSVC2013_32bit-Release</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">true</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments">
<value type="QString">-w</value>
<value type="QString">-r</value>
</valuelist>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments">
<value type="QString">-w</value>
<value type="QString">-r</value>
</valuelist>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Debug</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">2</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.1">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">/home/xu/2003/QT_process/build-data_process_class_dll-Desktop_Qt_5_7_0_MSVC2013_32bit-Release/release</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments">
<value type="QString">-w</value>
<value type="QString">-r</value>
</valuelist>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments">
<value type="QString">-w</value>
<value type="QString">-r</value>
</valuelist>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Release</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.2">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">/home/xu/2003/QT_process/build-data_process_class_dll-Desktop_Qt_5_7_0_GCC_64bit-Profile</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">true</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">true</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments">
<value type="QString">-w</value>
<value type="QString">-r</value>
</valuelist>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments">
<value type="QString">-w</value>
<value type="QString">-r</value>
</valuelist>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Profile</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
</valuemap>
<value type="int" key="ProjectExplorer.Target.BuildConfigurationCount">3</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.DeployConfiguration.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">0</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">部署</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Deploy</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">在本地部署</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.DefaultDeployConfiguration</value>
</valuemap>
<value type="int" key="ProjectExplorer.Target.DeployConfigurationCount">1</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.PluginSettings"/>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.RunConfiguration.0">
<value type="bool" key="Analyzer.QmlProfiler.AggregateTraces">false</value>
<value type="bool" key="Analyzer.QmlProfiler.FlushEnabled">false</value>
<value type="uint" key="Analyzer.QmlProfiler.FlushInterval">1000</value>
<value type="QString" key="Analyzer.QmlProfiler.LastTraceFile"></value>
<value type="bool" key="Analyzer.QmlProfiler.Settings.UseGlobalSettings">true</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.AddedSuppressionFiles"/>
<value type="bool" key="Analyzer.Valgrind.Callgrind.CollectBusEvents">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.CollectSystime">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableBranchSim">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableCacheSim">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableEventToolTips">true</value>
<value type="double" key="Analyzer.Valgrind.Callgrind.MinimumCostRatio">0.01</value>
<value type="double" key="Analyzer.Valgrind.Callgrind.VisualisationMinimumCostRatio">10</value>
<value type="bool" key="Analyzer.Valgrind.FilterExternalIssues">true</value>
<value type="int" key="Analyzer.Valgrind.LeakCheckOnFinish">1</value>
<value type="int" key="Analyzer.Valgrind.NumCallers">25</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.RemovedSuppressionFiles"/>
<value type="int" key="Analyzer.Valgrind.SelfModifyingCodeDetection">1</value>
<value type="bool" key="Analyzer.Valgrind.Settings.UseGlobalSettings">true</value>
<value type="bool" key="Analyzer.Valgrind.ShowReachable">false</value>
<value type="bool" key="Analyzer.Valgrind.TrackOrigins">true</value>
<value type="QString" key="Analyzer.Valgrind.ValgrindExecutable">valgrind</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.VisibleErrorKinds">
<value type="int">0</value>
<value type="int">1</value>
<value type="int">2</value>
<value type="int">3</value>
<value type="int">4</value>
<value type="int">5</value>
<value type="int">6</value>
<value type="int">7</value>
<value type="int">8</value>
<value type="int">9</value>
<value type="int">10</value>
<value type="int">11</value>
<value type="int">12</value>
<value type="int">13</value>
<value type="int">14</value>
</valuelist>
<value type="int" key="PE.EnvironmentAspect.Base">2</value>
<valuelist type="QVariantList" key="PE.EnvironmentAspect.Changes"/>
<value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.Arguments"></value>
<value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.Executable"></value>
<value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.WorkingDirectory">%{buildDir}</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">自定义执行档</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.CustomExecutableRunConfiguration</value>
<value type="uint" key="RunConfiguration.QmlDebugServerPort">3768</value>
<value type="bool" key="RunConfiguration.UseCppDebugger">false</value>
<value type="bool" key="RunConfiguration.UseCppDebuggerAuto">true</value>
<value type="bool" key="RunConfiguration.UseMultiProcess">false</value>
<value type="bool" key="RunConfiguration.UseQmlDebugger">false</value>
<value type="bool" key="RunConfiguration.UseQmlDebuggerAuto">true</value>
</valuemap>
<value type="int" key="ProjectExplorer.Target.RunConfigurationCount">1</value>
</valuemap>
</data>
<data>
<variable>ProjectExplorer.Project.TargetCount</variable>
<value type="int">1</value>
</data>
<data>
<variable>ProjectExplorer.Project.Updater.FileVersion</variable>
<value type="int">18</value>
</data>
<data>
<variable>Version</variable>
<value type="int">18</value>
</data>
</qtcreator>
data_process_class_dll/data_process_class_dll.pro.user.7d2b7fb
-315
View File
@@ -1,315 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE QtCreatorProject>
<!-- Written by QtCreator 4.0.2, 2021-06-08T14:09:25. -->
<qtcreator>
<data>
<variable>EnvironmentId</variable>
<value type="QByteArray">{7d2b7fbd-9f92-4349-8514-21c38df4ed25}</value>
</data>
<data>
<variable>ProjectExplorer.Project.ActiveTarget</variable>
<value type="int">0</value>
</data>
<data>
<variable>ProjectExplorer.Project.EditorSettings</variable>
<valuemap type="QVariantMap">
<value type="bool" key="EditorConfiguration.AutoIndent">true</value>
<value type="bool" key="EditorConfiguration.AutoSpacesForTabs">false</value>
<value type="bool" key="EditorConfiguration.CamelCaseNavigation">true</value>
<valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.0">
<value type="QString" key="language">Cpp</value>
<valuemap type="QVariantMap" key="value">
<value type="QByteArray" key="CurrentPreferences">CppGlobal</value>
</valuemap>
</valuemap>
<valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.1">
<value type="QString" key="language">QmlJS</value>
<valuemap type="QVariantMap" key="value">
<value type="QByteArray" key="CurrentPreferences">QmlJSGlobal</value>
</valuemap>
</valuemap>
<value type="int" key="EditorConfiguration.CodeStyle.Count">2</value>
<value type="QByteArray" key="EditorConfiguration.Codec">UTF-8</value>
<value type="bool" key="EditorConfiguration.ConstrainTooltips">false</value>
<value type="int" key="EditorConfiguration.IndentSize">4</value>
<value type="bool" key="EditorConfiguration.KeyboardTooltips">false</value>
<value type="int" key="EditorConfiguration.MarginColumn">80</value>
<value type="bool" key="EditorConfiguration.MouseHiding">true</value>
<value type="bool" key="EditorConfiguration.MouseNavigation">true</value>
<value type="int" key="EditorConfiguration.PaddingMode">1</value>
<value type="bool" key="EditorConfiguration.ScrollWheelZooming">true</value>
<value type="bool" key="EditorConfiguration.ShowMargin">false</value>
<value type="int" key="EditorConfiguration.SmartBackspaceBehavior">0</value>
<value type="bool" key="EditorConfiguration.SmartSelectionChanging">true</value>
<value type="bool" key="EditorConfiguration.SpacesForTabs">true</value>
<value type="int" key="EditorConfiguration.TabKeyBehavior">0</value>
<value type="int" key="EditorConfiguration.TabSize">8</value>
<value type="bool" key="EditorConfiguration.UseGlobal">true</value>
<value type="int" key="EditorConfiguration.Utf8BomBehavior">1</value>
<value type="bool" key="EditorConfiguration.addFinalNewLine">true</value>
<value type="bool" key="EditorConfiguration.cleanIndentation">true</value>
<value type="bool" key="EditorConfiguration.cleanWhitespace">true</value>
<value type="bool" key="EditorConfiguration.inEntireDocument">false</value>
</valuemap>
</data>
<data>
<variable>ProjectExplorer.Project.PluginSettings</variable>
<valuemap type="QVariantMap"/>
</data>
<data>
<variable>ProjectExplorer.Project.Target.0</variable>
<valuemap type="QVariantMap">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop Qt 5.7.0 MSVC2013 32bit</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Desktop Qt 5.7.0 MSVC2013 32bit</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">qt.57.win32_msvc2013_kit</value>
<value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">1</value>
<value type="int" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
<value type="int" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">E:/data_process_qt_vision_2003/build-data_process_class_dll-Desktop_Qt_5_7_0_MSVC2013_32bit-Debug</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">true</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Debug</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">2</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.1">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">E:/dataprocess/QT_process/build-data_process_class_dll-Desktop_Qt_5_7_0_MSVC2013_32bit-Release</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Release</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.2">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">E:/data_process_qt_vision_2003/build-data_process_class_dll-Desktop_Qt_5_7_0_MSVC2013_32bit-Profile</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">true</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">true</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Profile</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
</valuemap>
<value type="int" key="ProjectExplorer.Target.BuildConfigurationCount">3</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.DeployConfiguration.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">0</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">部署</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Deploy</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">在本地部署</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.DefaultDeployConfiguration</value>
</valuemap>
<value type="int" key="ProjectExplorer.Target.DeployConfigurationCount">1</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.PluginSettings"/>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.RunConfiguration.0">
<value type="bool" key="Analyzer.QmlProfiler.AggregateTraces">false</value>
<value type="bool" key="Analyzer.QmlProfiler.FlushEnabled">false</value>
<value type="uint" key="Analyzer.QmlProfiler.FlushInterval">1000</value>
<value type="QString" key="Analyzer.QmlProfiler.LastTraceFile"></value>
<value type="bool" key="Analyzer.QmlProfiler.Settings.UseGlobalSettings">true</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.AddedSuppressionFiles"/>
<value type="bool" key="Analyzer.Valgrind.Callgrind.CollectBusEvents">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.CollectSystime">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableBranchSim">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableCacheSim">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableEventToolTips">true</value>
<value type="double" key="Analyzer.Valgrind.Callgrind.MinimumCostRatio">0.01</value>
<value type="double" key="Analyzer.Valgrind.Callgrind.VisualisationMinimumCostRatio">10</value>
<value type="bool" key="Analyzer.Valgrind.FilterExternalIssues">true</value>
<value type="int" key="Analyzer.Valgrind.LeakCheckOnFinish">1</value>
<value type="int" key="Analyzer.Valgrind.NumCallers">25</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.RemovedSuppressionFiles"/>
<value type="int" key="Analyzer.Valgrind.SelfModifyingCodeDetection">1</value>
<value type="bool" key="Analyzer.Valgrind.Settings.UseGlobalSettings">true</value>
<value type="bool" key="Analyzer.Valgrind.ShowReachable">false</value>
<value type="bool" key="Analyzer.Valgrind.TrackOrigins">true</value>
<value type="QString" key="Analyzer.Valgrind.ValgrindExecutable">valgrind</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.VisibleErrorKinds">
<value type="int">0</value>
<value type="int">1</value>
<value type="int">2</value>
<value type="int">3</value>
<value type="int">4</value>
<value type="int">5</value>
<value type="int">6</value>
<value type="int">7</value>
<value type="int">8</value>
<value type="int">9</value>
<value type="int">10</value>
<value type="int">11</value>
<value type="int">12</value>
<value type="int">13</value>
<value type="int">14</value>
</valuelist>
<value type="int" key="PE.EnvironmentAspect.Base">2</value>
<valuelist type="QVariantList" key="PE.EnvironmentAspect.Changes"/>
<value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.Arguments"></value>
<value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.Executable"></value>
<value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.WorkingDirectory">%{buildDir}</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">自定义执行档</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.CustomExecutableRunConfiguration</value>
<value type="uint" key="RunConfiguration.QmlDebugServerPort">3768</value>
<value type="bool" key="RunConfiguration.UseCppDebugger">false</value>
<value type="bool" key="RunConfiguration.UseCppDebuggerAuto">true</value>
<value type="bool" key="RunConfiguration.UseMultiProcess">false</value>
<value type="bool" key="RunConfiguration.UseQmlDebugger">false</value>
<value type="bool" key="RunConfiguration.UseQmlDebuggerAuto">true</value>
</valuemap>
<value type="int" key="ProjectExplorer.Target.RunConfigurationCount">1</value>
</valuemap>
</data>
<data>
<variable>ProjectExplorer.Project.TargetCount</variable>
<value type="int">1</value>
</data>
<data>
<variable>ProjectExplorer.Project.Updater.FileVersion</variable>
<value type="int">18</value>
</data>
<data>
<variable>Version</variable>
<value type="int">18</value>
</data>
</qtcreator>
data_process_class_dll/data_process_class_dll.pro.user.d94506b
-559
View File
@@ -1,559 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE QtCreatorProject>
<!-- Written by QtCreator 4.0.2, 2021-06-08T13:58:48. -->
<qtcreator>
<data>
<variable>EnvironmentId</variable>
<value type="QByteArray">{d94506bb-f9e6-48c9-9c2d-e6e1c0edb92a}</value>
</data>
<data>
<variable>ProjectExplorer.Project.ActiveTarget</variable>
<value type="int">0</value>
</data>
<data>
<variable>ProjectExplorer.Project.EditorSettings</variable>
<valuemap type="QVariantMap">
<value type="bool" key="EditorConfiguration.AutoIndent">true</value>
<value type="bool" key="EditorConfiguration.AutoSpacesForTabs">false</value>
<value type="bool" key="EditorConfiguration.CamelCaseNavigation">true</value>
<valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.0">
<value type="QString" key="language">Cpp</value>
<valuemap type="QVariantMap" key="value">
<value type="QByteArray" key="CurrentPreferences">CppGlobal</value>
</valuemap>
</valuemap>
<valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.1">
<value type="QString" key="language">QmlJS</value>
<valuemap type="QVariantMap" key="value">
<value type="QByteArray" key="CurrentPreferences">QmlJSGlobal</value>
</valuemap>
</valuemap>
<value type="int" key="EditorConfiguration.CodeStyle.Count">2</value>
<value type="QByteArray" key="EditorConfiguration.Codec">UTF-8</value>
<value type="bool" key="EditorConfiguration.ConstrainTooltips">false</value>
<value type="int" key="EditorConfiguration.IndentSize">4</value>
<value type="bool" key="EditorConfiguration.KeyboardTooltips">false</value>
<value type="int" key="EditorConfiguration.MarginColumn">80</value>
<value type="bool" key="EditorConfiguration.MouseHiding">true</value>
<value type="bool" key="EditorConfiguration.MouseNavigation">true</value>
<value type="int" key="EditorConfiguration.PaddingMode">1</value>
<value type="bool" key="EditorConfiguration.ScrollWheelZooming">true</value>
<value type="bool" key="EditorConfiguration.ShowMargin">false</value>
<value type="int" key="EditorConfiguration.SmartBackspaceBehavior">0</value>
<value type="bool" key="EditorConfiguration.SmartSelectionChanging">true</value>
<value type="bool" key="EditorConfiguration.SpacesForTabs">true</value>
<value type="int" key="EditorConfiguration.TabKeyBehavior">0</value>
<value type="int" key="EditorConfiguration.TabSize">8</value>
<value type="bool" key="EditorConfiguration.UseGlobal">true</value>
<value type="int" key="EditorConfiguration.Utf8BomBehavior">1</value>
<value type="bool" key="EditorConfiguration.addFinalNewLine">true</value>
<value type="bool" key="EditorConfiguration.cleanIndentation">true</value>
<value type="bool" key="EditorConfiguration.cleanWhitespace">true</value>
<value type="bool" key="EditorConfiguration.inEntireDocument">false</value>
</valuemap>
</data>
<data>
<variable>ProjectExplorer.Project.PluginSettings</variable>
<valuemap type="QVariantMap"/>
</data>
<data>
<variable>ProjectExplorer.Project.Target.0</variable>
<valuemap type="QVariantMap">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop Qt 5.7.0 MSVC2013 32bit</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Desktop Qt 5.7.0 MSVC2013 32bit</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">qt.57.win32_msvc2013_kit</value>
<value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">1</value>
<value type="int" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
<value type="int" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">E:/data_process_qt_vision_2003/build-data_process_class_dll-Desktop_Qt_5_7_0_MSVC2013_32bit-Debug</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">true</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Debug</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">2</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.1">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">E:/data_process_qt_vision_2003/build-data_process_class_dll-Desktop_Qt_5_7_0_MSVC2013_32bit-Release</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Release</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.2">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">E:/data_process_qt_vision_2003/build-data_process_class_dll-Desktop_Qt_5_7_0_MSVC2013_32bit-Profile</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">true</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">true</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Profile</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
</valuemap>
<value type="int" key="ProjectExplorer.Target.BuildConfigurationCount">3</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.DeployConfiguration.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">0</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">部署</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Deploy</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">在本地部署</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.DefaultDeployConfiguration</value>
</valuemap>
<value type="int" key="ProjectExplorer.Target.DeployConfigurationCount">1</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.PluginSettings"/>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.RunConfiguration.0">
<value type="bool" key="Analyzer.QmlProfiler.AggregateTraces">false</value>
<value type="bool" key="Analyzer.QmlProfiler.FlushEnabled">false</value>
<value type="uint" key="Analyzer.QmlProfiler.FlushInterval">1000</value>
<value type="QString" key="Analyzer.QmlProfiler.LastTraceFile"></value>
<value type="bool" key="Analyzer.QmlProfiler.Settings.UseGlobalSettings">true</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.AddedSuppressionFiles"/>
<value type="bool" key="Analyzer.Valgrind.Callgrind.CollectBusEvents">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.CollectSystime">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableBranchSim">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableCacheSim">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableEventToolTips">true</value>
<value type="double" key="Analyzer.Valgrind.Callgrind.MinimumCostRatio">0.01</value>
<value type="double" key="Analyzer.Valgrind.Callgrind.VisualisationMinimumCostRatio">10</value>
<value type="bool" key="Analyzer.Valgrind.FilterExternalIssues">true</value>
<value type="int" key="Analyzer.Valgrind.LeakCheckOnFinish">1</value>
<value type="int" key="Analyzer.Valgrind.NumCallers">25</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.RemovedSuppressionFiles"/>
<value type="int" key="Analyzer.Valgrind.SelfModifyingCodeDetection">1</value>
<value type="bool" key="Analyzer.Valgrind.Settings.UseGlobalSettings">true</value>
<value type="bool" key="Analyzer.Valgrind.ShowReachable">false</value>
<value type="bool" key="Analyzer.Valgrind.TrackOrigins">true</value>
<value type="QString" key="Analyzer.Valgrind.ValgrindExecutable">valgrind</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.VisibleErrorKinds">
<value type="int">0</value>
<value type="int">1</value>
<value type="int">2</value>
<value type="int">3</value>
<value type="int">4</value>
<value type="int">5</value>
<value type="int">6</value>
<value type="int">7</value>
<value type="int">8</value>
<value type="int">9</value>
<value type="int">10</value>
<value type="int">11</value>
<value type="int">12</value>
<value type="int">13</value>
<value type="int">14</value>
</valuelist>
<value type="int" key="PE.EnvironmentAspect.Base">2</value>
<valuelist type="QVariantList" key="PE.EnvironmentAspect.Changes"/>
<value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.Arguments"></value>
<value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.Executable"></value>
<value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.WorkingDirectory">%{buildDir}</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">自定义执行档</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.CustomExecutableRunConfiguration</value>
<value type="uint" key="RunConfiguration.QmlDebugServerPort">3768</value>
<value type="bool" key="RunConfiguration.UseCppDebugger">false</value>
<value type="bool" key="RunConfiguration.UseCppDebuggerAuto">true</value>
<value type="bool" key="RunConfiguration.UseMultiProcess">false</value>
<value type="bool" key="RunConfiguration.UseQmlDebugger">false</value>
<value type="bool" key="RunConfiguration.UseQmlDebuggerAuto">true</value>
</valuemap>
<value type="int" key="ProjectExplorer.Target.RunConfigurationCount">1</value>
</valuemap>
</data>
<data>
<variable>ProjectExplorer.Project.Target.1</variable>
<valuemap type="QVariantMap">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">未命名</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">未命名</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">{9b0b3026-9845-46f4-8357-c52f2694ea2c}</value>
<value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">0</value>
<value type="int" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
<value type="int" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">E:/data_process_qt_vision_2003/build-data_process_class_dll-unknown-Debug</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">true</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Debug</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">2</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.1">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">E:/data_process_qt_vision_2003/build-data_process_class_dll-unknown-Release</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Release</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.2">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">E:/data_process_qt_vision_2003/build-data_process_class_dll-unknown-Profile</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">true</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">true</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments"/>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Profile</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
</valuemap>
<value type="int" key="ProjectExplorer.Target.BuildConfigurationCount">3</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.DeployConfiguration.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">0</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">部署</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Deploy</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">在本地部署</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.DefaultDeployConfiguration</value>
</valuemap>
<value type="int" key="ProjectExplorer.Target.DeployConfigurationCount">1</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.PluginSettings"/>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.RunConfiguration.0">
<value type="bool" key="Analyzer.QmlProfiler.AggregateTraces">false</value>
<value type="bool" key="Analyzer.QmlProfiler.FlushEnabled">false</value>
<value type="uint" key="Analyzer.QmlProfiler.FlushInterval">1000</value>
<value type="QString" key="Analyzer.QmlProfiler.LastTraceFile"></value>
<value type="bool" key="Analyzer.QmlProfiler.Settings.UseGlobalSettings">true</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.AddedSuppressionFiles"/>
<value type="bool" key="Analyzer.Valgrind.Callgrind.CollectBusEvents">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.CollectSystime">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableBranchSim">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableCacheSim">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableEventToolTips">true</value>
<value type="double" key="Analyzer.Valgrind.Callgrind.MinimumCostRatio">0.01</value>
<value type="double" key="Analyzer.Valgrind.Callgrind.VisualisationMinimumCostRatio">10</value>
<value type="bool" key="Analyzer.Valgrind.FilterExternalIssues">true</value>
<value type="int" key="Analyzer.Valgrind.LeakCheckOnFinish">1</value>
<value type="int" key="Analyzer.Valgrind.NumCallers">25</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.RemovedSuppressionFiles"/>
<value type="int" key="Analyzer.Valgrind.SelfModifyingCodeDetection">1</value>
<value type="bool" key="Analyzer.Valgrind.Settings.UseGlobalSettings">true</value>
<value type="bool" key="Analyzer.Valgrind.ShowReachable">false</value>
<value type="bool" key="Analyzer.Valgrind.TrackOrigins">true</value>
<value type="QString" key="Analyzer.Valgrind.ValgrindExecutable">valgrind</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.VisibleErrorKinds">
<value type="int">0</value>
<value type="int">1</value>
<value type="int">2</value>
<value type="int">3</value>
<value type="int">4</value>
<value type="int">5</value>
<value type="int">6</value>
<value type="int">7</value>
<value type="int">8</value>
<value type="int">9</value>
<value type="int">10</value>
<value type="int">11</value>
<value type="int">12</value>
<value type="int">13</value>
<value type="int">14</value>
</valuelist>
<value type="int" key="PE.EnvironmentAspect.Base">-1</value>
<valuelist type="QVariantList" key="PE.EnvironmentAspect.Changes"/>
<value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.Arguments"></value>
<value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.Executable"></value>
<value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.WorkingDirectory">%{buildDir}</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">自定义执行档</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.CustomExecutableRunConfiguration</value>
<value type="uint" key="RunConfiguration.QmlDebugServerPort">3768</value>
<value type="bool" key="RunConfiguration.UseCppDebugger">false</value>
<value type="bool" key="RunConfiguration.UseCppDebuggerAuto">true</value>
<value type="bool" key="RunConfiguration.UseMultiProcess">false</value>
<value type="bool" key="RunConfiguration.UseQmlDebugger">false</value>
<value type="bool" key="RunConfiguration.UseQmlDebuggerAuto">true</value>
</valuemap>
<value type="int" key="ProjectExplorer.Target.RunConfigurationCount">1</value>
</valuemap>
</data>
<data>
<variable>ProjectExplorer.Project.TargetCount</variable>
<value type="int">2</value>
</data>
<data>
<variable>ProjectExplorer.Project.Updater.FileVersion</variable>
<value type="int">18</value>
</data>
<data>
<variable>Version</variable>
<value type="int">18</value>
</data>
</qtcreator>
data_process_class_dll/data_process_class_dll_global.h
+2 -16
View File
@@ -1,26 +1,12 @@
#ifndef DATA_PROCESS_CLASS_DLL_GLOBAL_H #ifndef DATA_PROCESS_CLASS_DLL_GLOBAL_H
#define DATA_PROCESS_CLASS_DLL_GLOBAL_H #define DATA_PROCESS_CLASS_DLL_GLOBAL_H
#include <QtCore/qglobal.h>
#if defined(DATA_PROCESS_CLASS_DLL_LIBRARY) #if defined(DATA_PROCESS_CLASS_DLL_LIBRARY)
# define DATA_PROCESS_CLASS_DLLSHARED_EXPORT Q_DECL_EXPORT # define DATA_PROCESS_CLASS_DLLSHARED_EXPORT __declspec(dllexport)
#else #else
# define DATA_PROCESS_CLASS_DLLSHARED_EXPORT Q_DECL_IMPORT # define DATA_PROCESS_CLASS_DLLSHARED_EXPORT __declspec(dllimport)
#endif #endif
//#if defined(DATA_PROCESS_CLASS_DLL_LIBRARY)
//# define DATA_PROCESS_CLASS_DLLSHARED_EXPORT __declspec(dllexport)
//#else
//# define DATA_PROCESS_CLASS_DLLSHARED_EXPORT __declspec(dllexport)
//#endif
//#if defined(DATA_PROCESS_CLASS_DLL_LIBRARY)
//#define DATA_PROCESS_CLASS_DLLSHARED_EXPORT __declspec(dllexport)
//#else
//#define DATA_PROCESS_CLASS_DLLSHARED_EXPORT __declspec(dllimport)
//#endif
#endif // DATA_PROCESS_CLASS_DLL_GLOBAL_H #endif // DATA_PROCESS_CLASS_DLL_GLOBAL_H
data_process_class_dll/dot_coh.cpp
+36 -40
View File
@@ -1,12 +1,11 @@
#include "dot_coh.h" #include "dot_coh.h"
#include <qmath.h> #include <cmath>
#include"memory.h" #include <cstring>
#include <QVector> #include <vector>
using namespace std; using namespace std;
int Dot_Coh::dot_coh_process(std::vector <PointRecv> *data_input,
int Dot_Coh::dot_coh_process(QVector <PointRecv> *data_input, std::vector <PointRecv> *point_recv,
QVector <PointRecv> *point_recv,
struct RadarPara Work_Parameter) struct RadarPara Work_Parameter)
{ {
@@ -23,7 +22,7 @@ int Dot_Coh::dot_coh_process(QVector <PointRecv> *data_input,
float point_0_A=(*data_input)[loop_of_point].Amplitude; float point_0_A=(*data_input)[loop_of_point].Amplitude;
for (unsigned int i=loop_of_point+1;i<data_input->size();i++) for (unsigned int i=loop_of_point+1;i<data_input->size();i++)
{ {
if((*data_input)[loop_of_point].Use_Flag!=1) if((*data_input)[loop_of_point].Use_Flag!=1 && (*data_input)[i].Use_Flag!=1)
{ {
float point_1_R=(*data_input)[i].Range; float point_1_R=(*data_input)[i].Range;
float point_1_V=(*data_input)[i].Velocity; float point_1_V=(*data_input)[i].Velocity;
@@ -33,7 +32,8 @@ int Dot_Coh::dot_coh_process(QVector <PointRecv> *data_input,
//凝聚条件： 距离、方位接近 //凝聚条件： 距离、方位接近
if(Work_Parameter.work_mode == 0) if(Work_Parameter.work_mode == 0)
{ {
if( (fabs(point_0_R-point_1_R)<=DOT_COH_RANGE && fabs(point_0_F-point_1_F) <=DOT_COH_AZI/180.0*PI && fabs(point_0_V-point_1_V)<=DOT_COH_V)// float delta_F = fabs(point_0_F-point_1_F)<2*PI-fabs(point_0_F-point_1_F) ? fabs(point_0_F-point_1_F) :2*PI-fabs(point_0_F-point_1_F);
if( (fabs(point_0_R-point_1_R)<=DOT_COH_RANGE && delta_F <=DOT_COH_AZI/180.0*PI && fabs(point_0_V-point_1_V)<=DOT_COH_V)//
&& point_0_A <point_1_A )// && point_0_A <point_1_A )//
{ {
point_0_R=(*data_input)[i].Range; point_0_R=(*data_input)[i].Range;
@@ -42,7 +42,7 @@ int Dot_Coh::dot_coh_process(QVector <PointRecv> *data_input,
point_0_F=(*data_input)[i].Azimuth; point_0_F=(*data_input)[i].Azimuth;
(*data_input)[loop_of_point].Use_Flag=1; (*data_input)[loop_of_point].Use_Flag=1;
} }
else if( (fabs(point_0_R-point_1_R)<=DOT_COH_RANGE && fabs(point_0_F-point_1_F) <=DOT_COH_AZI/180.0*PI && fabs(point_0_V-point_1_V)<=DOT_COH_V)// else if( (fabs(point_0_R-point_1_R)<=DOT_COH_RANGE && delta_F <=DOT_COH_AZI/180.0*PI && fabs(point_0_V-point_1_V)<=DOT_COH_V)//
&& point_0_A >= point_1_A)// && point_0_A >= point_1_A)//
{ {
(*data_input)[i].Use_Flag=1; (*data_input)[i].Use_Flag=1;
@@ -66,8 +66,6 @@ int Dot_Coh::dot_coh_process(QVector <PointRecv> *data_input,
(*data_input)[i].Use_Flag=1; (*data_input)[i].Use_Flag=1;
} }
} }
} }
} }
@@ -76,7 +74,7 @@ int Dot_Coh::dot_coh_process(QVector <PointRecv> *data_input,
} }
//删除凝聚点 和 量程范围外点 //删除凝聚点 和 量程范围外点
QVector <PointRecv>::iterator Iter; std::vector <PointRecv>::iterator Iter;
for (Iter=data_input->begin(); Iter!=data_input->end();) for (Iter=data_input->begin(); Iter!=data_input->end();)
{ {
if((*Iter).Use_Flag==1 || (*Iter).Range <R_MIN || (*Iter).Range > R_MAX ) if((*Iter).Use_Flag==1 || (*Iter).Range <R_MIN || (*Iter).Range > R_MAX )
@@ -98,38 +96,41 @@ int Dot_Coh::dot_coh_process(QVector <PointRecv> *data_input,
return 0; return 0;
} }
int Dot_Coh::dot_coh_process_buff( std::vector <PointRecv> *data_input, //输入的点迹
std::vector <PointRecv> *point_recv, //输出点迹
int Dot_Coh::dot_coh_process_buff( QVector <PointRecv> *data_input, //输入的点迹
QVector <PointRecv> *point_recv, //输出点迹
struct RadarPara Work_Parameter //工作参数 struct RadarPara Work_Parameter //工作参数
) )
{ {
//1. data_input与data_input_buff进行凝聚 //1. data_input与data_input_buff进行凝聚
//1.1 data_input、data_input_buff中的数据放在一起 //1.1 data_input、data_input_buff中的数据放在一起
QVector <PointRecv> data_tmp; std::vector <PointRecv> data_tmp;
for (int i=0;i<data_input_buff.size();i++) for (int i=0;i<data_input_buff.size();i++)
{ {
data_tmp.push_back(data_input_buff[i]); data_tmp.push_back(data_input_buff[i]);
data_tmp[data_tmp.size()-1].point_section_asso = 1; data_tmp[data_tmp.size()-1].point_section_asso = 1;
} }
for (int i=0;i<data_input->size();i++) for (int i=0;i<data_input->size();i++)
{ {
data_tmp.push_back((*data_input)[i]); data_tmp.push_back((*data_input)[i]);
data_tmp[data_tmp.size()-1].point_section_asso = 2; data_tmp[data_tmp.size()-1].point_section_asso = 2;
} }
// //去除点迹中，1km以内，SNR小于20dB的点
// for (int i=0;i<data_input->size();i++)
// {
// if((*data_input)[i].Range > 1000 || (*data_input)[i].snr >= 20){
// data_tmp.push_back((*data_input)[i]);
// data_tmp[data_tmp.size()-1].point_section_asso = 2;
// }
// }
//1.2 把data_input、data_input_buff清空 //1.2 把data_input、data_input_buff清空
QVector<PointRecv>().swap(data_input_buff); std::vector<PointRecv>().swap(data_input_buff);
QVector<PointRecv>().swap(*data_input); std::vector<PointRecv>().swap(*data_input);
//1.3 对data_tmp进行凝聚 //1.3 对data_tmp进行凝聚
if(data_tmp.size()>1) if(data_tmp.size()>1)
@@ -145,7 +146,7 @@ int Dot_Coh::dot_coh_process_buff( QVector <PointRecv> *data_input,
float point_0_A=data_tmp[loop_of_point].Amplitude; float point_0_A=data_tmp[loop_of_point].Amplitude;
for (unsigned int i=loop_of_point+1;i<data_tmp.size();i++) for (unsigned int i=loop_of_point+1;i<data_tmp.size();i++)
{ {
if(data_tmp[loop_of_point].Use_Flag!=1) if(data_tmp[loop_of_point].Use_Flag!=1 && data_tmp[i].Use_Flag!=1)
{ {
float point_1_R=data_tmp[i].Range; float point_1_R=data_tmp[i].Range;
float point_1_V=data_tmp[i].Velocity; float point_1_V=data_tmp[i].Velocity;
@@ -155,7 +156,8 @@ int Dot_Coh::dot_coh_process_buff( QVector <PointRecv> *data_input,
//凝聚条件： 距离、方位接近 //凝聚条件： 距离、方位接近
if(Work_Parameter.work_mode == 0) if(Work_Parameter.work_mode == 0)
{ {
if( (fabs(point_0_R-point_1_R)<=DOT_COH_RANGE && fabs(point_0_F-point_1_F) <=DOT_COH_AZI/180.0*PI && fabs(point_0_V-point_1_V)<=DOT_COH_V)// float delta_F = fabs(point_0_F-point_1_F)<2*PI-fabs(point_0_F-point_1_F) ? fabs(point_0_F-point_1_F) :2*PI-fabs(point_0_F-point_1_F);
if( (fabs(point_0_R-point_1_R)<=DOT_COH_RANGE && delta_F <=DOT_COH_AZI/180.0*PI && fabs(point_0_V-point_1_V)<=DOT_COH_V)//
&& point_0_A <point_1_A )// && point_0_A <point_1_A )//
{ {
point_0_R=data_tmp[i].Range; point_0_R=data_tmp[i].Range;
@@ -164,7 +166,7 @@ int Dot_Coh::dot_coh_process_buff( QVector <PointRecv> *data_input,
point_0_F=data_tmp[i].Azimuth; point_0_F=data_tmp[i].Azimuth;
data_tmp[loop_of_point].Use_Flag=1; data_tmp[loop_of_point].Use_Flag=1;
} }
else if( (fabs(point_0_R-point_1_R)<=DOT_COH_RANGE && fabs(point_0_F-point_1_F) <=DOT_COH_AZI/180.0*PI && fabs(point_0_V-point_1_V)<=DOT_COH_V)// else if( (fabs(point_0_R-point_1_R)<=DOT_COH_RANGE && delta_F <=DOT_COH_AZI/180.0*PI && fabs(point_0_V-point_1_V)<=DOT_COH_V)//
&& point_0_A >= point_1_A)// && point_0_A >= point_1_A)//
{ {
data_tmp[i].Use_Flag=1; data_tmp[i].Use_Flag=1;
@@ -188,8 +190,6 @@ int Dot_Coh::dot_coh_process_buff( QVector <PointRecv> *data_input,
data_tmp[i].Use_Flag=1; data_tmp[i].Use_Flag=1;
} }
} }
} }
} }
@@ -198,7 +198,7 @@ int Dot_Coh::dot_coh_process_buff( QVector <PointRecv> *data_input,
} }
//1.4 删除凝聚点 和 量程范围外点 //1.4 删除凝聚点 和 量程范围外点
QVector <PointRecv>::iterator Iter; std::vector <PointRecv>::iterator Iter;
for (Iter=data_tmp.begin(); Iter!=data_tmp.end();) for (Iter=data_tmp.begin(); Iter!=data_tmp.end();)
{ {
if((*Iter).Use_Flag==1 || (*Iter).Range <R_MIN || (*Iter).Range > R_MAX ) if((*Iter).Use_Flag==1 || (*Iter).Range <R_MIN || (*Iter).Range > R_MAX )
@@ -225,9 +225,7 @@ int Dot_Coh::dot_coh_process_buff( QVector <PointRecv> *data_input,
(*data_input).push_back(data_tmp[i]); (*data_input).push_back(data_tmp[i]);
} }
} }
QVector<PointRecv>().swap(data_tmp); std::vector<PointRecv>().swap(data_tmp);
//2.data_input_buff数据输出给point_recv //2.data_input_buff数据输出给point_recv
@@ -236,8 +234,7 @@ int Dot_Coh::dot_coh_process_buff( QVector <PointRecv> *data_input,
(*point_recv).push_back(data_input_buff[i]); (*point_recv).push_back(data_input_buff[i]);
} }
QVector<PointRecv>().swap(data_input_buff); std::vector<PointRecv>().swap(data_input_buff);
//3.data_input数据输出给data_input_buff //3.data_input数据输出给data_input_buff
for (int i=0;i<data_input->size();i++) for (int i=0;i<data_input->size();i++)
@@ -245,16 +242,15 @@ int Dot_Coh::dot_coh_process_buff( QVector <PointRecv> *data_input,
data_input_buff.push_back((*data_input)[i]); data_input_buff.push_back((*data_input)[i]);
} }
return 0; return 0;
} }
Dot_Coh::Dot_Coh(void) Dot_Coh::Dot_Coh(void)
{ {
} }
void Dot_Coh::reset()
{
data_input_buff.clear();
}
data_process_class_dll/dot_coh.h
+7 -14
View File
@@ -3,8 +3,7 @@
#include "data_process_class_dll.h" #include "data_process_class_dll.h"
#include "parameters.h" #include "parameters.h"
#include "struct.h" #include "struct.h"
#include <QVector> #include <vector>
#include <QDebug>
using namespace std; using namespace std;
@@ -14,29 +13,23 @@ class Dot_Coh
public: public:
// 点迹凝聚函数 // 点迹凝聚函数
int dot_coh_process( QVector <PointRecv> *data_input, //输入的点迹 int dot_coh_process( std::vector <PointRecv> *data_input, //输入的点迹
QVector <PointRecv> *point_recv, //输出点迹 std::vector <PointRecv> *point_recv, //输出点迹
struct RadarPara Work_Parameter //工作参数 struct RadarPara Work_Parameter //工作参数
); );
//点迹凝聚函数，缓存一帧，一边输出，一边进行滑窗凝聚 //点迹凝聚函数，缓存一帧，一边输出，一边进行滑窗凝聚
int dot_coh_process_buff( QVector <PointRecv> *data_input, //输入的点迹 int dot_coh_process_buff( std::vector <PointRecv> *data_input, //输入的点迹
QVector <PointRecv> *point_recv, //输出点迹 std::vector <PointRecv> *point_recv, //输出点迹
struct RadarPara Work_Parameter //工作参数 struct RadarPara Work_Parameter //工作参数
); );
//构造函数 //构造函数
Dot_Coh(); Dot_Coh();
void reset();
private: private:
QVector <PointRecv> data_input_buff; std::vector <PointRecv> data_input_buff;
}; };
data_process_class_dll/dot_coh_tas.cpp
+10 -17
View File
@@ -1,13 +1,11 @@
#include "dot_coh_tas.h" #include "dot_coh_tas.h"
#include <qmath.h> #include <cmath>
#include"memory.h" #include <cstring>
#include <QVector> #include <vector>
using namespace std; using namespace std;
int Dot_Coh_TAS::dot_coh_tas_process(std::vector <PointRecv> *data_input, //输入点迹
std::vector <PointRecv> *point_recv_tas //输出点迹
int Dot_Coh_TAS::dot_coh_tas_process(QVector <PointRecv> *data_input, //输入点迹
QVector <PointRecv> *point_recv_tas //输出点迹
) )
{ {
if (data_input->size() == 0) { if (data_input->size() == 0) {
@@ -24,7 +22,7 @@ int Dot_Coh_TAS::dot_coh_tas_process(QVector <PointRecv> *data_in
float point_0_A=(*data_input)[loop_of_point].Amplitude; float point_0_A=(*data_input)[loop_of_point].Amplitude;
for ( int i=loop_of_point+1;i<(*data_input).size();i++) for ( int i=loop_of_point+1;i<(*data_input).size();i++)
{ {
if((*data_input)[loop_of_point].Use_Flag!=1) if((*data_input)[loop_of_point].Use_Flag!=1 && (*data_input)[i].Use_Flag!=1)
{ {
float point_1_R=(*data_input)[i].Range; float point_1_R=(*data_input)[i].Range;
float point_1_V=(*data_input)[i].Velocity; float point_1_V=(*data_input)[i].Velocity;
@@ -32,7 +30,8 @@ int Dot_Coh_TAS::dot_coh_tas_process(QVector <PointRecv> *data_in
float point_1_A=(*data_input)[i].Amplitude; float point_1_A=(*data_input)[i].Amplitude;
//凝聚条件： 距离、方位接近 //凝聚条件： 距离、方位接近
if( (fabs(point_0_R-point_1_R)<=DOT_COH_RANGE && fabs(point_0_F-point_1_F) <=DOT_COH_AZI/180.0*PI && fabs(point_0_V-point_1_V)<=DOT_COH_V) float delta_F = fabs(point_0_F-point_1_F)<2*PI-fabs(point_0_F-point_1_F) ? fabs(point_0_F-point_1_F) :2*PI-fabs(point_0_F-point_1_F);
if( (fabs(point_0_R-point_1_R)<=DOT_COH_RANGE && delta_F <=DOT_COH_AZI/180.0*PI && fabs(point_0_V-point_1_V)<=DOT_COH_V)
&& point_0_A <point_1_A ) && point_0_A <point_1_A )
{ {
point_0_R=(*data_input)[i].Range; point_0_R=(*data_input)[i].Range;
@@ -41,7 +40,7 @@ int Dot_Coh_TAS::dot_coh_tas_process(QVector <PointRecv> *data_in
point_0_F=(*data_input)[i].Azimuth; point_0_F=(*data_input)[i].Azimuth;
(*data_input)[loop_of_point].Use_Flag=1; (*data_input)[loop_of_point].Use_Flag=1;
} }
else if( (fabs(point_0_R-point_1_R)<=DOT_COH_RANGE && fabs(point_0_F-point_1_F) <=DOT_COH_AZI/180.0*PI && fabs(point_0_V-point_1_V)<=DOT_COH_V) else if( (fabs(point_0_R-point_1_R)<=DOT_COH_RANGE && delta_F <=DOT_COH_AZI/180.0*PI && fabs(point_0_V-point_1_V)<=DOT_COH_V)
&& point_0_A >= point_1_A) && point_0_A >= point_1_A)
{ {
(*data_input)[i].Use_Flag=1; (*data_input)[i].Use_Flag=1;
@@ -51,10 +50,8 @@ int Dot_Coh_TAS::dot_coh_tas_process(QVector <PointRecv> *data_in
} }
} }
//删除凝聚点 和 量程范围外点 //删除凝聚点 和 量程范围外点
QVector <PointRecv>::iterator Iter; std::vector <PointRecv>::iterator Iter;
for (Iter=data_input->begin(); Iter!=data_input->end();) for (Iter=data_input->begin(); Iter!=data_input->end();)
{ {
if((*Iter).Use_Flag==1 || (*Iter).Range <R_MIN || (*Iter).Range > R_MAX ) if((*Iter).Use_Flag==1 || (*Iter).Range <R_MIN || (*Iter).Range > R_MAX )
@@ -68,14 +65,10 @@ int Dot_Coh_TAS::dot_coh_tas_process(QVector <PointRecv> *data_in
} }
} }
for (int i=0;i<data_input->size();i++) for (int i=0;i<data_input->size();i++)
{ {
(*point_recv_tas).push_back((*data_input)[i]); (*point_recv_tas).push_back((*data_input)[i]);
} }
return 1; return 1;
} }
data_process_class_dll/dot_coh_tas.h
+3 -6
View File
@@ -2,18 +2,15 @@
#define DOT_COH_TAS_H #define DOT_COH_TAS_H
#include "parameters.h" #include "parameters.h"
#include "struct.h" #include "struct.h"
#include <QVector> #include <vector>
class Dot_Coh_TAS class Dot_Coh_TAS
{ {
public: public:
// 点迹凝聚函数 // 点迹凝聚函数
int dot_coh_tas_process(QVector <PointRecv> *data_input, //输入点迹 int dot_coh_tas_process(std::vector <PointRecv> *data_input, //输入点迹
QVector <PointRecv> *point_recv_tas //输出点迹 std::vector <PointRecv> *point_recv_tas //输出点迹
); );
}; };
#endif // DOT_COH_TAS_H #endif // DOT_COH_TAS_H
data_process_class_dll/eigen-3.3.7/.hgeol
-11
View File
@@ -1,11 +0,0 @@
[patterns]
*.sh = LF
*.MINPACK = CRLF
scripts/*.in = LF
debug/msvc/*.dat = CRLF
debug/msvc/*.natvis = CRLF
unsupported/test/mpreal/*.* = CRLF
** = native
[repository]
native = LF
data_process_class_dll/eigen-3.3.7/.hgignore
-34
View File
@@ -1,34 +0,0 @@
syntax: glob
qrc_*cxx
*.orig
*.pyc
*.diff
diff
*.save
save
*.old
*.gmo
*.qm
core
core.*
*.bak
*~
*build*
*.moc.*
*.moc
ui_*
CMakeCache.txt
tags
.*.swp
activity.png
*.out
*.php*
*.log
*.orig
*.rej
log
patch
a
a.*
lapack/testing
lapack/reference
data_process_class_dll/eigen-3.3.7/CMakeLists.txt
-616
View File
@@ -1,616 +0,0 @@
project(Eigen3)
cmake_minimum_required(VERSION 2.8.5)
# guard against in-source builds
if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
message(FATAL_ERROR "In-source builds not allowed. Please make a new directory (called a build directory) and run CMake from there. You may need to remove CMakeCache.txt. ")
endif()
# Alias Eigen_*_DIR to Eigen3_*_DIR:
set(Eigen_SOURCE_DIR ${Eigen3_SOURCE_DIR})
set(Eigen_BINARY_DIR ${Eigen3_BINARY_DIR})
# guard against bad build-type strings
if (NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE "Release")
endif()
string(TOLOWER "${CMAKE_BUILD_TYPE}" cmake_build_type_tolower)
if( NOT cmake_build_type_tolower STREQUAL "debug"
AND NOT cmake_build_type_tolower STREQUAL "release"
AND NOT cmake_build_type_tolower STREQUAL "relwithdebinfo")
message(FATAL_ERROR "Unknown build type \"${CMAKE_BUILD_TYPE}\". Allowed values are Debug, Release, RelWithDebInfo (case-insensitive).")
endif()
#############################################################################
# retrieve version infomation #
#############################################################################
# automatically parse the version number
file(READ "${PROJECT_SOURCE_DIR}/Eigen/src/Core/util/Macros.h" _eigen_version_header)
string(REGEX MATCH "define[ \t]+EIGEN_WORLD_VERSION[ \t]+([0-9]+)" _eigen_world_version_match "${_eigen_version_header}")
set(EIGEN_WORLD_VERSION "${CMAKE_MATCH_1}")
string(REGEX MATCH "define[ \t]+EIGEN_MAJOR_VERSION[ \t]+([0-9]+)" _eigen_major_version_match "${_eigen_version_header}")
set(EIGEN_MAJOR_VERSION "${CMAKE_MATCH_1}")
string(REGEX MATCH "define[ \t]+EIGEN_MINOR_VERSION[ \t]+([0-9]+)" _eigen_minor_version_match "${_eigen_version_header}")
set(EIGEN_MINOR_VERSION "${CMAKE_MATCH_1}")
set(EIGEN_VERSION_NUMBER ${EIGEN_WORLD_VERSION}.${EIGEN_MAJOR_VERSION}.${EIGEN_MINOR_VERSION})
# if we are not in a mercurial clone
if(IS_DIRECTORY ${CMAKE_SOURCE_DIR}/.hg)
# if the mercurial program is absent or this will leave the EIGEN_HG_CHANGESET string empty,
# but won't stop CMake.
execute_process(COMMAND hg tip -R ${CMAKE_SOURCE_DIR} OUTPUT_VARIABLE EIGEN_HGTIP_OUTPUT)
execute_process(COMMAND hg branch -R ${CMAKE_SOURCE_DIR} OUTPUT_VARIABLE EIGEN_BRANCH_OUTPUT)
endif()
# if this is the default (aka development) branch, extract the mercurial changeset number from the hg tip output...
if(EIGEN_BRANCH_OUTPUT MATCHES "default")
string(REGEX MATCH "^changeset: *[0-9]*:([0-9;a-f]+).*" EIGEN_HG_CHANGESET_MATCH "${EIGEN_HGTIP_OUTPUT}")
set(EIGEN_HG_CHANGESET "${CMAKE_MATCH_1}")
endif(EIGEN_BRANCH_OUTPUT MATCHES "default")
#...and show it next to the version number
if(EIGEN_HG_CHANGESET)
set(EIGEN_VERSION "${EIGEN_VERSION_NUMBER} (mercurial changeset ${EIGEN_HG_CHANGESET})")
else(EIGEN_HG_CHANGESET)
set(EIGEN_VERSION "${EIGEN_VERSION_NUMBER}")
endif(EIGEN_HG_CHANGESET)
include(CheckCXXCompilerFlag)
include(GNUInstallDirs)
set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
option(EIGEN_TEST_CXX11 "Enable testing with C++11 and C++11 features (e.g. Tensor module)." OFF)
macro(ei_add_cxx_compiler_flag FLAG)
string(REGEX REPLACE "-" "" SFLAG1 ${FLAG})
string(REGEX REPLACE "\\+" "p" SFLAG ${SFLAG1})
check_cxx_compiler_flag(${FLAG} COMPILER_SUPPORT_${SFLAG})
if(COMPILER_SUPPORT_${SFLAG})
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLAG}")
endif()
endmacro(ei_add_cxx_compiler_flag)
check_cxx_compiler_flag("-std=c++11" EIGEN_COMPILER_SUPPORT_CPP11)
if(EIGEN_TEST_CXX11)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_EXTENSIONS OFF)
if(EIGEN_COMPILER_SUPPORT_CPP11)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
endif()
else()
#set(CMAKE_CXX_STANDARD 03)
#set(CMAKE_CXX_EXTENSIONS OFF)
ei_add_cxx_compiler_flag("-std=c++03")
endif()
#############################################################################
# find how to link to the standard libraries #
#############################################################################
find_package(StandardMathLibrary)
set(EIGEN_TEST_CUSTOM_LINKER_FLAGS "" CACHE STRING "Additional linker flags when linking unit tests.")
set(EIGEN_TEST_CUSTOM_CXX_FLAGS "" CACHE STRING "Additional compiler flags when compiling unit tests.")
set(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO "")
if(NOT STANDARD_MATH_LIBRARY_FOUND)
message(FATAL_ERROR
"Can't link to the standard math library. Please report to the Eigen developers, telling them about your platform.")
else()
if(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO)
set(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO "${EIGEN_STANDARD_LIBRARIES_TO_LINK_TO} ${STANDARD_MATH_LIBRARY}")
else()
set(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO "${STANDARD_MATH_LIBRARY}")
endif()
endif()
if(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO)
message(STATUS "Standard libraries to link to explicitly: ${EIGEN_STANDARD_LIBRARIES_TO_LINK_TO}")
else()
message(STATUS "Standard libraries to link to explicitly: none")
endif()
option(EIGEN_BUILD_BTL "Build benchmark suite" OFF)
# Disable pkgconfig only for native Windows builds
if(NOT WIN32 OR NOT CMAKE_HOST_SYSTEM_NAME MATCHES Windows)
option(EIGEN_BUILD_PKGCONFIG "Build pkg-config .pc file for Eigen" ON)
endif()
set(CMAKE_INCLUDE_CURRENT_DIR ON)
option(EIGEN_SPLIT_LARGE_TESTS "Split large tests into smaller executables" ON)
option(EIGEN_DEFAULT_TO_ROW_MAJOR "Use row-major as default matrix storage order" OFF)
if(EIGEN_DEFAULT_TO_ROW_MAJOR)
add_definitions("-DEIGEN_DEFAULT_TO_ROW_MAJOR")
endif()
set(EIGEN_TEST_MAX_SIZE "320" CACHE STRING "Maximal matrix/vector size, default is 320")
if(NOT MSVC)
# We assume that other compilers are partly compatible with GNUCC
# clang outputs some warnings for unknown flags that are not caught by check_cxx_compiler_flag
# adding -Werror turns such warnings into errors
check_cxx_compiler_flag("-Werror" COMPILER_SUPPORT_WERROR)
if(COMPILER_SUPPORT_WERROR)
set(CMAKE_REQUIRED_FLAGS "-Werror")
endif()
ei_add_cxx_compiler_flag("-pedantic")
ei_add_cxx_compiler_flag("-Wall")
ei_add_cxx_compiler_flag("-Wextra")
#ei_add_cxx_compiler_flag("-Weverything") # clang
ei_add_cxx_compiler_flag("-Wundef")
ei_add_cxx_compiler_flag("-Wcast-align")
ei_add_cxx_compiler_flag("-Wchar-subscripts")
ei_add_cxx_compiler_flag("-Wnon-virtual-dtor")
ei_add_cxx_compiler_flag("-Wunused-local-typedefs")
ei_add_cxx_compiler_flag("-Wpointer-arith")
ei_add_cxx_compiler_flag("-Wwrite-strings")
ei_add_cxx_compiler_flag("-Wformat-security")
ei_add_cxx_compiler_flag("-Wshorten-64-to-32")
ei_add_cxx_compiler_flag("-Wlogical-op")
ei_add_cxx_compiler_flag("-Wenum-conversion")
ei_add_cxx_compiler_flag("-Wc++11-extensions")
ei_add_cxx_compiler_flag("-Wdouble-promotion")
# ei_add_cxx_compiler_flag("-Wconversion")
# -Wshadow is insanely too strict with gcc, hopefully it will become usable with gcc 6
# if(NOT CMAKE_COMPILER_IS_GNUCXX OR (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER "5.0.0"))
if(NOT CMAKE_COMPILER_IS_GNUCXX)
ei_add_cxx_compiler_flag("-Wshadow")
endif()
ei_add_cxx_compiler_flag("-Wno-psabi")
ei_add_cxx_compiler_flag("-Wno-variadic-macros")
ei_add_cxx_compiler_flag("-Wno-long-long")
ei_add_cxx_compiler_flag("-fno-check-new")
ei_add_cxx_compiler_flag("-fno-common")
ei_add_cxx_compiler_flag("-fstrict-aliasing")
ei_add_cxx_compiler_flag("-wd981") # disable ICC's "operands are evaluated in unspecified order" remark
ei_add_cxx_compiler_flag("-wd2304") # disable ICC's "warning #2304: non-explicit constructor with single argument may cause implicit type conversion" produced by -Wnon-virtual-dtor
# The -ansi flag must be added last, otherwise it is also used as a linker flag by check_cxx_compiler_flag making it fails
# Moreover we should not set both -strict-ansi and -ansi
check_cxx_compiler_flag("-strict-ansi" COMPILER_SUPPORT_STRICTANSI)
ei_add_cxx_compiler_flag("-Qunused-arguments") # disable clang warning: argument unused during compilation: '-ansi'
if(COMPILER_SUPPORT_STRICTANSI)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -strict-ansi")
else()
ei_add_cxx_compiler_flag("-ansi")
endif()
if(ANDROID_NDK)
ei_add_cxx_compiler_flag("-pie")
ei_add_cxx_compiler_flag("-fPIE")
endif()
set(CMAKE_REQUIRED_FLAGS "")
option(EIGEN_TEST_SSE2 "Enable/Disable SSE2 in tests/examples" OFF)
if(EIGEN_TEST_SSE2)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse2")
message(STATUS "Enabling SSE2 in tests/examples")
endif()
option(EIGEN_TEST_SSE3 "Enable/Disable SSE3 in tests/examples" OFF)
if(EIGEN_TEST_SSE3)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse3")
message(STATUS "Enabling SSE3 in tests/examples")
endif()
option(EIGEN_TEST_SSSE3 "Enable/Disable SSSE3 in tests/examples" OFF)
if(EIGEN_TEST_SSSE3)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mssse3")
message(STATUS "Enabling SSSE3 in tests/examples")
endif()
option(EIGEN_TEST_SSE4_1 "Enable/Disable SSE4.1 in tests/examples" OFF)
if(EIGEN_TEST_SSE4_1)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse4.1")
message(STATUS "Enabling SSE4.1 in tests/examples")
endif()
option(EIGEN_TEST_SSE4_2 "Enable/Disable SSE4.2 in tests/examples" OFF)
if(EIGEN_TEST_SSE4_2)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse4.2")
message(STATUS "Enabling SSE4.2 in tests/examples")
endif()
option(EIGEN_TEST_AVX "Enable/Disable AVX in tests/examples" OFF)
if(EIGEN_TEST_AVX)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx")
message(STATUS "Enabling AVX in tests/examples")
endif()
option(EIGEN_TEST_FMA "Enable/Disable FMA in tests/examples" OFF)
if(EIGEN_TEST_FMA AND NOT EIGEN_TEST_NEON)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfma")
message(STATUS "Enabling FMA in tests/examples")
endif()
option(EIGEN_TEST_AVX512 "Enable/Disable AVX512 in tests/examples" OFF)
if(EIGEN_TEST_AVX512)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx512f -fabi-version=6 -DEIGEN_ENABLE_AVX512")
message(STATUS "Enabling AVX512 in tests/examples")
endif()
option(EIGEN_TEST_F16C "Enable/Disable F16C in tests/examples" OFF)
if(EIGEN_TEST_F16C)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mf16c")
message(STATUS "Enabling F16C in tests/examples")
endif()
option(EIGEN_TEST_ALTIVEC "Enable/Disable AltiVec in tests/examples" OFF)
if(EIGEN_TEST_ALTIVEC)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -maltivec -mabi=altivec")
message(STATUS "Enabling AltiVec in tests/examples")
endif()
option(EIGEN_TEST_VSX "Enable/Disable VSX in tests/examples" OFF)
if(EIGEN_TEST_VSX)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m64 -mvsx")
message(STATUS "Enabling VSX in tests/examples")
endif()
option(EIGEN_TEST_NEON "Enable/Disable Neon in tests/examples" OFF)
if(EIGEN_TEST_NEON)
if(EIGEN_TEST_FMA)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpu=neon-vfpv4")
else()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpu=neon")
endif()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfloat-abi=hard")
message(STATUS "Enabling NEON in tests/examples")
endif()
option(EIGEN_TEST_NEON64 "Enable/Disable Neon in tests/examples" OFF)
if(EIGEN_TEST_NEON64)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
message(STATUS "Enabling NEON in tests/examples")
endif()
option(EIGEN_TEST_ZVECTOR "Enable/Disable S390X(zEC13) ZVECTOR in tests/examples" OFF)
if(EIGEN_TEST_ZVECTOR)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=z13 -mzvector")
message(STATUS "Enabling S390X(zEC13) ZVECTOR in tests/examples")
endif()
check_cxx_compiler_flag("-fopenmp" COMPILER_SUPPORT_OPENMP)
if(COMPILER_SUPPORT_OPENMP)
option(EIGEN_TEST_OPENMP "Enable/Disable OpenMP in tests/examples" OFF)
if(EIGEN_TEST_OPENMP)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fopenmp")
message(STATUS "Enabling OpenMP in tests/examples")
endif()
endif()
else(NOT MSVC)
# C4127 - conditional expression is constant
# C4714 - marked as __forceinline not inlined (I failed to deactivate it selectively)
# We can disable this warning in the unit tests since it is clear that it occurs
# because we are oftentimes returning objects that have a destructor or may
# throw exceptions - in particular in the unit tests we are throwing extra many
# exceptions to cover indexing errors.
# C4505 - unreferenced local function has been removed (impossible to deactive selectively)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc /wd4127 /wd4505 /wd4714")
# replace all /Wx by /W4
string(REGEX REPLACE "/W[0-9]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
check_cxx_compiler_flag("/openmp" COMPILER_SUPPORT_OPENMP)
if(COMPILER_SUPPORT_OPENMP)
option(EIGEN_TEST_OPENMP "Enable/Disable OpenMP in tests/examples" OFF)
if(EIGEN_TEST_OPENMP)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /openmp")
message(STATUS "Enabling OpenMP in tests/examples")
endif()
endif()
option(EIGEN_TEST_SSE2 "Enable/Disable SSE2 in tests/examples" OFF)
if(EIGEN_TEST_SSE2)
if(NOT CMAKE_CL_64)
# arch is not supported on 64 bit systems, SSE is enabled automatically.
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:SSE2")
endif(NOT CMAKE_CL_64)
message(STATUS "Enabling SSE2 in tests/examples")
endif(EIGEN_TEST_SSE2)
endif(NOT MSVC)
option(EIGEN_TEST_NO_EXPLICIT_VECTORIZATION "Disable explicit vectorization in tests/examples" OFF)
option(EIGEN_TEST_X87 "Force using X87 instructions. Implies no vectorization." OFF)
option(EIGEN_TEST_32BIT "Force generating 32bit code." OFF)
if(EIGEN_TEST_X87)
set(EIGEN_TEST_NO_EXPLICIT_VECTORIZATION ON)
if(CMAKE_COMPILER_IS_GNUCXX)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpmath=387")
message(STATUS "Forcing use of x87 instructions in tests/examples")
else()
message(STATUS "EIGEN_TEST_X87 ignored on your compiler")
endif()
endif()
if(EIGEN_TEST_32BIT)
if(CMAKE_COMPILER_IS_GNUCXX)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m32")
message(STATUS "Forcing generation of 32-bit code in tests/examples")
else()
message(STATUS "EIGEN_TEST_32BIT ignored on your compiler")
endif()
endif()
if(EIGEN_TEST_NO_EXPLICIT_VECTORIZATION)
add_definitions(-DEIGEN_DONT_VECTORIZE=1)
message(STATUS "Disabling vectorization in tests/examples")
endif()
option(EIGEN_TEST_NO_EXPLICIT_ALIGNMENT "Disable explicit alignment (hence vectorization) in tests/examples" OFF)
if(EIGEN_TEST_NO_EXPLICIT_ALIGNMENT)
add_definitions(-DEIGEN_DONT_ALIGN=1)
message(STATUS "Disabling alignment in tests/examples")
endif()
option(EIGEN_TEST_NO_EXCEPTIONS "Disables C++ exceptions" OFF)
if(EIGEN_TEST_NO_EXCEPTIONS)
ei_add_cxx_compiler_flag("-fno-exceptions")
message(STATUS "Disabling exceptions in tests/examples")
endif()
set(EIGEN_CUDA_COMPUTE_ARCH 30 CACHE STRING "The CUDA compute architecture level to target when compiling CUDA code")
include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
# Backward compatibility support for EIGEN_INCLUDE_INSTALL_DIR
if(EIGEN_INCLUDE_INSTALL_DIR)
message(WARNING "EIGEN_INCLUDE_INSTALL_DIR is deprecated. Use INCLUDE_INSTALL_DIR instead.")
endif()
if(EIGEN_INCLUDE_INSTALL_DIR AND NOT INCLUDE_INSTALL_DIR)
set(INCLUDE_INSTALL_DIR ${EIGEN_INCLUDE_INSTALL_DIR}
CACHE PATH "The directory relative to CMAKE_PREFIX_PATH where Eigen header files are installed")
else()
set(INCLUDE_INSTALL_DIR
"${CMAKE_INSTALL_INCLUDEDIR}/eigen3"
CACHE PATH "The directory relative to CMAKE_PREFIX_PATH where Eigen header files are installed"
)
endif()
set(CMAKEPACKAGE_INSTALL_DIR
"${CMAKE_INSTALL_DATADIR}/eigen3/cmake"
CACHE PATH "The directory relative to CMAKE_PREFIX_PATH where Eigen3Config.cmake is installed"
)
set(PKGCONFIG_INSTALL_DIR
"${CMAKE_INSTALL_DATADIR}/pkgconfig"
CACHE PATH "The directory relative to CMAKE_PREFIX_PATH where eigen3.pc is installed"
)
# similar to set_target_properties but append the property instead of overwriting it
macro(ei_add_target_property target prop value)
get_target_property(previous ${target} ${prop})
# if the property wasn't previously set, ${previous} is now "previous-NOTFOUND" which cmake allows catching with plain if()
if(NOT previous)
set(previous "")
endif(NOT previous)
set_target_properties(${target} PROPERTIES ${prop} "${previous} ${value}")
endmacro(ei_add_target_property)
install(FILES
signature_of_eigen3_matrix_library
DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel
)
if(EIGEN_BUILD_PKGCONFIG)
configure_file(eigen3.pc.in eigen3.pc @ONLY)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/eigen3.pc
DESTINATION ${PKGCONFIG_INSTALL_DIR}
)
endif()
add_subdirectory(Eigen)
add_subdirectory(doc EXCLUDE_FROM_ALL)
option(BUILD_TESTING "Enable creation of Eigen tests." ON)
if(BUILD_TESTING)
include(EigenConfigureTesting)
if(EIGEN_LEAVE_TEST_IN_ALL_TARGET)
add_subdirectory(test) # can't do EXCLUDE_FROM_ALL here, breaks CTest
else()
add_subdirectory(test EXCLUDE_FROM_ALL)
endif()
endif()
if(EIGEN_LEAVE_TEST_IN_ALL_TARGET)
add_subdirectory(blas)
add_subdirectory(lapack)
else()
add_subdirectory(blas EXCLUDE_FROM_ALL)
add_subdirectory(lapack EXCLUDE_FROM_ALL)
endif()
# add SYCL
option(EIGEN_TEST_SYCL "Add Sycl support." OFF)
if(EIGEN_TEST_SYCL)
set (CMAKE_MODULE_PATH "${CMAKE_ROOT}/Modules" "cmake/Modules/" "${CMAKE_MODULE_PATH}")
include(FindComputeCpp)
endif()
add_subdirectory(unsupported)
add_subdirectory(demos EXCLUDE_FROM_ALL)
# must be after test and unsupported, for configuring buildtests.in
add_subdirectory(scripts EXCLUDE_FROM_ALL)
# TODO: consider also replacing EIGEN_BUILD_BTL by a custom target "make btl"?
if(EIGEN_BUILD_BTL)
add_subdirectory(bench/btl EXCLUDE_FROM_ALL)
endif(EIGEN_BUILD_BTL)
if(NOT WIN32)
add_subdirectory(bench/spbench EXCLUDE_FROM_ALL)
endif(NOT WIN32)
configure_file(scripts/cdashtesting.cmake.in cdashtesting.cmake @ONLY)
if(BUILD_TESTING)
ei_testing_print_summary()
endif()
message(STATUS "")
message(STATUS "Configured Eigen ${EIGEN_VERSION_NUMBER}")
message(STATUS "")
option(EIGEN_FAILTEST "Enable failtests." OFF)
if(EIGEN_FAILTEST)
add_subdirectory(failtest)
endif()
string(TOLOWER "${CMAKE_GENERATOR}" cmake_generator_tolower)
if(cmake_generator_tolower MATCHES "makefile")
message(STATUS "Some things you can do now:")
message(STATUS "--------------+--------------------------------------------------------------")
message(STATUS "Command | Description")
message(STATUS "--------------+--------------------------------------------------------------")
message(STATUS "make install | Install Eigen. Headers will be installed to:")
message(STATUS " | <CMAKE_INSTALL_PREFIX>/<INCLUDE_INSTALL_DIR>")
message(STATUS " | Using the following values:")
message(STATUS " | CMAKE_INSTALL_PREFIX: ${CMAKE_INSTALL_PREFIX}")
message(STATUS " | INCLUDE_INSTALL_DIR: ${INCLUDE_INSTALL_DIR}")
message(STATUS " | Change the install location of Eigen headers using:")
message(STATUS " | cmake . -DCMAKE_INSTALL_PREFIX=yourprefix")
message(STATUS " | Or:")
message(STATUS " | cmake . -DINCLUDE_INSTALL_DIR=yourdir")
message(STATUS "make doc | Generate the API documentation, requires Doxygen & LaTeX")
message(STATUS "make check | Build and run the unit-tests. Read this page:")
message(STATUS " | http://eigen.tuxfamily.org/index.php?title=Tests")
message(STATUS "make blas | Build BLAS library (not the same thing as Eigen)")
message(STATUS "make uninstall| Removes files installed by make install")
message(STATUS "--------------+--------------------------------------------------------------")
else()
message(STATUS "To build/run the unit tests, read this page:")
message(STATUS " http://eigen.tuxfamily.org/index.php?title=Tests")
endif()
message(STATUS "")
set ( EIGEN_VERSION_STRING ${EIGEN_VERSION_NUMBER} )
set ( EIGEN_VERSION_MAJOR ${EIGEN_WORLD_VERSION} )
set ( EIGEN_VERSION_MINOR ${EIGEN_MAJOR_VERSION} )
set ( EIGEN_VERSION_PATCH ${EIGEN_MINOR_VERSION} )
set ( EIGEN_DEFINITIONS "")
set ( EIGEN_INCLUDE_DIR "${CMAKE_INSTALL_PREFIX}/${INCLUDE_INSTALL_DIR}" )
set ( EIGEN_ROOT_DIR ${CMAKE_INSTALL_PREFIX} )
# Interface libraries require at least CMake 3.0
if (NOT CMAKE_VERSION VERSION_LESS 3.0)
include (CMakePackageConfigHelpers)
# Imported target support
add_library (eigen INTERFACE)
target_compile_definitions (eigen INTERFACE ${EIGEN_DEFINITIONS})
target_include_directories (eigen INTERFACE
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
$<INSTALL_INTERFACE:${INCLUDE_INSTALL_DIR}>
)
# Export as title case Eigen
set_target_properties (eigen PROPERTIES EXPORT_NAME Eigen)
install (TARGETS eigen EXPORT Eigen3Targets)
configure_package_config_file (
${CMAKE_CURRENT_SOURCE_DIR}/cmake/Eigen3Config.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/Eigen3Config.cmake
PATH_VARS EIGEN_INCLUDE_DIR EIGEN_ROOT_DIR
INSTALL_DESTINATION ${CMAKEPACKAGE_INSTALL_DIR}
NO_CHECK_REQUIRED_COMPONENTS_MACRO # Eigen does not provide components
)
# Remove CMAKE_SIZEOF_VOID_P from Eigen3ConfigVersion.cmake since Eigen does
# not depend on architecture specific settings or libraries. More
# specifically, an Eigen3Config.cmake generated from a 64 bit target can be
# used for 32 bit targets as well (and vice versa).
set (_Eigen3_CMAKE_SIZEOF_VOID_P ${CMAKE_SIZEOF_VOID_P})
unset (CMAKE_SIZEOF_VOID_P)
write_basic_package_version_file (Eigen3ConfigVersion.cmake
VERSION ${EIGEN_VERSION_NUMBER}
COMPATIBILITY SameMajorVersion)
set (CMAKE_SIZEOF_VOID_P ${_Eigen3_CMAKE_SIZEOF_VOID_P})
# The Eigen target will be located in the Eigen3 namespace. Other CMake
# targets can refer to it using Eigen3::Eigen.
export (TARGETS eigen NAMESPACE Eigen3:: FILE Eigen3Targets.cmake)
# Export Eigen3 package to CMake registry such that it can be easily found by
# CMake even if it has not been installed to a standard directory.
export (PACKAGE Eigen3)
install (EXPORT Eigen3Targets NAMESPACE Eigen3:: DESTINATION ${CMAKEPACKAGE_INSTALL_DIR})
else (NOT CMAKE_VERSION VERSION_LESS 3.0)
# Fallback to legacy Eigen3Config.cmake without the imported target
# If CMakePackageConfigHelpers module is available (CMake >= 2.8.8)
# create a relocatable Config file, otherwise leave the hardcoded paths
include(CMakePackageConfigHelpers OPTIONAL RESULT_VARIABLE CPCH_PATH)
if(CPCH_PATH)
configure_package_config_file (
${CMAKE_CURRENT_SOURCE_DIR}/cmake/Eigen3ConfigLegacy.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/Eigen3Config.cmake
PATH_VARS EIGEN_INCLUDE_DIR EIGEN_ROOT_DIR
INSTALL_DESTINATION ${CMAKEPACKAGE_INSTALL_DIR}
NO_CHECK_REQUIRED_COMPONENTS_MACRO # Eigen does not provide components
)
else()
# The PACKAGE_* variables are defined by the configure_package_config_file
# but without it we define them manually to the hardcoded paths
set(PACKAGE_INIT "")
set(PACKAGE_EIGEN_INCLUDE_DIR ${EIGEN_INCLUDE_DIR})
set(PACKAGE_EIGEN_ROOT_DIR ${EIGEN_ROOT_DIR})
configure_file ( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Eigen3ConfigLegacy.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/Eigen3Config.cmake
@ONLY ESCAPE_QUOTES )
endif()
write_basic_package_version_file( Eigen3ConfigVersion.cmake
VERSION ${EIGEN_VERSION_NUMBER}
COMPATIBILITY SameMajorVersion )
endif (NOT CMAKE_VERSION VERSION_LESS 3.0)
install ( FILES ${CMAKE_CURRENT_SOURCE_DIR}/cmake/UseEigen3.cmake
${CMAKE_CURRENT_BINARY_DIR}/Eigen3Config.cmake
${CMAKE_CURRENT_BINARY_DIR}/Eigen3ConfigVersion.cmake
DESTINATION ${CMAKEPACKAGE_INSTALL_DIR} )
# Add uninstall target
add_custom_target ( uninstall
COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/EigenUninstall.cmake)
data_process_class_dll/eigen-3.3.7/COPYING.BSD
-26
View File
@@ -1,26 +0,0 @@
/*
Copyright (c) 2011, Intel Corporation. All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of Intel Corporation nor the names of its contributors may
be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
data_process_class_dll/eigen-3.3.7/COPYING.GPL
-674
View File
@@ -1,674 +0,0 @@
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
<program> Copyright (C) <year> <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.
data_process_class_dll/eigen-3.3.7/COPYING.LGPL
-502
View File
@@ -1,502 +0,0 @@
GNU LESSER GENERAL PUBLIC LICENSE
Version 2.1, February 1999
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.
When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.
To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
To protect each distributor, we want to make it very clear that
there is no warranty for the free library. Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.
Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.
We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.
For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard. To achieve this, non-free programs must be
allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
GNU LESSER GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.
c) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
d) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
e) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!
data_process_class_dll/eigen-3.3.7/COPYING.MINPACK
-52
View File
@@ -1,52 +0,0 @@
Minpack Copyright Notice (1999) University of Chicago. All rights reserved
Redistribution and use in source and binary forms, with or
without modification, are permitted provided that the
following conditions are met:
1. Redistributions of source code must retain the above
copyright notice, this list of conditions and the following
disclaimer.
2. Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials
provided with the distribution.
3. The end-user documentation included with the
redistribution, if any, must include the following
acknowledgment:
"This product includes software developed by the
University of Chicago, as Operator of Argonne National
Laboratory.
Alternately, this acknowledgment may appear in the software
itself, if and wherever such third-party acknowledgments
normally appear.
4. WARRANTY DISCLAIMER. THE SOFTWARE IS SUPPLIED "AS IS"
WITHOUT WARRANTY OF ANY KIND. THE COPYRIGHT HOLDER, THE
UNITED STATES, THE UNITED STATES DEPARTMENT OF ENERGY, AND
THEIR EMPLOYEES: (1) DISCLAIM ANY WARRANTIES, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO ANY IMPLIED WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE
OR NON-INFRINGEMENT, (2) DO NOT ASSUME ANY LEGAL LIABILITY
OR RESPONSIBILITY FOR THE ACCURACY, COMPLETENESS, OR
USEFULNESS OF THE SOFTWARE, (3) DO NOT REPRESENT THAT USE OF
THE SOFTWARE WOULD NOT INFRINGE PRIVATELY OWNED RIGHTS, (4)
DO NOT WARRANT THAT THE SOFTWARE WILL FUNCTION
UNINTERRUPTED, THAT IT IS ERROR-FREE OR THAT ANY ERRORS WILL
BE CORRECTED.
5. LIMITATION OF LIABILITY. IN NO EVENT WILL THE COPYRIGHT
HOLDER, THE UNITED STATES, THE UNITED STATES DEPARTMENT OF
ENERGY, OR THEIR EMPLOYEES: BE LIABLE FOR ANY INDIRECT,
INCIDENTAL, CONSEQUENTIAL, SPECIAL OR PUNITIVE DAMAGES OF
ANY KIND OR NATURE, INCLUDING BUT NOT LIMITED TO LOSS OF
PROFITS OR LOSS OF DATA, FOR ANY REASON WHATSOEVER, WHETHER
SUCH LIABILITY IS ASSERTED ON THE BASIS OF CONTRACT, TORT
(INCLUDING NEGLIGENCE OR STRICT LIABILITY), OR OTHERWISE,
EVEN IF ANY OF SAID PARTIES HAS BEEN WARNED OF THE
POSSIBILITY OF SUCH LOSS OR DAMAGES.
data_process_class_dll/eigen-3.3.7/COPYING.MPL2
-373
View File
@@ -1,373 +0,0 @@
Mozilla Public License Version 2.0
==================================
1. Definitions
--------------
1.1. "Contributor"
means each individual or legal entity that creates, contributes to
the creation of, or owns Covered Software.
1.2. "Contributor Version"
means the combination of the Contributions of others (if any) used
by a Contributor and that particular Contributor's Contribution.
1.3. "Contribution"
means Covered Software of a particular Contributor.
1.4. "Covered Software"
means Source Code Form to which the initial Contributor has attached
the notice in Exhibit A, the Executable Form of such Source Code
Form, and Modifications of such Source Code Form, in each case
including portions thereof.
1.5. "Incompatible With Secondary Licenses"
means
(a) that the initial Contributor has attached the notice described
in Exhibit B to the Covered Software; or
(b) that the Covered Software was made available under the terms of
version 1.1 or earlier of the License, but not also under the
terms of a Secondary License.
1.6. "Executable Form"
means any form of the work other than Source Code Form.
1.7. "Larger Work"
means a work that combines Covered Software with other material, in
a separate file or files, that is not Covered Software.
1.8. "License"
means this document.
1.9. "Licensable"
means having the right to grant, to the maximum extent possible,
whether at the time of the initial grant or subsequently, any and
all of the rights conveyed by this License.
1.10. "Modifications"
means any of the following:
(a) any file in Source Code Form that results from an addition to,
deletion from, or modification of the contents of Covered
Software; or
(b) any new file in Source Code Form that contains any Covered
Software.
1.11. "Patent Claims" of a Contributor
means any patent claim(s), including without limitation, method,
process, and apparatus claims, in any patent Licensable by such
Contributor that would be infringed, but for the grant of the
License, by the making, using, selling, offering for sale, having
made, import, or transfer of either its Contributions or its
Contributor Version.
1.12. "Secondary License"
means either the GNU General Public License, Version 2.0, the GNU
Lesser General Public License, Version 2.1, the GNU Affero General
Public License, Version 3.0, or any later versions of those
licenses.
1.13. "Source Code Form"
means the form of the work preferred for making modifications.
1.14. "You" (or "Your")
means an individual or a legal entity exercising rights under this
License. For legal entities, "You" includes any entity that
controls, is controlled by, or is under common control with You. For
purposes of this definition, "control" means (a) the power, direct
or indirect, to cause the direction or management of such entity,
whether by contract or otherwise, or (b) ownership of more than
fifty percent (50%) of the outstanding shares or beneficial
ownership of such entity.
2. License Grants and Conditions
--------------------------------
2.1. Grants
Each Contributor hereby grants You a world-wide, royalty-free,
non-exclusive license:
(a) under intellectual property rights (other than patent or trademark)
Licensable by such Contributor to use, reproduce, make available,
modify, display, perform, distribute, and otherwise exploit its
Contributions, either on an unmodified basis, with Modifications, or
as part of a Larger Work; and
(b) under Patent Claims of such Contributor to make, use, sell, offer
for sale, have made, import, and otherwise transfer either its
Contributions or its Contributor Version.
2.2. Effective Date
The licenses granted in Section 2.1 with respect to any Contribution
become effective for each Contribution on the date the Contributor first
distributes such Contribution.
2.3. Limitations on Grant Scope
The licenses granted in this Section 2 are the only rights granted under
this License. No additional rights or licenses will be implied from the
distribution or licensing of Covered Software under this License.
Notwithstanding Section 2.1(b) above, no patent license is granted by a
Contributor:
(a) for any code that a Contributor has removed from Covered Software;
or
(b) for infringements caused by: (i) Your and any other third party's
modifications of Covered Software, or (ii) the combination of its
Contributions with other software (except as part of its Contributor
Version); or
(c) under Patent Claims infringed by Covered Software in the absence of
its Contributions.
This License does not grant any rights in the trademarks, service marks,
or logos of any Contributor (except as may be necessary to comply with
the notice requirements in Section 3.4).
2.4. Subsequent Licenses
No Contributor makes additional grants as a result of Your choice to
distribute the Covered Software under a subsequent version of this
License (see Section 10.2) or under the terms of a Secondary License (if
permitted under the terms of Section 3.3).
2.5. Representation
Each Contributor represents that the Contributor believes its
Contributions are its original creation(s) or it has sufficient rights
to grant the rights to its Contributions conveyed by this License.
2.6. Fair Use
This License is not intended to limit any rights You have under
applicable copyright doctrines of fair use, fair dealing, or other
equivalents.
2.7. Conditions
Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
in Section 2.1.
3. Responsibilities
-------------------
3.1. Distribution of Source Form
All distribution of Covered Software in Source Code Form, including any
Modifications that You create or to which You contribute, must be under
the terms of this License. You must inform recipients that the Source
Code Form of the Covered Software is governed by the terms of this
License, and how they can obtain a copy of this License. You may not
attempt to alter or restrict the recipients' rights in the Source Code
Form.
3.2. Distribution of Executable Form
If You distribute Covered Software in Executable Form then:
(a) such Covered Software must also be made available in Source Code
Form, as described in Section 3.1, and You must inform recipients of
the Executable Form how they can obtain a copy of such Source Code
Form by reasonable means in a timely manner, at a charge no more
than the cost of distribution to the recipient; and
(b) You may distribute such Executable Form under the terms of this
License, or sublicense it under different terms, provided that the
license for the Executable Form does not attempt to limit or alter
the recipients' rights in the Source Code Form under this License.
3.3. Distribution of a Larger Work
You may create and distribute a Larger Work under terms of Your choice,
provided that You also comply with the requirements of this License for
the Covered Software. If the Larger Work is a combination of Covered
Software with a work governed by one or more Secondary Licenses, and the
Covered Software is not Incompatible With Secondary Licenses, this
License permits You to additionally distribute such Covered Software
under the terms of such Secondary License(s), so that the recipient of
the Larger Work may, at their option, further distribute the Covered
Software under the terms of either this License or such Secondary
License(s).
3.4. Notices
You may not remove or alter the substance of any license notices
(including copyright notices, patent notices, disclaimers of warranty,
or limitations of liability) contained within the Source Code Form of
the Covered Software, except that You may alter any license notices to
the extent required to remedy known factual inaccuracies.
3.5. Application of Additional Terms
You may choose to offer, and to charge a fee for, warranty, support,
indemnity or liability obligations to one or more recipients of Covered
Software. However, You may do so only on Your own behalf, and not on
behalf of any Contributor. You must make it absolutely clear that any
such warranty, support, indemnity, or liability obligation is offered by
You alone, and You hereby agree to indemnify every Contributor for any
liability incurred by such Contributor as a result of warranty, support,
indemnity or liability terms You offer. You may include additional
disclaimers of warranty and limitations of liability specific to any
jurisdiction.
4. Inability to Comply Due to Statute or Regulation
---------------------------------------------------
If it is impossible for You to comply with any of the terms of this
License with respect to some or all of the Covered Software due to
statute, judicial order, or regulation then You must: (a) comply with
the terms of this License to the maximum extent possible; and (b)
describe the limitations and the code they affect. Such description must
be placed in a text file included with all distributions of the Covered
Software under this License. Except to the extent prohibited by statute
or regulation, such description must be sufficiently detailed for a
recipient of ordinary skill to be able to understand it.
5. Termination
--------------
5.1. The rights granted under this License will terminate automatically
if You fail to comply with any of its terms. However, if You become
compliant, then the rights granted under this License from a particular
Contributor are reinstated (a) provisionally, unless and until such
Contributor explicitly and finally terminates Your grants, and (b) on an
ongoing basis, if such Contributor fails to notify You of the
non-compliance by some reasonable means prior to 60 days after You have
come back into compliance. Moreover, Your grants from a particular
Contributor are reinstated on an ongoing basis if such Contributor
notifies You of the non-compliance by some reasonable means, this is the
first time You have received notice of non-compliance with this License
from such Contributor, and You become compliant prior to 30 days after
Your receipt of the notice.
5.2. If You initiate litigation against any entity by asserting a patent
infringement claim (excluding declaratory judgment actions,
counter-claims, and cross-claims) alleging that a Contributor Version
directly or indirectly infringes any patent, then the rights granted to
You by any and all Contributors for the Covered Software under Section
2.1 of this License shall terminate.
5.3. In the event of termination under Sections 5.1 or 5.2 above, all
end user license agreements (excluding distributors and resellers) which
have been validly granted by You or Your distributors under this License
prior to termination shall survive termination.
************************************************************************
* *
* 6. Disclaimer of Warranty *
* ------------------------- *
* *
* Covered Software is provided under this License on an "as is" *
* basis, without warranty of any kind, either expressed, implied, or *
* statutory, including, without limitation, warranties that the *
* Covered Software is free of defects, merchantable, fit for a *
* particular purpose or non-infringing. The entire risk as to the *
* quality and performance of the Covered Software is with You. *
* Should any Covered Software prove defective in any respect, You *
* (not any Contributor) assume the cost of any necessary servicing, *
* repair, or correction. This disclaimer of warranty constitutes an *
* essential part of this License. No use of any Covered Software is *
* authorized under this License except under this disclaimer. *
* *
************************************************************************
************************************************************************
* *
* 7. Limitation of Liability *
* -------------------------- *
* *
* Under no circumstances and under no legal theory, whether tort *
* (including negligence), contract, or otherwise, shall any *
* Contributor, or anyone who distributes Covered Software as *
* permitted above, be liable to You for any direct, indirect, *
* special, incidental, or consequential damages of any character *
* including, without limitation, damages for lost profits, loss of *
* goodwill, work stoppage, computer failure or malfunction, or any *
* and all other commercial damages or losses, even if such party *
* shall have been informed of the possibility of such damages. This *
* limitation of liability shall not apply to liability for death or *
* personal injury resulting from such party's negligence to the *
* extent applicable law prohibits such limitation. Some *
* jurisdictions do not allow the exclusion or limitation of *
* incidental or consequential damages, so this exclusion and *
* limitation may not apply to You. *
* *
************************************************************************
8. Litigation
-------------
Any litigation relating to this License may be brought only in the
courts of a jurisdiction where the defendant maintains its principal
place of business and such litigation shall be governed by laws of that
jurisdiction, without reference to its conflict-of-law provisions.
Nothing in this Section shall prevent a party's ability to bring
cross-claims or counter-claims.
9. Miscellaneous
----------------
This License represents the complete agreement concerning the subject
matter hereof. If any provision of this License is held to be
unenforceable, such provision shall be reformed only to the extent
necessary to make it enforceable. Any law or regulation which provides
that the language of a contract shall be construed against the drafter
shall not be used to construe this License against a Contributor.
10. Versions of the License
---------------------------
10.1. New Versions
Mozilla Foundation is the license steward. Except as provided in Section
10.3, no one other than the license steward has the right to modify or
publish new versions of this License. Each version will be given a
distinguishing version number.
10.2. Effect of New Versions
You may distribute the Covered Software under the terms of the version
of the License under which You originally received the Covered Software,
or under the terms of any subsequent version published by the license
steward.
10.3. Modified Versions
If you create software not governed by this License, and you want to
create a new license for such software, you may create and use a
modified version of this License if you rename the license and remove
any references to the name of the license steward (except to note that
such modified license differs from this License).
10.4. Distributing Source Code Form that is Incompatible With Secondary
Licenses
If You choose to distribute Source Code Form that is Incompatible With
Secondary Licenses under the terms of this version of the License, the
notice described in Exhibit B of this License must be attached.
Exhibit A - Source Code Form License Notice
-------------------------------------------
This Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at http://mozilla.org/MPL/2.0/.
If it is not possible or desirable to put the notice in a particular
file, then You may include the notice in a location (such as a LICENSE
file in a relevant directory) where a recipient would be likely to look
for such a notice.
You may add additional accurate notices of copyright ownership.
Exhibit B - "Incompatible With Secondary Licenses" Notice
---------------------------------------------------------
This Source Code Form is "Incompatible With Secondary Licenses", as
defined by the Mozilla Public License, v. 2.0.
data_process_class_dll/eigen-3.3.7/COPYING.README
-18
View File
@@ -1,18 +0,0 @@
Eigen is primarily MPL2 licensed. See COPYING.MPL2 and these links:
http://www.mozilla.org/MPL/2.0/
http://www.mozilla.org/MPL/2.0/FAQ.html
Some files contain third-party code under BSD or LGPL licenses, whence the other
COPYING.* files here.
All the LGPL code is either LGPL 2.1-only, or LGPL 2.1-or-later.
For this reason, the COPYING.LGPL file contains the LGPL 2.1 text.
If you want to guarantee that the Eigen code that you are #including is licensed
under the MPL2 and possibly more permissive licenses (like BSD), #define this
preprocessor symbol:
EIGEN_MPL2_ONLY
For example, with most compilers, you could add this to your project CXXFLAGS:
-DEIGEN_MPL2_ONLY
This will cause a compilation error to be generated if you #include any code that is
LGPL licensed.
data_process_class_dll/eigen-3.3.7/CTestConfig.cmake
-13
View File
@@ -1,13 +0,0 @@
## This file should be placed in the root directory of your project.
## Then modify the CMakeLists.txt file in the root directory of your
## project to incorporate the testing dashboard.
## # The following are required to uses Dart and the Cdash dashboard
## ENABLE_TESTING()
## INCLUDE(CTest)
set(CTEST_PROJECT_NAME "Eigen 3.3")
set(CTEST_NIGHTLY_START_TIME "00:00:00 UTC")
set(CTEST_DROP_METHOD "http")
set(CTEST_DROP_SITE "manao.inria.fr")
set(CTEST_DROP_LOCATION "/CDash/submit.php?project=Eigen+3.3")
set(CTEST_DROP_SITE_CDASH TRUE)
data_process_class_dll/eigen-3.3.7/CTestCustom.cmake.in
-4
View File
@@ -1,4 +0,0 @@
set(CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS "2000")
set(CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS "2000")
list(APPEND CTEST_CUSTOM_ERROR_EXCEPTION @EIGEN_CTEST_ERROR_EXCEPTION@)
data_process_class_dll/eigen-3.3.7/Eigen/CMakeLists.txt
-19
View File
@@ -1,19 +0,0 @@
include(RegexUtils)
test_escape_string_as_regex()
file(GLOB Eigen_directory_files "*")
escape_string_as_regex(ESCAPED_CMAKE_CURRENT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
foreach(f ${Eigen_directory_files})
if(NOT f MATCHES "\\.txt" AND NOT f MATCHES "${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/[.].+" AND NOT f MATCHES "${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/src")
list(APPEND Eigen_directory_files_to_install ${f})
endif()
endforeach(f ${Eigen_directory_files})
install(FILES
${Eigen_directory_files_to_install}
DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen COMPONENT Devel
)
install(DIRECTORY src DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen COMPONENT Devel FILES_MATCHING PATTERN "*.h")
data_process_class_dll/eigen-3.3.7/Eigen/Cholesky
-46
View File
@@ -1,46 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_CHOLESKY_MODULE_H
#define EIGEN_CHOLESKY_MODULE_H
#include "Core"
#include "Jacobi"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup Cholesky_Module Cholesky module
*
*
*
* This module provides two variants of the Cholesky decomposition for selfadjoint (hermitian) matrices.
* Those decompositions are also accessible via the following methods:
* - MatrixBase::llt()
* - MatrixBase::ldlt()
* - SelfAdjointView::llt()
* - SelfAdjointView::ldlt()
*
* \code
* #include <Eigen/Cholesky>
* \endcode
*/
#include "src/Cholesky/LLT.h"
#include "src/Cholesky/LDLT.h"
#ifdef EIGEN_USE_LAPACKE
#ifdef EIGEN_USE_MKL
#include "mkl_lapacke.h"
#else
#include "src/misc/lapacke.h"
#endif
#include "src/Cholesky/LLT_LAPACKE.h"
#endif
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_CHOLESKY_MODULE_H
/* vim: set filetype=cpp et sw=2 ts=2 ai: */
data_process_class_dll/eigen-3.3.7/Eigen/CholmodSupport
-48
View File
@@ -1,48 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_CHOLMODSUPPORT_MODULE_H
#define EIGEN_CHOLMODSUPPORT_MODULE_H
#include "SparseCore"
#include "src/Core/util/DisableStupidWarnings.h"
extern "C" {
#include <cholmod.h>
}
/** \ingroup Support_modules
* \defgroup CholmodSupport_Module CholmodSupport module
*
* This module provides an interface to the Cholmod library which is part of the <a href="http://www.suitesparse.com">suitesparse</a> package.
* It provides the two following main factorization classes:
* - class CholmodSupernodalLLT: a supernodal LLT Cholesky factorization.
* - class CholmodDecomposiiton: a general L(D)LT Cholesky factorization with automatic or explicit runtime selection of the underlying factorization method (supernodal or simplicial).
*
* For the sake of completeness, this module also propose the two following classes:
* - class CholmodSimplicialLLT
* - class CholmodSimplicialLDLT
* Note that these classes does not bring any particular advantage compared to the built-in
* SimplicialLLT and SimplicialLDLT factorization classes.
*
* \code
* #include <Eigen/CholmodSupport>
* \endcode
*
* In order to use this module, the cholmod headers must be accessible from the include paths, and your binary must be linked to the cholmod library and its dependencies.
* The dependencies depend on how cholmod has been compiled.
* For a cmake based project, you can use our FindCholmod.cmake module to help you in this task.
*
*/
#include "src/CholmodSupport/CholmodSupport.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_CHOLMODSUPPORT_MODULE_H
data_process_class_dll/eigen-3.3.7/Eigen/Core
-537
View File
@@ -1,537 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2007-2011 Benoit Jacob <jacob.benoit.1@gmail.com>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_CORE_H
#define EIGEN_CORE_H
// first thing Eigen does: stop the compiler from committing suicide
#include "src/Core/util/DisableStupidWarnings.h"
#if defined(__CUDACC__) && !defined(EIGEN_NO_CUDA)
#define EIGEN_CUDACC __CUDACC__
#endif
#if defined(__CUDA_ARCH__) && !defined(EIGEN_NO_CUDA)
#define EIGEN_CUDA_ARCH __CUDA_ARCH__
#endif
#if defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 9)
#define EIGEN_CUDACC_VER ((__CUDACC_VER_MAJOR__ * 10000) + (__CUDACC_VER_MINOR__ * 100))
#elif defined(__CUDACC_VER__)
#define EIGEN_CUDACC_VER __CUDACC_VER__
#else
#define EIGEN_CUDACC_VER 0
#endif
// Handle NVCC/CUDA/SYCL
#if defined(__CUDACC__) || defined(__SYCL_DEVICE_ONLY__)
// Do not try asserts on CUDA and SYCL!
#ifndef EIGEN_NO_DEBUG
#define EIGEN_NO_DEBUG
#endif
#ifdef EIGEN_INTERNAL_DEBUGGING
#undef EIGEN_INTERNAL_DEBUGGING
#endif
#ifdef EIGEN_EXCEPTIONS
#undef EIGEN_EXCEPTIONS
#endif
// All functions callable from CUDA code must be qualified with __device__
#ifdef __CUDACC__
// Do not try to vectorize on CUDA and SYCL!
#ifndef EIGEN_DONT_VECTORIZE
#define EIGEN_DONT_VECTORIZE
#endif
#define EIGEN_DEVICE_FUNC __host__ __device__
// We need cuda_runtime.h to ensure that that EIGEN_USING_STD_MATH macro
// works properly on the device side
#include <cuda_runtime.h>
#else
#define EIGEN_DEVICE_FUNC
#endif
#else
#define EIGEN_DEVICE_FUNC
#endif
// When compiling CUDA device code with NVCC, pull in math functions from the
// global namespace. In host mode, and when device doee with clang, use the
// std versions.
#if defined(__CUDA_ARCH__) && defined(__NVCC__)
#define EIGEN_USING_STD_MATH(FUNC) using ::FUNC;
#else
#define EIGEN_USING_STD_MATH(FUNC) using std::FUNC;
#endif
#if (defined(_CPPUNWIND) || defined(__EXCEPTIONS)) && !defined(__CUDA_ARCH__) && !defined(EIGEN_EXCEPTIONS) && !defined(EIGEN_USE_SYCL)
#define EIGEN_EXCEPTIONS
#endif
#ifdef EIGEN_EXCEPTIONS
#include <new>
#endif
// then include this file where all our macros are defined. It's really important to do it first because
// it's where we do all the alignment settings (platform detection and honoring the user's will if he
// defined e.g. EIGEN_DONT_ALIGN) so it needs to be done before we do anything with vectorization.
#include "src/Core/util/Macros.h"
// Disable the ipa-cp-clone optimization flag with MinGW 6.x or newer (enabled by default with -O3)
// See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=556 for details.
#if EIGEN_COMP_MINGW && EIGEN_GNUC_AT_LEAST(4,6)
#pragma GCC optimize ("-fno-ipa-cp-clone")
#endif
#include <complex>
// this include file manages BLAS and MKL related macros
// and inclusion of their respective header files
#include "src/Core/util/MKL_support.h"
// if alignment is disabled, then disable vectorization. Note: EIGEN_MAX_ALIGN_BYTES is the proper check, it takes into
// account both the user's will (EIGEN_MAX_ALIGN_BYTES,EIGEN_DONT_ALIGN) and our own platform checks
#if EIGEN_MAX_ALIGN_BYTES==0
#ifndef EIGEN_DONT_VECTORIZE
#define EIGEN_DONT_VECTORIZE
#endif
#endif
#if EIGEN_COMP_MSVC
#include <malloc.h> // for _aligned_malloc -- need it regardless of whether vectorization is enabled
#if (EIGEN_COMP_MSVC >= 1500) // 2008 or later
// Remember that usage of defined() in a #define is undefined by the standard.
// a user reported that in 64-bit mode, MSVC doesn't care to define _M_IX86_FP.
#if (defined(_M_IX86_FP) && (_M_IX86_FP >= 2)) || EIGEN_ARCH_x86_64
#define EIGEN_SSE2_ON_MSVC_2008_OR_LATER
#endif
#endif
#else
// Remember that usage of defined() in a #define is undefined by the standard
#if (defined __SSE2__) && ( (!EIGEN_COMP_GNUC) || EIGEN_COMP_ICC || EIGEN_GNUC_AT_LEAST(4,2) )
#define EIGEN_SSE2_ON_NON_MSVC_BUT_NOT_OLD_GCC
#endif
#endif
#ifndef EIGEN_DONT_VECTORIZE
#if defined (EIGEN_SSE2_ON_NON_MSVC_BUT_NOT_OLD_GCC) || defined(EIGEN_SSE2_ON_MSVC_2008_OR_LATER)
// Defines symbols for compile-time detection of which instructions are
// used.
// EIGEN_VECTORIZE_YY is defined if and only if the instruction set YY is used
#define EIGEN_VECTORIZE
#define EIGEN_VECTORIZE_SSE
#define EIGEN_VECTORIZE_SSE2
// Detect sse3/ssse3/sse4:
// gcc and icc defines __SSE3__, ...
// there is no way to know about this on msvc. You can define EIGEN_VECTORIZE_SSE* if you
// want to force the use of those instructions with msvc.
#ifdef __SSE3__
#define EIGEN_VECTORIZE_SSE3
#endif
#ifdef __SSSE3__
#define EIGEN_VECTORIZE_SSSE3
#endif
#ifdef __SSE4_1__
#define EIGEN_VECTORIZE_SSE4_1
#endif
#ifdef __SSE4_2__
#define EIGEN_VECTORIZE_SSE4_2
#endif
#ifdef __AVX__
#define EIGEN_VECTORIZE_AVX
#define EIGEN_VECTORIZE_SSE3
#define EIGEN_VECTORIZE_SSSE3
#define EIGEN_VECTORIZE_SSE4_1
#define EIGEN_VECTORIZE_SSE4_2
#endif
#ifdef __AVX2__
#define EIGEN_VECTORIZE_AVX2
#endif
#ifdef __FMA__
#define EIGEN_VECTORIZE_FMA
#endif
#if defined(__AVX512F__) && defined(EIGEN_ENABLE_AVX512)
#define EIGEN_VECTORIZE_AVX512
#define EIGEN_VECTORIZE_AVX2
#define EIGEN_VECTORIZE_AVX
#define EIGEN_VECTORIZE_FMA
#ifdef __AVX512DQ__
#define EIGEN_VECTORIZE_AVX512DQ
#endif
#ifdef __AVX512ER__
#define EIGEN_VECTORIZE_AVX512ER
#endif
#endif
// include files
// This extern "C" works around a MINGW-w64 compilation issue
// https://sourceforge.net/tracker/index.php?func=detail&aid=3018394&group_id=202880&atid=983354
// In essence, intrin.h is included by windows.h and also declares intrinsics (just as emmintrin.h etc. below do).
// However, intrin.h uses an extern "C" declaration, and g++ thus complains of duplicate declarations
// with conflicting linkage. The linkage for intrinsics doesn't matter, but at that stage the compiler doesn't know;
// so, to avoid compile errors when windows.h is included after Eigen/Core, ensure intrinsics are extern "C" here too.
// notice that since these are C headers, the extern "C" is theoretically needed anyways.
extern "C" {
// In theory we should only include immintrin.h and not the other *mmintrin.h header files directly.
// Doing so triggers some issues with ICC. However old gcc versions seems to not have this file, thus:
#if EIGEN_COMP_ICC >= 1110
#include <immintrin.h>
#else
#include <mmintrin.h>
#include <emmintrin.h>
#include <xmmintrin.h>
#ifdef EIGEN_VECTORIZE_SSE3
#include <pmmintrin.h>
#endif
#ifdef EIGEN_VECTORIZE_SSSE3
#include <tmmintrin.h>
#endif
#ifdef EIGEN_VECTORIZE_SSE4_1
#include <smmintrin.h>
#endif
#ifdef EIGEN_VECTORIZE_SSE4_2
#include <nmmintrin.h>
#endif
#if defined(EIGEN_VECTORIZE_AVX) || defined(EIGEN_VECTORIZE_AVX512)
#include <immintrin.h>
#endif
#endif
} // end extern "C"
#elif defined __VSX__
#define EIGEN_VECTORIZE
#define EIGEN_VECTORIZE_VSX
#include <altivec.h>
// We need to #undef all these ugly tokens defined in <altivec.h>
// => use __vector instead of vector
#undef bool
#undef vector
#undef pixel
#elif defined __ALTIVEC__
#define EIGEN_VECTORIZE
#define EIGEN_VECTORIZE_ALTIVEC
#include <altivec.h>
// We need to #undef all these ugly tokens defined in <altivec.h>
// => use __vector instead of vector
#undef bool
#undef vector
#undef pixel
#elif (defined __ARM_NEON) || (defined __ARM_NEON__)
#define EIGEN_VECTORIZE
#define EIGEN_VECTORIZE_NEON
#include <arm_neon.h>
#elif (defined __s390x__ && defined __VEC__)
#define EIGEN_VECTORIZE
#define EIGEN_VECTORIZE_ZVECTOR
#include <vecintrin.h>
#endif
#endif
#if defined(__F16C__) && !defined(EIGEN_COMP_CLANG)
// We can use the optimized fp16 to float and float to fp16 conversion routines
#define EIGEN_HAS_FP16_C
#endif
#if defined __CUDACC__
#define EIGEN_VECTORIZE_CUDA
#include <vector_types.h>
#if EIGEN_CUDACC_VER >= 70500
#define EIGEN_HAS_CUDA_FP16
#endif
#endif
#if defined EIGEN_HAS_CUDA_FP16
#include <host_defines.h>
#include <cuda_fp16.h>
#endif
#if (defined _OPENMP) && (!defined EIGEN_DONT_PARALLELIZE)
#define EIGEN_HAS_OPENMP
#endif
#ifdef EIGEN_HAS_OPENMP
#include <omp.h>
#endif
// MSVC for windows mobile does not have the errno.h file
#if !(EIGEN_COMP_MSVC && EIGEN_OS_WINCE) && !EIGEN_COMP_ARM
#define EIGEN_HAS_ERRNO
#endif
#ifdef EIGEN_HAS_ERRNO
#include <cerrno>
#endif
#include <cstddef>
#include <cstdlib>
#include <cmath>
#include <cassert>
#include <functional>
#include <iosfwd>
#include <cstring>
#include <string>
#include <limits>
#include <climits> // for CHAR_BIT
// for min/max:
#include <algorithm>
// for std::is_nothrow_move_assignable
#ifdef EIGEN_INCLUDE_TYPE_TRAITS
#include <type_traits>
#endif
// for outputting debug info
#ifdef EIGEN_DEBUG_ASSIGN
#include <iostream>
#endif
// required for __cpuid, needs to be included after cmath
#if EIGEN_COMP_MSVC && EIGEN_ARCH_i386_OR_x86_64 && !EIGEN_OS_WINCE
#include <intrin.h>
#endif
/** \brief Namespace containing all symbols from the %Eigen library. */
namespace Eigen {
inline static const char *SimdInstructionSetsInUse(void) {
#if defined(EIGEN_VECTORIZE_AVX512)
return "AVX512, FMA, AVX2, AVX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2";
#elif defined(EIGEN_VECTORIZE_AVX)
return "AVX SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2";
#elif defined(EIGEN_VECTORIZE_SSE4_2)
return "SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2";
#elif defined(EIGEN_VECTORIZE_SSE4_1)
return "SSE, SSE2, SSE3, SSSE3, SSE4.1";
#elif defined(EIGEN_VECTORIZE_SSSE3)
return "SSE, SSE2, SSE3, SSSE3";
#elif defined(EIGEN_VECTORIZE_SSE3)
return "SSE, SSE2, SSE3";
#elif defined(EIGEN_VECTORIZE_SSE2)
return "SSE, SSE2";
#elif defined(EIGEN_VECTORIZE_ALTIVEC)
return "AltiVec";
#elif defined(EIGEN_VECTORIZE_VSX)
return "VSX";
#elif defined(EIGEN_VECTORIZE_NEON)
return "ARM NEON";
#elif defined(EIGEN_VECTORIZE_ZVECTOR)
return "S390X ZVECTOR";
#else
return "None";
#endif
}
} // end namespace Eigen
#if defined EIGEN2_SUPPORT_STAGE40_FULL_EIGEN3_STRICTNESS || defined EIGEN2_SUPPORT_STAGE30_FULL_EIGEN3_API || defined EIGEN2_SUPPORT_STAGE20_RESOLVE_API_CONFLICTS || defined EIGEN2_SUPPORT_STAGE10_FULL_EIGEN2_API || defined EIGEN2_SUPPORT
// This will generate an error message:
#error Eigen2-support is only available up to version 3.2. Please go to "http://eigen.tuxfamily.org/index.php?title=Eigen2" for further information
#endif
namespace Eigen {
// we use size_t frequently and we'll never remember to prepend it with std:: everytime just to
// ensure QNX/QCC support
using std::size_t;
// gcc 4.6.0 wants std:: for ptrdiff_t
using std::ptrdiff_t;
}
/** \defgroup Core_Module Core module
* This is the main module of Eigen providing dense matrix and vector support
* (both fixed and dynamic size) with all the features corresponding to a BLAS library
* and much more...
*
* \code
* #include <Eigen/Core>
* \endcode
*/
#include "src/Core/util/Constants.h"
#include "src/Core/util/Meta.h"
#include "src/Core/util/ForwardDeclarations.h"
#include "src/Core/util/StaticAssert.h"
#include "src/Core/util/XprHelper.h"
#include "src/Core/util/Memory.h"
#include "src/Core/NumTraits.h"
#include "src/Core/MathFunctions.h"
#include "src/Core/GenericPacketMath.h"
#include "src/Core/MathFunctionsImpl.h"
#include "src/Core/arch/Default/ConjHelper.h"
#if defined EIGEN_VECTORIZE_AVX512
#include "src/Core/arch/SSE/PacketMath.h"
#include "src/Core/arch/AVX/PacketMath.h"
#include "src/Core/arch/AVX512/PacketMath.h"
#include "src/Core/arch/AVX512/MathFunctions.h"
#elif defined EIGEN_VECTORIZE_AVX
// Use AVX for floats and doubles, SSE for integers
#include "src/Core/arch/SSE/PacketMath.h"
#include "src/Core/arch/SSE/Complex.h"
#include "src/Core/arch/SSE/MathFunctions.h"
#include "src/Core/arch/AVX/PacketMath.h"
#include "src/Core/arch/AVX/MathFunctions.h"
#include "src/Core/arch/AVX/Complex.h"
#include "src/Core/arch/AVX/TypeCasting.h"
#include "src/Core/arch/SSE/TypeCasting.h"
#elif defined EIGEN_VECTORIZE_SSE
#include "src/Core/arch/SSE/PacketMath.h"
#include "src/Core/arch/SSE/MathFunctions.h"
#include "src/Core/arch/SSE/Complex.h"
#include "src/Core/arch/SSE/TypeCasting.h"
#elif defined(EIGEN_VECTORIZE_ALTIVEC) || defined(EIGEN_VECTORIZE_VSX)
#include "src/Core/arch/AltiVec/PacketMath.h"
#include "src/Core/arch/AltiVec/MathFunctions.h"
#include "src/Core/arch/AltiVec/Complex.h"
#elif defined EIGEN_VECTORIZE_NEON
#include "src/Core/arch/NEON/PacketMath.h"
#include "src/Core/arch/NEON/MathFunctions.h"
#include "src/Core/arch/NEON/Complex.h"
#elif defined EIGEN_VECTORIZE_ZVECTOR
#include "src/Core/arch/ZVector/PacketMath.h"
#include "src/Core/arch/ZVector/MathFunctions.h"
#include "src/Core/arch/ZVector/Complex.h"
#endif
// Half float support
#include "src/Core/arch/CUDA/Half.h"
#include "src/Core/arch/CUDA/PacketMathHalf.h"
#include "src/Core/arch/CUDA/TypeCasting.h"
#if defined EIGEN_VECTORIZE_CUDA
#include "src/Core/arch/CUDA/PacketMath.h"
#include "src/Core/arch/CUDA/MathFunctions.h"
#endif
#include "src/Core/arch/Default/Settings.h"
#include "src/Core/functors/TernaryFunctors.h"
#include "src/Core/functors/BinaryFunctors.h"
#include "src/Core/functors/UnaryFunctors.h"
#include "src/Core/functors/NullaryFunctors.h"
#include "src/Core/functors/StlFunctors.h"
#include "src/Core/functors/AssignmentFunctors.h"
// Specialized functors to enable the processing of complex numbers
// on CUDA devices
#include "src/Core/arch/CUDA/Complex.h"
#include "src/Core/IO.h"
#include "src/Core/DenseCoeffsBase.h"
#include "src/Core/DenseBase.h"
#include "src/Core/MatrixBase.h"
#include "src/Core/EigenBase.h"
#include "src/Core/Product.h"
#include "src/Core/CoreEvaluators.h"
#include "src/Core/AssignEvaluator.h"
#ifndef EIGEN_PARSED_BY_DOXYGEN // work around Doxygen bug triggered by Assign.h r814874
// at least confirmed with Doxygen 1.5.5 and 1.5.6
#include "src/Core/Assign.h"
#endif
#include "src/Core/ArrayBase.h"
#include "src/Core/util/BlasUtil.h"
#include "src/Core/DenseStorage.h"
#include "src/Core/NestByValue.h"
// #include "src/Core/ForceAlignedAccess.h"
#include "src/Core/ReturnByValue.h"
#include "src/Core/NoAlias.h"
#include "src/Core/PlainObjectBase.h"
#include "src/Core/Matrix.h"
#include "src/Core/Array.h"
#include "src/Core/CwiseTernaryOp.h"
#include "src/Core/CwiseBinaryOp.h"
#include "src/Core/CwiseUnaryOp.h"
#include "src/Core/CwiseNullaryOp.h"
#include "src/Core/CwiseUnaryView.h"
#include "src/Core/SelfCwiseBinaryOp.h"
#include "src/Core/Dot.h"
#include "src/Core/StableNorm.h"
#include "src/Core/Stride.h"
#include "src/Core/MapBase.h"
#include "src/Core/Map.h"
#include "src/Core/Ref.h"
#include "src/Core/Block.h"
#include "src/Core/VectorBlock.h"
#include "src/Core/Transpose.h"
#include "src/Core/DiagonalMatrix.h"
#include "src/Core/Diagonal.h"
#include "src/Core/DiagonalProduct.h"
#include "src/Core/Redux.h"
#include "src/Core/Visitor.h"
#include "src/Core/Fuzzy.h"
#include "src/Core/Swap.h"
#include "src/Core/CommaInitializer.h"
#include "src/Core/GeneralProduct.h"
#include "src/Core/Solve.h"
#include "src/Core/Inverse.h"
#include "src/Core/SolverBase.h"
#include "src/Core/PermutationMatrix.h"
#include "src/Core/Transpositions.h"
#include "src/Core/TriangularMatrix.h"
#include "src/Core/SelfAdjointView.h"
#include "src/Core/products/GeneralBlockPanelKernel.h"
#include "src/Core/products/Parallelizer.h"
#include "src/Core/ProductEvaluators.h"
#include "src/Core/products/GeneralMatrixVector.h"
#include "src/Core/products/GeneralMatrixMatrix.h"
#include "src/Core/SolveTriangular.h"
#include "src/Core/products/GeneralMatrixMatrixTriangular.h"
#include "src/Core/products/SelfadjointMatrixVector.h"
#include "src/Core/products/SelfadjointMatrixMatrix.h"
#include "src/Core/products/SelfadjointProduct.h"
#include "src/Core/products/SelfadjointRank2Update.h"
#include "src/Core/products/TriangularMatrixVector.h"
#include "src/Core/products/TriangularMatrixMatrix.h"
#include "src/Core/products/TriangularSolverMatrix.h"
#include "src/Core/products/TriangularSolverVector.h"
#include "src/Core/BandMatrix.h"
#include "src/Core/CoreIterators.h"
#include "src/Core/ConditionEstimator.h"
#include "src/Core/BooleanRedux.h"
#include "src/Core/Select.h"
#include "src/Core/VectorwiseOp.h"
#include "src/Core/Random.h"
#include "src/Core/Replicate.h"
#include "src/Core/Reverse.h"
#include "src/Core/ArrayWrapper.h"
#ifdef EIGEN_USE_BLAS
#include "src/Core/products/GeneralMatrixMatrix_BLAS.h"
#include "src/Core/products/GeneralMatrixVector_BLAS.h"
#include "src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h"
#include "src/Core/products/SelfadjointMatrixMatrix_BLAS.h"
#include "src/Core/products/SelfadjointMatrixVector_BLAS.h"
#include "src/Core/products/TriangularMatrixMatrix_BLAS.h"
#include "src/Core/products/TriangularMatrixVector_BLAS.h"
#include "src/Core/products/TriangularSolverMatrix_BLAS.h"
#endif // EIGEN_USE_BLAS
#ifdef EIGEN_USE_MKL_VML
#include "src/Core/Assign_MKL.h"
#endif
#include "src/Core/GlobalFunctions.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_CORE_H
data_process_class_dll/eigen-3.3.7/Eigen/Dense
-7
View File
@@ -1,7 +0,0 @@
#include "Core"
#include "LU"
#include "Cholesky"
#include "QR"
#include "SVD"
#include "Geometry"
#include "Eigenvalues"
data_process_class_dll/eigen-3.3.7/Eigen/Eigen
-2
View File
@@ -1,2 +0,0 @@
#include "Dense"
#include "Sparse"
data_process_class_dll/eigen-3.3.7/Eigen/Eigenvalues
-61
View File
@@ -1,61 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_EIGENVALUES_MODULE_H
#define EIGEN_EIGENVALUES_MODULE_H
#include "Core"
#include "src/Core/util/DisableStupidWarnings.h"
#include "Cholesky"
#include "Jacobi"
#include "Householder"
#include "LU"
#include "Geometry"
/** \defgroup Eigenvalues_Module Eigenvalues module
*
*
*
* This module mainly provides various eigenvalue solvers.
* This module also provides some MatrixBase methods, including:
* - MatrixBase::eigenvalues(),
* - MatrixBase::operatorNorm()
*
* \code
* #include <Eigen/Eigenvalues>
* \endcode
*/
#include "src/misc/RealSvd2x2.h"
#include "src/Eigenvalues/Tridiagonalization.h"
#include "src/Eigenvalues/RealSchur.h"
#include "src/Eigenvalues/EigenSolver.h"
#include "src/Eigenvalues/SelfAdjointEigenSolver.h"
#include "src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h"
#include "src/Eigenvalues/HessenbergDecomposition.h"
#include "src/Eigenvalues/ComplexSchur.h"
#include "src/Eigenvalues/ComplexEigenSolver.h"
#include "src/Eigenvalues/RealQZ.h"
#include "src/Eigenvalues/GeneralizedEigenSolver.h"
#include "src/Eigenvalues/MatrixBaseEigenvalues.h"
#ifdef EIGEN_USE_LAPACKE
#ifdef EIGEN_USE_MKL
#include "mkl_lapacke.h"
#else
#include "src/misc/lapacke.h"
#endif
#include "src/Eigenvalues/RealSchur_LAPACKE.h"
#include "src/Eigenvalues/ComplexSchur_LAPACKE.h"
#include "src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h"
#endif
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_EIGENVALUES_MODULE_H
/* vim: set filetype=cpp et sw=2 ts=2 ai: */
data_process_class_dll/eigen-3.3.7/Eigen/Geometry
-62
View File
@@ -1,62 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_GEOMETRY_MODULE_H
#define EIGEN_GEOMETRY_MODULE_H
#include "Core"
#include "src/Core/util/DisableStupidWarnings.h"
#include "SVD"
#include "LU"
#include <limits>
/** \defgroup Geometry_Module Geometry module
*
* This module provides support for:
* - fixed-size homogeneous transformations
* - translation, scaling, 2D and 3D rotations
* - \link Quaternion quaternions \endlink
* - cross products (\ref MatrixBase::cross, \ref MatrixBase::cross3)
* - orthognal vector generation (\ref MatrixBase::unitOrthogonal)
* - some linear components: \link ParametrizedLine parametrized-lines \endlink and \link Hyperplane hyperplanes \endlink
* - \link AlignedBox axis aligned bounding boxes \endlink
* - \link umeyama least-square transformation fitting \endlink
*
* \code
* #include <Eigen/Geometry>
* \endcode
*/
#include "src/Geometry/OrthoMethods.h"
#include "src/Geometry/EulerAngles.h"
#include "src/Geometry/Homogeneous.h"
#include "src/Geometry/RotationBase.h"
#include "src/Geometry/Rotation2D.h"
#include "src/Geometry/Quaternion.h"
#include "src/Geometry/AngleAxis.h"
#include "src/Geometry/Transform.h"
#include "src/Geometry/Translation.h"
#include "src/Geometry/Scaling.h"
#include "src/Geometry/Hyperplane.h"
#include "src/Geometry/ParametrizedLine.h"
#include "src/Geometry/AlignedBox.h"
#include "src/Geometry/Umeyama.h"
// Use the SSE optimized version whenever possible. At the moment the
// SSE version doesn't compile when AVX is enabled
#if defined EIGEN_VECTORIZE_SSE && !defined EIGEN_VECTORIZE_AVX
#include "src/Geometry/arch/Geometry_SSE.h"
#endif
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_GEOMETRY_MODULE_H
/* vim: set filetype=cpp et sw=2 ts=2 ai: */
data_process_class_dll/eigen-3.3.7/Eigen/Householder
-30
View File
@@ -1,30 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_HOUSEHOLDER_MODULE_H
#define EIGEN_HOUSEHOLDER_MODULE_H
#include "Core"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup Householder_Module Householder module
* This module provides Householder transformations.
*
* \code
* #include <Eigen/Householder>
* \endcode
*/
#include "src/Householder/Householder.h"
#include "src/Householder/HouseholderSequence.h"
#include "src/Householder/BlockHouseholder.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_HOUSEHOLDER_MODULE_H
/* vim: set filetype=cpp et sw=2 ts=2 ai: */
data_process_class_dll/eigen-3.3.7/Eigen/IterativeLinearSolvers
-48
View File
@@ -1,48 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
#define EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
#include "SparseCore"
#include "OrderingMethods"
#include "src/Core/util/DisableStupidWarnings.h"
/**
* \defgroup IterativeLinearSolvers_Module IterativeLinearSolvers module
*
* This module currently provides iterative methods to solve problems of the form \c A \c x = \c b, where \c A is a squared matrix, usually very large and sparse.
* Those solvers are accessible via the following classes:
* - ConjugateGradient for selfadjoint (hermitian) matrices,
* - LeastSquaresConjugateGradient for rectangular least-square problems,
* - BiCGSTAB for general square matrices.
*
* These iterative solvers are associated with some preconditioners:
* - IdentityPreconditioner - not really useful
* - DiagonalPreconditioner - also called Jacobi preconditioner, work very well on diagonal dominant matrices.
* - IncompleteLUT - incomplete LU factorization with dual thresholding
*
* Such problems can also be solved using the direct sparse decomposition modules: SparseCholesky, CholmodSupport, UmfPackSupport, SuperLUSupport.
*
\code
#include <Eigen/IterativeLinearSolvers>
\endcode
*/
#include "src/IterativeLinearSolvers/SolveWithGuess.h"
#include "src/IterativeLinearSolvers/IterativeSolverBase.h"
#include "src/IterativeLinearSolvers/BasicPreconditioners.h"
#include "src/IterativeLinearSolvers/ConjugateGradient.h"
#include "src/IterativeLinearSolvers/LeastSquareConjugateGradient.h"
#include "src/IterativeLinearSolvers/BiCGSTAB.h"
#include "src/IterativeLinearSolvers/IncompleteLUT.h"
#include "src/IterativeLinearSolvers/IncompleteCholesky.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
data_process_class_dll/eigen-3.3.7/Eigen/Jacobi
-33
View File
@@ -1,33 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_JACOBI_MODULE_H
#define EIGEN_JACOBI_MODULE_H
#include "Core"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup Jacobi_Module Jacobi module
* This module provides Jacobi and Givens rotations.
*
* \code
* #include <Eigen/Jacobi>
* \endcode
*
* In addition to listed classes, it defines the two following MatrixBase methods to apply a Jacobi or Givens rotation:
* - MatrixBase::applyOnTheLeft()
* - MatrixBase::applyOnTheRight().
*/
#include "src/Jacobi/Jacobi.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_JACOBI_MODULE_H
/* vim: set filetype=cpp et sw=2 ts=2 ai: */
data_process_class_dll/eigen-3.3.7/Eigen/LU
-50
View File
@@ -1,50 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_LU_MODULE_H
#define EIGEN_LU_MODULE_H
#include "Core"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup LU_Module LU module
* This module includes %LU decomposition and related notions such as matrix inversion and determinant.
* This module defines the following MatrixBase methods:
* - MatrixBase::inverse()
* - MatrixBase::determinant()
*
* \code
* #include <Eigen/LU>
* \endcode
*/
#include "src/misc/Kernel.h"
#include "src/misc/Image.h"
#include "src/LU/FullPivLU.h"
#include "src/LU/PartialPivLU.h"
#ifdef EIGEN_USE_LAPACKE
#ifdef EIGEN_USE_MKL
#include "mkl_lapacke.h"
#else
#include "src/misc/lapacke.h"
#endif
#include "src/LU/PartialPivLU_LAPACKE.h"
#endif
#include "src/LU/Determinant.h"
#include "src/LU/InverseImpl.h"
// Use the SSE optimized version whenever possible. At the moment the
// SSE version doesn't compile when AVX is enabled
#if defined EIGEN_VECTORIZE_SSE && !defined EIGEN_VECTORIZE_AVX
#include "src/LU/arch/Inverse_SSE.h"
#endif
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_LU_MODULE_H
/* vim: set filetype=cpp et sw=2 ts=2 ai: */
data_process_class_dll/eigen-3.3.7/Eigen/MetisSupport
-35
View File
@@ -1,35 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_METISSUPPORT_MODULE_H
#define EIGEN_METISSUPPORT_MODULE_H
#include "SparseCore"
#include "src/Core/util/DisableStupidWarnings.h"
extern "C" {
#include <metis.h>
}
/** \ingroup Support_modules
* \defgroup MetisSupport_Module MetisSupport module
*
* \code
* #include <Eigen/MetisSupport>
* \endcode
* This module defines an interface to the METIS reordering package (http://glaros.dtc.umn.edu/gkhome/views/metis).
* It can be used just as any other built-in method as explained in \link OrderingMethods_Module here. \endlink
*/
#include "src/MetisSupport/MetisSupport.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_METISSUPPORT_MODULE_H
data_process_class_dll/eigen-3.3.7/Eigen/OrderingMethods
-73
View File
@@ -1,73 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_ORDERINGMETHODS_MODULE_H
#define EIGEN_ORDERINGMETHODS_MODULE_H
#include "SparseCore"
#include "src/Core/util/DisableStupidWarnings.h"
/**
* \defgroup OrderingMethods_Module OrderingMethods module
*
* This module is currently for internal use only
*
* It defines various built-in and external ordering methods for sparse matrices.
* They are typically used to reduce the number of elements during
* the sparse matrix decomposition (LLT, LU, QR).
* Precisely, in a preprocessing step, a permutation matrix P is computed using
* those ordering methods and applied to the columns of the matrix.
* Using for instance the sparse Cholesky decomposition, it is expected that
* the nonzeros elements in LLT(A*P) will be much smaller than that in LLT(A).
*
*
* Usage :
* \code
* #include <Eigen/OrderingMethods>
* \endcode
*
* A simple usage is as a template parameter in the sparse decomposition classes :
*
* \code
* SparseLU<MatrixType, COLAMDOrdering<int> > solver;
* \endcode
*
* \code
* SparseQR<MatrixType, COLAMDOrdering<int> > solver;
* \endcode
*
* It is possible as well to call directly a particular ordering method for your own purpose,
* \code
* AMDOrdering<int> ordering;
* PermutationMatrix<Dynamic, Dynamic, int> perm;
* SparseMatrix<double> A;
* //Fill the matrix ...
*
* ordering(A, perm); // Call AMD
* \endcode
*
* \note Some of these methods (like AMD or METIS), need the sparsity pattern
* of the input matrix to be symmetric. When the matrix is structurally unsymmetric,
* Eigen computes internally the pattern of \f$A^T*A\f$ before calling the method.
* If your matrix is already symmetric (at leat in structure), you can avoid that
* by calling the method with a SelfAdjointView type.
*
* \code
* // Call the ordering on the pattern of the lower triangular matrix A
* ordering(A.selfadjointView<Lower>(), perm);
* \endcode
*/
#ifndef EIGEN_MPL2_ONLY
#include "src/OrderingMethods/Amd.h"
#endif
#include "src/OrderingMethods/Ordering.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_ORDERINGMETHODS_MODULE_H
data_process_class_dll/eigen-3.3.7/Eigen/PaStiXSupport
-48
View File
@@ -1,48 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_PASTIXSUPPORT_MODULE_H
#define EIGEN_PASTIXSUPPORT_MODULE_H
#include "SparseCore"
#include "src/Core/util/DisableStupidWarnings.h"
extern "C" {
#include <pastix_nompi.h>
#include <pastix.h>
}
#ifdef complex
#undef complex
#endif
/** \ingroup Support_modules
* \defgroup PaStiXSupport_Module PaStiXSupport module
*
* This module provides an interface to the <a href="http://pastix.gforge.inria.fr/">PaSTiX</a> library.
* PaSTiX is a general \b supernodal, \b parallel and \b opensource sparse solver.
* It provides the two following main factorization classes:
* - class PastixLLT : a supernodal, parallel LLt Cholesky factorization.
* - class PastixLDLT: a supernodal, parallel LDLt Cholesky factorization.
* - class PastixLU : a supernodal, parallel LU factorization (optimized for a symmetric pattern).
*
* \code
* #include <Eigen/PaStiXSupport>
* \endcode
*
* In order to use this module, the PaSTiX headers must be accessible from the include paths, and your binary must be linked to the PaSTiX library and its dependencies.
* The dependencies depend on how PaSTiX has been compiled.
* For a cmake based project, you can use our FindPaSTiX.cmake module to help you in this task.
*
*/
#include "src/PaStiXSupport/PaStiXSupport.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_PASTIXSUPPORT_MODULE_H
data_process_class_dll/eigen-3.3.7/Eigen/PardisoSupport
-35
View File
@@ -1,35 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_PARDISOSUPPORT_MODULE_H
#define EIGEN_PARDISOSUPPORT_MODULE_H
#include "SparseCore"
#include "src/Core/util/DisableStupidWarnings.h"
#include <mkl_pardiso.h>
/** \ingroup Support_modules
* \defgroup PardisoSupport_Module PardisoSupport module
*
* This module brings support for the Intel(R) MKL PARDISO direct sparse solvers.
*
* \code
* #include <Eigen/PardisoSupport>
* \endcode
*
* In order to use this module, the MKL headers must be accessible from the include paths, and your binary must be linked to the MKL library and its dependencies.
* See this \ref TopicUsingIntelMKL "page" for more information on MKL-Eigen integration.
*
*/
#include "src/PardisoSupport/PardisoSupport.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_PARDISOSUPPORT_MODULE_H
data_process_class_dll/eigen-3.3.7/Eigen/QR
-51
View File
@@ -1,51 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_QR_MODULE_H
#define EIGEN_QR_MODULE_H
#include "Core"
#include "src/Core/util/DisableStupidWarnings.h"
#include "Cholesky"
#include "Jacobi"
#include "Householder"
/** \defgroup QR_Module QR module
*
*
*
* This module provides various QR decompositions
* This module also provides some MatrixBase methods, including:
* - MatrixBase::householderQr()
* - MatrixBase::colPivHouseholderQr()
* - MatrixBase::fullPivHouseholderQr()
*
* \code
* #include <Eigen/QR>
* \endcode
*/
#include "src/QR/HouseholderQR.h"
#include "src/QR/FullPivHouseholderQR.h"
#include "src/QR/ColPivHouseholderQR.h"
#include "src/QR/CompleteOrthogonalDecomposition.h"
#ifdef EIGEN_USE_LAPACKE
#ifdef EIGEN_USE_MKL
#include "mkl_lapacke.h"
#else
#include "src/misc/lapacke.h"
#endif
#include "src/QR/HouseholderQR_LAPACKE.h"
#include "src/QR/ColPivHouseholderQR_LAPACKE.h"
#endif
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_QR_MODULE_H
/* vim: set filetype=cpp et sw=2 ts=2 ai: */
data_process_class_dll/eigen-3.3.7/Eigen/QtAlignedMalloc
-40
View File
@@ -1,40 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_QTMALLOC_MODULE_H
#define EIGEN_QTMALLOC_MODULE_H
#include "Core"
#if (!EIGEN_MALLOC_ALREADY_ALIGNED)
#include "src/Core/util/DisableStupidWarnings.h"
void *qMalloc(std::size_t size)
{
return Eigen::internal::aligned_malloc(size);
}
void qFree(void *ptr)
{
Eigen::internal::aligned_free(ptr);
}
void *qRealloc(void *ptr, std::size_t size)
{
void* newPtr = Eigen::internal::aligned_malloc(size);
std::memcpy(newPtr, ptr, size);
Eigen::internal::aligned_free(ptr);
return newPtr;
}
#include "src/Core/util/ReenableStupidWarnings.h"
#endif
#endif // EIGEN_QTMALLOC_MODULE_H
/* vim: set filetype=cpp et sw=2 ts=2 ai: */
data_process_class_dll/eigen-3.3.7/Eigen/SPQRSupport
-34
View File
@@ -1,34 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_SPQRSUPPORT_MODULE_H
#define EIGEN_SPQRSUPPORT_MODULE_H
#include "SparseCore"
#include "src/Core/util/DisableStupidWarnings.h"
#include "SuiteSparseQR.hpp"
/** \ingroup Support_modules
* \defgroup SPQRSupport_Module SuiteSparseQR module
*
* This module provides an interface to the SPQR library, which is part of the <a href="http://www.suitesparse.com">suitesparse</a> package.
*
* \code
* #include <Eigen/SPQRSupport>
* \endcode
*
* In order to use this module, the SPQR headers must be accessible from the include paths, and your binary must be linked to the SPQR library and its dependencies (Cholmod, AMD, COLAMD,...).
* For a cmake based project, you can use our FindSPQR.cmake and FindCholmod.Cmake modules
*
*/
#include "src/CholmodSupport/CholmodSupport.h"
#include "src/SPQRSupport/SuiteSparseQRSupport.h"
#endif
data_process_class_dll/eigen-3.3.7/Eigen/SVD
-51
View File
@@ -1,51 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_SVD_MODULE_H
#define EIGEN_SVD_MODULE_H
#include "QR"
#include "Householder"
#include "Jacobi"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup SVD_Module SVD module
*
*
*
* This module provides SVD decomposition for matrices (both real and complex).
* Two decomposition algorithms are provided:
* - JacobiSVD implementing two-sided Jacobi iterations is numerically very accurate, fast for small matrices, but very slow for larger ones.
* - BDCSVD implementing a recursive divide & conquer strategy on top of an upper-bidiagonalization which remains fast for large problems.
* These decompositions are accessible via the respective classes and following MatrixBase methods:
* - MatrixBase::jacobiSvd()
* - MatrixBase::bdcSvd()
*
* \code
* #include <Eigen/SVD>
* \endcode
*/
#include "src/misc/RealSvd2x2.h"
#include "src/SVD/UpperBidiagonalization.h"
#include "src/SVD/SVDBase.h"
#include "src/SVD/JacobiSVD.h"
#include "src/SVD/BDCSVD.h"
#if defined(EIGEN_USE_LAPACKE) && !defined(EIGEN_USE_LAPACKE_STRICT)
#ifdef EIGEN_USE_MKL
#include "mkl_lapacke.h"
#else
#include "src/misc/lapacke.h"
#endif
#include "src/SVD/JacobiSVD_LAPACKE.h"
#endif
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_SVD_MODULE_H
/* vim: set filetype=cpp et sw=2 ts=2 ai: */
data_process_class_dll/eigen-3.3.7/Eigen/Sparse
-36
View File
@@ -1,36 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_SPARSE_MODULE_H
#define EIGEN_SPARSE_MODULE_H
/** \defgroup Sparse_Module Sparse meta-module
*
* Meta-module including all related modules:
* - \ref SparseCore_Module
* - \ref OrderingMethods_Module
* - \ref SparseCholesky_Module
* - \ref SparseLU_Module
* - \ref SparseQR_Module
* - \ref IterativeLinearSolvers_Module
*
\code
#include <Eigen/Sparse>
\endcode
*/
#include "SparseCore"
#include "OrderingMethods"
#ifndef EIGEN_MPL2_ONLY
#include "SparseCholesky"
#endif
#include "SparseLU"
#include "SparseQR"
#include "IterativeLinearSolvers"
#endif // EIGEN_SPARSE_MODULE_H
data_process_class_dll/eigen-3.3.7/Eigen/SparseCholesky
-45
View File
@@ -1,45 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008-2013 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_SPARSECHOLESKY_MODULE_H
#define EIGEN_SPARSECHOLESKY_MODULE_H
#include "SparseCore"
#include "OrderingMethods"
#include "src/Core/util/DisableStupidWarnings.h"
/**
* \defgroup SparseCholesky_Module SparseCholesky module
*
* This module currently provides two variants of the direct sparse Cholesky decomposition for selfadjoint (hermitian) matrices.
* Those decompositions are accessible via the following classes:
* - SimplicialLLt,
* - SimplicialLDLt
*
* Such problems can also be solved using the ConjugateGradient solver from the IterativeLinearSolvers module.
*
* \code
* #include <Eigen/SparseCholesky>
* \endcode
*/
#ifdef EIGEN_MPL2_ONLY
#error The SparseCholesky module has nothing to offer in MPL2 only mode
#endif
#include "src/SparseCholesky/SimplicialCholesky.h"
#ifndef EIGEN_MPL2_ONLY
#include "src/SparseCholesky/SimplicialCholesky_impl.h"
#endif
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_SPARSECHOLESKY_MODULE_H
data_process_class_dll/eigen-3.3.7/Eigen/SparseCore
-69
View File
@@ -1,69 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_SPARSECORE_MODULE_H
#define EIGEN_SPARSECORE_MODULE_H
#include "Core"
#include "src/Core/util/DisableStupidWarnings.h"
#include <vector>
#include <map>
#include <cstdlib>
#include <cstring>
#include <algorithm>
/**
* \defgroup SparseCore_Module SparseCore module
*
* This module provides a sparse matrix representation, and basic associated matrix manipulations
* and operations.
*
* See the \ref TutorialSparse "Sparse tutorial"
*
* \code
* #include <Eigen/SparseCore>
* \endcode
*
* This module depends on: Core.
*/
#include "src/SparseCore/SparseUtil.h"
#include "src/SparseCore/SparseMatrixBase.h"
#include "src/SparseCore/SparseAssign.h"
#include "src/SparseCore/CompressedStorage.h"
#include "src/SparseCore/AmbiVector.h"
#include "src/SparseCore/SparseCompressedBase.h"
#include "src/SparseCore/SparseMatrix.h"
#include "src/SparseCore/SparseMap.h"
#include "src/SparseCore/MappedSparseMatrix.h"
#include "src/SparseCore/SparseVector.h"
#include "src/SparseCore/SparseRef.h"
#include "src/SparseCore/SparseCwiseUnaryOp.h"
#include "src/SparseCore/SparseCwiseBinaryOp.h"
#include "src/SparseCore/SparseTranspose.h"
#include "src/SparseCore/SparseBlock.h"
#include "src/SparseCore/SparseDot.h"
#include "src/SparseCore/SparseRedux.h"
#include "src/SparseCore/SparseView.h"
#include "src/SparseCore/SparseDiagonalProduct.h"
#include "src/SparseCore/ConservativeSparseSparseProduct.h"
#include "src/SparseCore/SparseSparseProductWithPruning.h"
#include "src/SparseCore/SparseProduct.h"
#include "src/SparseCore/SparseDenseProduct.h"
#include "src/SparseCore/SparseSelfAdjointView.h"
#include "src/SparseCore/SparseTriangularView.h"
#include "src/SparseCore/TriangularSolver.h"
#include "src/SparseCore/SparsePermutation.h"
#include "src/SparseCore/SparseFuzzy.h"
#include "src/SparseCore/SparseSolverBase.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_SPARSECORE_MODULE_H
data_process_class_dll/eigen-3.3.7/Eigen/SparseLU
-46
View File
@@ -1,46 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_SPARSELU_MODULE_H
#define EIGEN_SPARSELU_MODULE_H
#include "SparseCore"
/**
* \defgroup SparseLU_Module SparseLU module
* This module defines a supernodal factorization of general sparse matrices.
* The code is fully optimized for supernode-panel updates with specialized kernels.
* Please, see the documentation of the SparseLU class for more details.
*/
// Ordering interface
#include "OrderingMethods"
#include "src/SparseLU/SparseLU_gemm_kernel.h"
#include "src/SparseLU/SparseLU_Structs.h"
#include "src/SparseLU/SparseLU_SupernodalMatrix.h"
#include "src/SparseLU/SparseLUImpl.h"
#include "src/SparseCore/SparseColEtree.h"
#include "src/SparseLU/SparseLU_Memory.h"
#include "src/SparseLU/SparseLU_heap_relax_snode.h"
#include "src/SparseLU/SparseLU_relax_snode.h"
#include "src/SparseLU/SparseLU_pivotL.h"
#include "src/SparseLU/SparseLU_panel_dfs.h"
#include "src/SparseLU/SparseLU_kernel_bmod.h"
#include "src/SparseLU/SparseLU_panel_bmod.h"
#include "src/SparseLU/SparseLU_column_dfs.h"
#include "src/SparseLU/SparseLU_column_bmod.h"
#include "src/SparseLU/SparseLU_copy_to_ucol.h"
#include "src/SparseLU/SparseLU_pruneL.h"
#include "src/SparseLU/SparseLU_Utils.h"
#include "src/SparseLU/SparseLU.h"
#endif // EIGEN_SPARSELU_MODULE_H
data_process_class_dll/eigen-3.3.7/Eigen/SparseQR
-37
View File
@@ -1,37 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_SPARSEQR_MODULE_H
#define EIGEN_SPARSEQR_MODULE_H
#include "SparseCore"
#include "OrderingMethods"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup SparseQR_Module SparseQR module
* \brief Provides QR decomposition for sparse matrices
*
* This module provides a simplicial version of the left-looking Sparse QR decomposition.
* The columns of the input matrix should be reordered to limit the fill-in during the
* decomposition. Built-in methods (COLAMD, AMD) or external methods (METIS) can be used to this end.
* See the \link OrderingMethods_Module OrderingMethods\endlink module for the list
* of built-in and external ordering methods.
*
* \code
* #include <Eigen/SparseQR>
* \endcode
*
*
*/
#include "OrderingMethods"
#include "src/SparseCore/SparseColEtree.h"
#include "src/SparseQR/SparseQR.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif
data_process_class_dll/eigen-3.3.7/Eigen/StdDeque
-27
View File
@@ -1,27 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_STDDEQUE_MODULE_H
#define EIGEN_STDDEQUE_MODULE_H
#include "Core"
#include <deque>
#if EIGEN_COMP_MSVC && EIGEN_OS_WIN64 && (EIGEN_MAX_STATIC_ALIGN_BYTES<=16) /* MSVC auto aligns up to 16 bytes in 64 bit builds */
#define EIGEN_DEFINE_STL_DEQUE_SPECIALIZATION(...)
#else
#include "src/StlSupport/StdDeque.h"
#endif
#endif // EIGEN_STDDEQUE_MODULE_H
data_process_class_dll/eigen-3.3.7/Eigen/StdList
-26
View File
@@ -1,26 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_STDLIST_MODULE_H
#define EIGEN_STDLIST_MODULE_H
#include "Core"
#include <list>
#if EIGEN_COMP_MSVC && EIGEN_OS_WIN64 && (EIGEN_MAX_STATIC_ALIGN_BYTES<=16) /* MSVC auto aligns up to 16 bytes in 64 bit builds */
#define EIGEN_DEFINE_STL_LIST_SPECIALIZATION(...)
#else
#include "src/StlSupport/StdList.h"
#endif
#endif // EIGEN_STDLIST_MODULE_H
data_process_class_dll/eigen-3.3.7/Eigen/StdVector
-27
View File
@@ -1,27 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_STDVECTOR_MODULE_H
#define EIGEN_STDVECTOR_MODULE_H
#include "Core"
#include <vector>
#if EIGEN_COMP_MSVC && EIGEN_OS_WIN64 && (EIGEN_MAX_STATIC_ALIGN_BYTES<=16) /* MSVC auto aligns up to 16 bytes in 64 bit builds */
#define EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION(...)
#else
#include "src/StlSupport/StdVector.h"
#endif
#endif // EIGEN_STDVECTOR_MODULE_H
data_process_class_dll/eigen-3.3.7/Eigen/SuperLUSupport
-64
View File
@@ -1,64 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_SUPERLUSUPPORT_MODULE_H
#define EIGEN_SUPERLUSUPPORT_MODULE_H
#include "SparseCore"
#include "src/Core/util/DisableStupidWarnings.h"
#ifdef EMPTY
#define EIGEN_EMPTY_WAS_ALREADY_DEFINED
#endif
typedef int int_t;
#include <slu_Cnames.h>
#include <supermatrix.h>
#include <slu_util.h>
// slu_util.h defines a preprocessor token named EMPTY which is really polluting,
// so we remove it in favor of a SUPERLU_EMPTY token.
// If EMPTY was already defined then we don't undef it.
#if defined(EIGEN_EMPTY_WAS_ALREADY_DEFINED)
# undef EIGEN_EMPTY_WAS_ALREADY_DEFINED
#elif defined(EMPTY)
# undef EMPTY
#endif
#define SUPERLU_EMPTY (-1)
namespace Eigen { struct SluMatrix; }
/** \ingroup Support_modules
* \defgroup SuperLUSupport_Module SuperLUSupport module
*
* This module provides an interface to the <a href="http://crd-legacy.lbl.gov/~xiaoye/SuperLU/">SuperLU</a> library.
* It provides the following factorization class:
* - class SuperLU: a supernodal sequential LU factorization.
* - class SuperILU: a supernodal sequential incomplete LU factorization (to be used as a preconditioner for iterative methods).
*
* \warning This wrapper requires at least versions 4.0 of SuperLU. The 3.x versions are not supported.
*
* \warning When including this module, you have to use SUPERLU_EMPTY instead of EMPTY which is no longer defined because it is too polluting.
*
* \code
* #include <Eigen/SuperLUSupport>
* \endcode
*
* In order to use this module, the superlu headers must be accessible from the include paths, and your binary must be linked to the superlu library and its dependencies.
* The dependencies depend on how superlu has been compiled.
* For a cmake based project, you can use our FindSuperLU.cmake module to help you in this task.
*
*/
#include "src/SuperLUSupport/SuperLUSupport.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_SUPERLUSUPPORT_MODULE_H
data_process_class_dll/eigen-3.3.7/Eigen/UmfPackSupport
-40
View File
@@ -1,40 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_UMFPACKSUPPORT_MODULE_H
#define EIGEN_UMFPACKSUPPORT_MODULE_H
#include "SparseCore"
#include "src/Core/util/DisableStupidWarnings.h"
extern "C" {
#include <umfpack.h>
}
/** \ingroup Support_modules
* \defgroup UmfPackSupport_Module UmfPackSupport module
*
* This module provides an interface to the UmfPack library which is part of the <a href="http://www.suitesparse.com">suitesparse</a> package.
* It provides the following factorization class:
* - class UmfPackLU: a multifrontal sequential LU factorization.
*
* \code
* #include <Eigen/UmfPackSupport>
* \endcode
*
* In order to use this module, the umfpack headers must be accessible from the include paths, and your binary must be linked to the umfpack library and its dependencies.
* The dependencies depend on how umfpack has been compiled.
* For a cmake based project, you can use our FindUmfPack.cmake module to help you in this task.
*
*/
#include "src/UmfPackSupport/UmfPackSupport.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_UMFPACKSUPPORT_MODULE_H
data_process_class_dll/eigen-3.3.7/Eigen/src/Cholesky/LDLT.h
-673
View File
@@ -1,673 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2009 Keir Mierle <mierle@gmail.com>
// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
// Copyright (C) 2011 Timothy E. Holy <tim.holy@gmail.com >
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_LDLT_H
#define EIGEN_LDLT_H
namespace Eigen {
namespace internal {
template<typename MatrixType, int UpLo> struct LDLT_Traits;
// PositiveSemiDef means positive semi-definite and non-zero; same for NegativeSemiDef
enum SignMatrix { PositiveSemiDef, NegativeSemiDef, ZeroSign, Indefinite };
}
/** \ingroup Cholesky_Module
*
* \class LDLT
*
* \brief Robust Cholesky decomposition of a matrix with pivoting
*
* \tparam _MatrixType the type of the matrix of which to compute the LDL^T Cholesky decomposition
* \tparam _UpLo the triangular part that will be used for the decompositon: Lower (default) or Upper.
* The other triangular part won't be read.
*
* Perform a robust Cholesky decomposition of a positive semidefinite or negative semidefinite
* matrix \f$ A \f$ such that \f$ A = P^TLDL^*P \f$, where P is a permutation matrix, L
* is lower triangular with a unit diagonal and D is a diagonal matrix.
*
* The decomposition uses pivoting to ensure stability, so that L will have
* zeros in the bottom right rank(A) - n submatrix. Avoiding the square root
* on D also stabilizes the computation.
*
* Remember that Cholesky decompositions are not rank-revealing. Also, do not use a Cholesky
* decomposition to determine whether a system of equations has a solution.
*
* This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
*
* \sa MatrixBase::ldlt(), SelfAdjointView::ldlt(), class LLT
*/
template<typename _MatrixType, int _UpLo> class LDLT
{
public:
typedef _MatrixType MatrixType;
enum {
RowsAtCompileTime = MatrixType::RowsAtCompileTime,
ColsAtCompileTime = MatrixType::ColsAtCompileTime,
MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
UpLo = _UpLo
};
typedef typename MatrixType::Scalar Scalar;
typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
typedef typename MatrixType::StorageIndex StorageIndex;
typedef Matrix<Scalar, RowsAtCompileTime, 1, 0, MaxRowsAtCompileTime, 1> TmpMatrixType;
typedef Transpositions<RowsAtCompileTime, MaxRowsAtCompileTime> TranspositionType;
typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime> PermutationType;
typedef internal::LDLT_Traits<MatrixType,UpLo> Traits;
/** \brief Default Constructor.
*
* The default constructor is useful in cases in which the user intends to
* perform decompositions via LDLT::compute(const MatrixType&).
*/
LDLT()
: m_matrix(),
m_transpositions(),
m_sign(internal::ZeroSign),
m_isInitialized(false)
{}
/** \brief Default Constructor with memory preallocation
*
* Like the default constructor but with preallocation of the internal data
* according to the specified problem \a size.
* \sa LDLT()
*/
explicit LDLT(Index size)
: m_matrix(size, size),
m_transpositions(size),
m_temporary(size),
m_sign(internal::ZeroSign),
m_isInitialized(false)
{}
/** \brief Constructor with decomposition
*
* This calculates the decomposition for the input \a matrix.
*
* \sa LDLT(Index size)
*/
template<typename InputType>
explicit LDLT(const EigenBase<InputType>& matrix)
: m_matrix(matrix.rows(), matrix.cols()),
m_transpositions(matrix.rows()),
m_temporary(matrix.rows()),
m_sign(internal::ZeroSign),
m_isInitialized(false)
{
compute(matrix.derived());
}
/** \brief Constructs a LDLT factorization from a given matrix
*
* This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c MatrixType is a Eigen::Ref.
*
* \sa LDLT(const EigenBase&)
*/
template<typename InputType>
explicit LDLT(EigenBase<InputType>& matrix)
: m_matrix(matrix.derived()),
m_transpositions(matrix.rows()),
m_temporary(matrix.rows()),
m_sign(internal::ZeroSign),
m_isInitialized(false)
{
compute(matrix.derived());
}
/** Clear any existing decomposition
* \sa rankUpdate(w,sigma)
*/
void setZero()
{
m_isInitialized = false;
}
/** \returns a view of the upper triangular matrix U */
inline typename Traits::MatrixU matrixU() const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
return Traits::getU(m_matrix);
}
/** \returns a view of the lower triangular matrix L */
inline typename Traits::MatrixL matrixL() const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
return Traits::getL(m_matrix);
}
/** \returns the permutation matrix P as a transposition sequence.
*/
inline const TranspositionType& transpositionsP() const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
return m_transpositions;
}
/** \returns the coefficients of the diagonal matrix D */
inline Diagonal<const MatrixType> vectorD() const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
return m_matrix.diagonal();
}
/** \returns true if the matrix is positive (semidefinite) */
inline bool isPositive() const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
return m_sign == internal::PositiveSemiDef || m_sign == internal::ZeroSign;
}
/** \returns true if the matrix is negative (semidefinite) */
inline bool isNegative(void) const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
return m_sign == internal::NegativeSemiDef || m_sign == internal::ZeroSign;
}
/** \returns a solution x of \f$ A x = b \f$ using the current decomposition of A.
*
* This function also supports in-place solves using the syntax <tt>x = decompositionObject.solve(x)</tt> .
*
* \note_about_checking_solutions
*
* More precisely, this method solves \f$ A x = b \f$ using the decomposition \f$ A = P^T L D L^* P \f$
* by solving the systems \f$ P^T y_1 = b \f$, \f$ L y_2 = y_1 \f$, \f$ D y_3 = y_2 \f$,
* \f$ L^* y_4 = y_3 \f$ and \f$ P x = y_4 \f$ in succession. If the matrix \f$ A \f$ is singular, then
* \f$ D \f$ will also be singular (all the other matrices are invertible). In that case, the
* least-square solution of \f$ D y_3 = y_2 \f$ is computed. This does not mean that this function
* computes the least-square solution of \f$ A x = b \f$ is \f$ A \f$ is singular.
*
* \sa MatrixBase::ldlt(), SelfAdjointView::ldlt()
*/
template<typename Rhs>
inline const Solve<LDLT, Rhs>
solve(const MatrixBase<Rhs>& b) const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
eigen_assert(m_matrix.rows()==b.rows()
&& "LDLT::solve(): invalid number of rows of the right hand side matrix b");
return Solve<LDLT, Rhs>(*this, b.derived());
}
template<typename Derived>
bool solveInPlace(MatrixBase<Derived> &bAndX) const;
template<typename InputType>
LDLT& compute(const EigenBase<InputType>& matrix);
/** \returns an estimate of the reciprocal condition number of the matrix of
* which \c *this is the LDLT decomposition.
*/
RealScalar rcond() const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
return internal::rcond_estimate_helper(m_l1_norm, *this);
}
template <typename Derived>
LDLT& rankUpdate(const MatrixBase<Derived>& w, const RealScalar& alpha=1);
/** \returns the internal LDLT decomposition matrix
*
* TODO: document the storage layout
*/
inline const MatrixType& matrixLDLT() const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
return m_matrix;
}
MatrixType reconstructedMatrix() const;
/** \returns the adjoint of \c *this, that is, a const reference to the decomposition itself as the underlying matrix is self-adjoint.
*
* This method is provided for compatibility with other matrix decompositions, thus enabling generic code such as:
* \code x = decomposition.adjoint().solve(b) \endcode
*/
const LDLT& adjoint() const { return *this; };
inline Index rows() const { return m_matrix.rows(); }
inline Index cols() const { return m_matrix.cols(); }
/** \brief Reports whether previous computation was successful.
*
* \returns \c Success if computation was succesful,
* \c NumericalIssue if the factorization failed because of a zero pivot.
*/
ComputationInfo info() const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
return m_info;
}
#ifndef EIGEN_PARSED_BY_DOXYGEN
template<typename RhsType, typename DstType>
EIGEN_DEVICE_FUNC
void _solve_impl(const RhsType &rhs, DstType &dst) const;
#endif
protected:
static void check_template_parameters()
{
EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
}
/** \internal
* Used to compute and store the Cholesky decomposition A = L D L^* = U^* D U.
* The strict upper part is used during the decomposition, the strict lower
* part correspond to the coefficients of L (its diagonal is equal to 1 and
* is not stored), and the diagonal entries correspond to D.
*/
MatrixType m_matrix;
RealScalar m_l1_norm;
TranspositionType m_transpositions;
TmpMatrixType m_temporary;
internal::SignMatrix m_sign;
bool m_isInitialized;
ComputationInfo m_info;
};
namespace internal {
template<int UpLo> struct ldlt_inplace;
template<> struct ldlt_inplace<Lower>
{
template<typename MatrixType, typename TranspositionType, typename Workspace>
static bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, SignMatrix& sign)
{
using std::abs;
typedef typename MatrixType::Scalar Scalar;
typedef typename MatrixType::RealScalar RealScalar;
typedef typename TranspositionType::StorageIndex IndexType;
eigen_assert(mat.rows()==mat.cols());
const Index size = mat.rows();
bool found_zero_pivot = false;
bool ret = true;
if (size <= 1)
{
transpositions.setIdentity();
if(size==0) sign = ZeroSign;
else if (numext::real(mat.coeff(0,0)) > static_cast<RealScalar>(0) ) sign = PositiveSemiDef;
else if (numext::real(mat.coeff(0,0)) < static_cast<RealScalar>(0)) sign = NegativeSemiDef;
else sign = ZeroSign;
return true;
}
for (Index k = 0; k < size; ++k)
{
// Find largest diagonal element
Index index_of_biggest_in_corner;
mat.diagonal().tail(size-k).cwiseAbs().maxCoeff(&index_of_biggest_in_corner);
index_of_biggest_in_corner += k;
transpositions.coeffRef(k) = IndexType(index_of_biggest_in_corner);
if(k != index_of_biggest_in_corner)
{
// apply the transposition while taking care to consider only
// the lower triangular part
Index s = size-index_of_biggest_in_corner-1; // trailing size after the biggest element
mat.row(k).head(k).swap(mat.row(index_of_biggest_in_corner).head(k));
mat.col(k).tail(s).swap(mat.col(index_of_biggest_in_corner).tail(s));
std::swap(mat.coeffRef(k,k),mat.coeffRef(index_of_biggest_in_corner,index_of_biggest_in_corner));
for(Index i=k+1;i<index_of_biggest_in_corner;++i)
{
Scalar tmp = mat.coeffRef(i,k);
mat.coeffRef(i,k) = numext::conj(mat.coeffRef(index_of_biggest_in_corner,i));
mat.coeffRef(index_of_biggest_in_corner,i) = numext::conj(tmp);
}
if(NumTraits<Scalar>::IsComplex)
mat.coeffRef(index_of_biggest_in_corner,k) = numext::conj(mat.coeff(index_of_biggest_in_corner,k));
}
// partition the matrix:
// A00 | - | -
// lu = A10 | A11 | -
// A20 | A21 | A22
Index rs = size - k - 1;
Block<MatrixType,Dynamic,1> A21(mat,k+1,k,rs,1);
Block<MatrixType,1,Dynamic> A10(mat,k,0,1,k);
Block<MatrixType,Dynamic,Dynamic> A20(mat,k+1,0,rs,k);
if(k>0)
{
temp.head(k) = mat.diagonal().real().head(k).asDiagonal() * A10.adjoint();
mat.coeffRef(k,k) -= (A10 * temp.head(k)).value();
if(rs>0)
A21.noalias() -= A20 * temp.head(k);
}
// In some previous versions of Eigen (e.g., 3.2.1), the scaling was omitted if the pivot
// was smaller than the cutoff value. However, since LDLT is not rank-revealing
// we should only make sure that we do not introduce INF or NaN values.
// Remark that LAPACK also uses 0 as the cutoff value.
RealScalar realAkk = numext::real(mat.coeffRef(k,k));
bool pivot_is_valid = (abs(realAkk) > RealScalar(0));
if(k==0 && !pivot_is_valid)
{
// The entire diagonal is zero, there is nothing more to do
// except filling the transpositions, and checking whether the matrix is zero.
sign = ZeroSign;
for(Index j = 0; j<size; ++j)
{
transpositions.coeffRef(j) = IndexType(j);
ret = ret && (mat.col(j).tail(size-j-1).array()==Scalar(0)).all();
}
return ret;
}
if((rs>0) && pivot_is_valid)
A21 /= realAkk;
else if(rs>0)
ret = ret && (A21.array()==Scalar(0)).all();
if(found_zero_pivot && pivot_is_valid) ret = false; // factorization failed
else if(!pivot_is_valid) found_zero_pivot = true;
if (sign == PositiveSemiDef) {
if (realAkk < static_cast<RealScalar>(0)) sign = Indefinite;
} else if (sign == NegativeSemiDef) {
if (realAkk > static_cast<RealScalar>(0)) sign = Indefinite;
} else if (sign == ZeroSign) {
if (realAkk > static_cast<RealScalar>(0)) sign = PositiveSemiDef;
else if (realAkk < static_cast<RealScalar>(0)) sign = NegativeSemiDef;
}
}
return ret;
}
// Reference for the algorithm: Davis and Hager, "Multiple Rank
// Modifications of a Sparse Cholesky Factorization" (Algorithm 1)
// Trivial rearrangements of their computations (Timothy E. Holy)
// allow their algorithm to work for rank-1 updates even if the
// original matrix is not of full rank.
// Here only rank-1 updates are implemented, to reduce the
// requirement for intermediate storage and improve accuracy
template<typename MatrixType, typename WDerived>
static bool updateInPlace(MatrixType& mat, MatrixBase<WDerived>& w, const typename MatrixType::RealScalar& sigma=1)
{
using numext::isfinite;
typedef typename MatrixType::Scalar Scalar;
typedef typename MatrixType::RealScalar RealScalar;
const Index size = mat.rows();
eigen_assert(mat.cols() == size && w.size()==size);
RealScalar alpha = 1;
// Apply the update
for (Index j = 0; j < size; j++)
{
// Check for termination due to an original decomposition of low-rank
if (!(isfinite)(alpha))
break;
// Update the diagonal terms
RealScalar dj = numext::real(mat.coeff(j,j));
Scalar wj = w.coeff(j);
RealScalar swj2 = sigma*numext::abs2(wj);
RealScalar gamma = dj*alpha + swj2;
mat.coeffRef(j,j) += swj2/alpha;
alpha += swj2/dj;
// Update the terms of L
Index rs = size-j-1;
w.tail(rs) -= wj * mat.col(j).tail(rs);
if(gamma != 0)
mat.col(j).tail(rs) += (sigma*numext::conj(wj)/gamma)*w.tail(rs);
}
return true;
}
template<typename MatrixType, typename TranspositionType, typename Workspace, typename WType>
static bool update(MatrixType& mat, const TranspositionType& transpositions, Workspace& tmp, const WType& w, const typename MatrixType::RealScalar& sigma=1)
{
// Apply the permutation to the input w
tmp = transpositions * w;
return ldlt_inplace<Lower>::updateInPlace(mat,tmp,sigma);
}
};
template<> struct ldlt_inplace<Upper>
{
template<typename MatrixType, typename TranspositionType, typename Workspace>
static EIGEN_STRONG_INLINE bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, SignMatrix& sign)
{
Transpose<MatrixType> matt(mat);
return ldlt_inplace<Lower>::unblocked(matt, transpositions, temp, sign);
}
template<typename MatrixType, typename TranspositionType, typename Workspace, typename WType>
static EIGEN_STRONG_INLINE bool update(MatrixType& mat, TranspositionType& transpositions, Workspace& tmp, WType& w, const typename MatrixType::RealScalar& sigma=1)
{
Transpose<MatrixType> matt(mat);
return ldlt_inplace<Lower>::update(matt, transpositions, tmp, w.conjugate(), sigma);
}
};
template<typename MatrixType> struct LDLT_Traits<MatrixType,Lower>
{
typedef const TriangularView<const MatrixType, UnitLower> MatrixL;
typedef const TriangularView<const typename MatrixType::AdjointReturnType, UnitUpper> MatrixU;
static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
};
template<typename MatrixType> struct LDLT_Traits<MatrixType,Upper>
{
typedef const TriangularView<const typename MatrixType::AdjointReturnType, UnitLower> MatrixL;
typedef const TriangularView<const MatrixType, UnitUpper> MatrixU;
static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); }
static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
};
} // end namespace internal
/** Compute / recompute the LDLT decomposition A = L D L^* = U^* D U of \a matrix
*/
template<typename MatrixType, int _UpLo>
template<typename InputType>
LDLT<MatrixType,_UpLo>& LDLT<MatrixType,_UpLo>::compute(const EigenBase<InputType>& a)
{
check_template_parameters();
eigen_assert(a.rows()==a.cols());
const Index size = a.rows();
m_matrix = a.derived();
// Compute matrix L1 norm = max abs column sum.
m_l1_norm = RealScalar(0);
// TODO move this code to SelfAdjointView
for (Index col = 0; col < size; ++col) {
RealScalar abs_col_sum;
if (_UpLo == Lower)
abs_col_sum = m_matrix.col(col).tail(size - col).template lpNorm<1>() + m_matrix.row(col).head(col).template lpNorm<1>();
else
abs_col_sum = m_matrix.col(col).head(col).template lpNorm<1>() + m_matrix.row(col).tail(size - col).template lpNorm<1>();
if (abs_col_sum > m_l1_norm)
m_l1_norm = abs_col_sum;
}
m_transpositions.resize(size);
m_isInitialized = false;
m_temporary.resize(size);
m_sign = internal::ZeroSign;
m_info = internal::ldlt_inplace<UpLo>::unblocked(m_matrix, m_transpositions, m_temporary, m_sign) ? Success : NumericalIssue;
m_isInitialized = true;
return *this;
}
/** Update the LDLT decomposition: given A = L D L^T, efficiently compute the decomposition of A + sigma w w^T.
* \param w a vector to be incorporated into the decomposition.
* \param sigma a scalar, +1 for updates and -1 for "downdates," which correspond to removing previously-added column vectors. Optional; default value is +1.
* \sa setZero()
*/
template<typename MatrixType, int _UpLo>
template<typename Derived>
LDLT<MatrixType,_UpLo>& LDLT<MatrixType,_UpLo>::rankUpdate(const MatrixBase<Derived>& w, const typename LDLT<MatrixType,_UpLo>::RealScalar& sigma)
{
typedef typename TranspositionType::StorageIndex IndexType;
const Index size = w.rows();
if (m_isInitialized)
{
eigen_assert(m_matrix.rows()==size);
}
else
{
m_matrix.resize(size,size);
m_matrix.setZero();
m_transpositions.resize(size);
for (Index i = 0; i < size; i++)
m_transpositions.coeffRef(i) = IndexType(i);
m_temporary.resize(size);
m_sign = sigma>=0 ? internal::PositiveSemiDef : internal::NegativeSemiDef;
m_isInitialized = true;
}
internal::ldlt_inplace<UpLo>::update(m_matrix, m_transpositions, m_temporary, w, sigma);
return *this;
}
#ifndef EIGEN_PARSED_BY_DOXYGEN
template<typename _MatrixType, int _UpLo>
template<typename RhsType, typename DstType>
void LDLT<_MatrixType,_UpLo>::_solve_impl(const RhsType &rhs, DstType &dst) const
{
eigen_assert(rhs.rows() == rows());
// dst = P b
dst = m_transpositions * rhs;
// dst = L^-1 (P b)
matrixL().solveInPlace(dst);
// dst = D^-1 (L^-1 P b)
// more precisely, use pseudo-inverse of D (see bug 241)
using std::abs;
const typename Diagonal<const MatrixType>::RealReturnType vecD(vectorD());
// In some previous versions, tolerance was set to the max of 1/highest (or rather numeric_limits::min())
// and the maximal diagonal entry * epsilon as motivated by LAPACK's xGELSS:
// RealScalar tolerance = numext::maxi(vecD.array().abs().maxCoeff() * NumTraits<RealScalar>::epsilon(),RealScalar(1) / NumTraits<RealScalar>::highest());
// However, LDLT is not rank revealing, and so adjusting the tolerance wrt to the highest
// diagonal element is not well justified and leads to numerical issues in some cases.
// Moreover, Lapack's xSYTRS routines use 0 for the tolerance.
// Using numeric_limits::min() gives us more robustness to denormals.
RealScalar tolerance = (std::numeric_limits<RealScalar>::min)();
for (Index i = 0; i < vecD.size(); ++i)
{
if(abs(vecD(i)) > tolerance)
dst.row(i) /= vecD(i);
else
dst.row(i).setZero();
}
// dst = L^-T (D^-1 L^-1 P b)
matrixU().solveInPlace(dst);
// dst = P^-1 (L^-T D^-1 L^-1 P b) = A^-1 b
dst = m_transpositions.transpose() * dst;
}
#endif
/** \internal use x = ldlt_object.solve(x);
*
* This is the \em in-place version of solve().
*
* \param bAndX represents both the right-hand side matrix b and result x.
*
* \returns true always! If you need to check for existence of solutions, use another decomposition like LU, QR, or SVD.
*
* This version avoids a copy when the right hand side matrix b is not
* needed anymore.
*
* \sa LDLT::solve(), MatrixBase::ldlt()
*/
template<typename MatrixType,int _UpLo>
template<typename Derived>
bool LDLT<MatrixType,_UpLo>::solveInPlace(MatrixBase<Derived> &bAndX) const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
eigen_assert(m_matrix.rows() == bAndX.rows());
bAndX = this->solve(bAndX);
return true;
}
/** \returns the matrix represented by the decomposition,
* i.e., it returns the product: P^T L D L^* P.
* This function is provided for debug purpose. */
template<typename MatrixType, int _UpLo>
MatrixType LDLT<MatrixType,_UpLo>::reconstructedMatrix() const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
const Index size = m_matrix.rows();
MatrixType res(size,size);
// P
res.setIdentity();
res = transpositionsP() * res;
// L^* P
res = matrixU() * res;
// D(L^*P)
res = vectorD().real().asDiagonal() * res;
// L(DL^*P)
res = matrixL() * res;
// P^T (LDL^*P)
res = transpositionsP().transpose() * res;
return res;
}
/** \cholesky_module
* \returns the Cholesky decomposition with full pivoting without square root of \c *this
* \sa MatrixBase::ldlt()
*/
template<typename MatrixType, unsigned int UpLo>
inline const LDLT<typename SelfAdjointView<MatrixType, UpLo>::PlainObject, UpLo>
SelfAdjointView<MatrixType, UpLo>::ldlt() const
{
return LDLT<PlainObject,UpLo>(m_matrix);
}
/** \cholesky_module
* \returns the Cholesky decomposition with full pivoting without square root of \c *this
* \sa SelfAdjointView::ldlt()
*/
template<typename Derived>
inline const LDLT<typename MatrixBase<Derived>::PlainObject>
MatrixBase<Derived>::ldlt() const
{
return LDLT<PlainObject>(derived());
}
} // end namespace Eigen
#endif // EIGEN_LDLT_H
data_process_class_dll/eigen-3.3.7/Eigen/src/Cholesky/LLT.h
-542
View File
@@ -1,542 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_LLT_H
#define EIGEN_LLT_H
namespace Eigen {
namespace internal{
template<typename MatrixType, int UpLo> struct LLT_Traits;
}
/** \ingroup Cholesky_Module
*
* \class LLT
*
* \brief Standard Cholesky decomposition (LL^T) of a matrix and associated features
*
* \tparam _MatrixType the type of the matrix of which we are computing the LL^T Cholesky decomposition
* \tparam _UpLo the triangular part that will be used for the decompositon: Lower (default) or Upper.
* The other triangular part won't be read.
*
* This class performs a LL^T Cholesky decomposition of a symmetric, positive definite
* matrix A such that A = LL^* = U^*U, where L is lower triangular.
*
* While the Cholesky decomposition is particularly useful to solve selfadjoint problems like D^*D x = b,
* for that purpose, we recommend the Cholesky decomposition without square root which is more stable
* and even faster. Nevertheless, this standard Cholesky decomposition remains useful in many other
* situations like generalised eigen problems with hermitian matrices.
*
* Remember that Cholesky decompositions are not rank-revealing. This LLT decomposition is only stable on positive definite matrices,
* use LDLT instead for the semidefinite case. Also, do not use a Cholesky decomposition to determine whether a system of equations
* has a solution.
*
* Example: \include LLT_example.cpp
* Output: \verbinclude LLT_example.out
*
* \b Performance: for best performance, it is recommended to use a column-major storage format
* with the Lower triangular part (the default), or, equivalently, a row-major storage format
* with the Upper triangular part. Otherwise, you might get a 20% slowdown for the full factorization
* step, and rank-updates can be up to 3 times slower.
*
* This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
*
* Note that during the decomposition, only the lower (or upper, as defined by _UpLo) triangular part of A is considered.
* Therefore, the strict lower part does not have to store correct values.
*
* \sa MatrixBase::llt(), SelfAdjointView::llt(), class LDLT
*/
template<typename _MatrixType, int _UpLo> class LLT
{
public:
typedef _MatrixType MatrixType;
enum {
RowsAtCompileTime = MatrixType::RowsAtCompileTime,
ColsAtCompileTime = MatrixType::ColsAtCompileTime,
MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
};
typedef typename MatrixType::Scalar Scalar;
typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
typedef typename MatrixType::StorageIndex StorageIndex;
enum {
PacketSize = internal::packet_traits<Scalar>::size,
AlignmentMask = int(PacketSize)-1,
UpLo = _UpLo
};
typedef internal::LLT_Traits<MatrixType,UpLo> Traits;
/**
* \brief Default Constructor.
*
* The default constructor is useful in cases in which the user intends to
* perform decompositions via LLT::compute(const MatrixType&).
*/
LLT() : m_matrix(), m_isInitialized(false) {}
/** \brief Default Constructor with memory preallocation
*
* Like the default constructor but with preallocation of the internal data
* according to the specified problem \a size.
* \sa LLT()
*/
explicit LLT(Index size) : m_matrix(size, size),
m_isInitialized(false) {}
template<typename InputType>
explicit LLT(const EigenBase<InputType>& matrix)
: m_matrix(matrix.rows(), matrix.cols()),
m_isInitialized(false)
{
compute(matrix.derived());
}
/** \brief Constructs a LDLT factorization from a given matrix
*
* This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when
* \c MatrixType is a Eigen::Ref.
*
* \sa LLT(const EigenBase&)
*/
template<typename InputType>
explicit LLT(EigenBase<InputType>& matrix)
: m_matrix(matrix.derived()),
m_isInitialized(false)
{
compute(matrix.derived());
}
/** \returns a view of the upper triangular matrix U */
inline typename Traits::MatrixU matrixU() const
{
eigen_assert(m_isInitialized && "LLT is not initialized.");
return Traits::getU(m_matrix);
}
/** \returns a view of the lower triangular matrix L */
inline typename Traits::MatrixL matrixL() const
{
eigen_assert(m_isInitialized && "LLT is not initialized.");
return Traits::getL(m_matrix);
}
/** \returns the solution x of \f$ A x = b \f$ using the current decomposition of A.
*
* Since this LLT class assumes anyway that the matrix A is invertible, the solution
* theoretically exists and is unique regardless of b.
*
* Example: \include LLT_solve.cpp
* Output: \verbinclude LLT_solve.out
*
* \sa solveInPlace(), MatrixBase::llt(), SelfAdjointView::llt()
*/
template<typename Rhs>
inline const Solve<LLT, Rhs>
solve(const MatrixBase<Rhs>& b) const
{
eigen_assert(m_isInitialized && "LLT is not initialized.");
eigen_assert(m_matrix.rows()==b.rows()
&& "LLT::solve(): invalid number of rows of the right hand side matrix b");
return Solve<LLT, Rhs>(*this, b.derived());
}
template<typename Derived>
void solveInPlace(const MatrixBase<Derived> &bAndX) const;
template<typename InputType>
LLT& compute(const EigenBase<InputType>& matrix);
/** \returns an estimate of the reciprocal condition number of the matrix of
* which \c *this is the Cholesky decomposition.
*/
RealScalar rcond() const
{
eigen_assert(m_isInitialized && "LLT is not initialized.");
eigen_assert(m_info == Success && "LLT failed because matrix appears to be negative");
return internal::rcond_estimate_helper(m_l1_norm, *this);
}
/** \returns the LLT decomposition matrix
*
* TODO: document the storage layout
*/
inline const MatrixType& matrixLLT() const
{
eigen_assert(m_isInitialized && "LLT is not initialized.");
return m_matrix;
}
MatrixType reconstructedMatrix() const;
/** \brief Reports whether previous computation was successful.
*
* \returns \c Success if computation was succesful,
* \c NumericalIssue if the matrix.appears not to be positive definite.
*/
ComputationInfo info() const
{
eigen_assert(m_isInitialized && "LLT is not initialized.");
return m_info;
}
/** \returns the adjoint of \c *this, that is, a const reference to the decomposition itself as the underlying matrix is self-adjoint.
*
* This method is provided for compatibility with other matrix decompositions, thus enabling generic code such as:
* \code x = decomposition.adjoint().solve(b) \endcode
*/
const LLT& adjoint() const { return *this; };
inline Index rows() const { return m_matrix.rows(); }
inline Index cols() const { return m_matrix.cols(); }
template<typename VectorType>
LLT rankUpdate(const VectorType& vec, const RealScalar& sigma = 1);
#ifndef EIGEN_PARSED_BY_DOXYGEN
template<typename RhsType, typename DstType>
EIGEN_DEVICE_FUNC
void _solve_impl(const RhsType &rhs, DstType &dst) const;
#endif
protected:
static void check_template_parameters()
{
EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
}
/** \internal
* Used to compute and store L
* The strict upper part is not used and even not initialized.
*/
MatrixType m_matrix;
RealScalar m_l1_norm;
bool m_isInitialized;
ComputationInfo m_info;
};
namespace internal {
template<typename Scalar, int UpLo> struct llt_inplace;
template<typename MatrixType, typename VectorType>
static Index llt_rank_update_lower(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma)
{
using std::sqrt;
typedef typename MatrixType::Scalar Scalar;
typedef typename MatrixType::RealScalar RealScalar;
typedef typename MatrixType::ColXpr ColXpr;
typedef typename internal::remove_all<ColXpr>::type ColXprCleaned;
typedef typename ColXprCleaned::SegmentReturnType ColXprSegment;
typedef Matrix<Scalar,Dynamic,1> TempVectorType;
typedef typename TempVectorType::SegmentReturnType TempVecSegment;
Index n = mat.cols();
eigen_assert(mat.rows()==n && vec.size()==n);
TempVectorType temp;
if(sigma>0)
{
// This version is based on Givens rotations.
// It is faster than the other one below, but only works for updates,
// i.e., for sigma > 0
temp = sqrt(sigma) * vec;
for(Index i=0; i<n; ++i)
{
JacobiRotation<Scalar> g;
g.makeGivens(mat(i,i), -temp(i), &mat(i,i));
Index rs = n-i-1;
if(rs>0)
{
ColXprSegment x(mat.col(i).tail(rs));
TempVecSegment y(temp.tail(rs));
apply_rotation_in_the_plane(x, y, g);
}
}
}
else
{
temp = vec;
RealScalar beta = 1;
for(Index j=0; j<n; ++j)
{
RealScalar Ljj = numext::real(mat.coeff(j,j));
RealScalar dj = numext::abs2(Ljj);
Scalar wj = temp.coeff(j);
RealScalar swj2 = sigma*numext::abs2(wj);
RealScalar gamma = dj*beta + swj2;
RealScalar x = dj + swj2/beta;
if (x<=RealScalar(0))
return j;
RealScalar nLjj = sqrt(x);
mat.coeffRef(j,j) = nLjj;
beta += swj2/dj;
// Update the terms of L
Index rs = n-j-1;
if(rs)
{
temp.tail(rs) -= (wj/Ljj) * mat.col(j).tail(rs);
if(gamma != 0)
mat.col(j).tail(rs) = (nLjj/Ljj) * mat.col(j).tail(rs) + (nLjj * sigma*numext::conj(wj)/gamma)*temp.tail(rs);
}
}
}
return -1;
}
template<typename Scalar> struct llt_inplace<Scalar, Lower>
{
typedef typename NumTraits<Scalar>::Real RealScalar;
template<typename MatrixType>
static Index unblocked(MatrixType& mat)
{
using std::sqrt;
eigen_assert(mat.rows()==mat.cols());
const Index size = mat.rows();
for(Index k = 0; k < size; ++k)
{
Index rs = size-k-1; // remaining size
Block<MatrixType,Dynamic,1> A21(mat,k+1,k,rs,1);
Block<MatrixType,1,Dynamic> A10(mat,k,0,1,k);
Block<MatrixType,Dynamic,Dynamic> A20(mat,k+1,0,rs,k);
RealScalar x = numext::real(mat.coeff(k,k));
if (k>0) x -= A10.squaredNorm();
if (x<=RealScalar(0))
return k;
mat.coeffRef(k,k) = x = sqrt(x);
if (k>0 && rs>0) A21.noalias() -= A20 * A10.adjoint();
if (rs>0) A21 /= x;
}
return -1;
}
template<typename MatrixType>
static Index blocked(MatrixType& m)
{
eigen_assert(m.rows()==m.cols());
Index size = m.rows();
if(size<32)
return unblocked(m);
Index blockSize = size/8;
blockSize = (blockSize/16)*16;
blockSize = (std::min)((std::max)(blockSize,Index(8)), Index(128));
for (Index k=0; k<size; k+=blockSize)
{
// partition the matrix:
// A00 | - | -
// lu = A10 | A11 | -
// A20 | A21 | A22
Index bs = (std::min)(blockSize, size-k);
Index rs = size - k - bs;
Block<MatrixType,Dynamic,Dynamic> A11(m,k, k, bs,bs);
Block<MatrixType,Dynamic,Dynamic> A21(m,k+bs,k, rs,bs);
Block<MatrixType,Dynamic,Dynamic> A22(m,k+bs,k+bs,rs,rs);
Index ret;
if((ret=unblocked(A11))>=0) return k+ret;
if(rs>0) A11.adjoint().template triangularView<Upper>().template solveInPlace<OnTheRight>(A21);
if(rs>0) A22.template selfadjointView<Lower>().rankUpdate(A21,typename NumTraits<RealScalar>::Literal(-1)); // bottleneck
}
return -1;
}
template<typename MatrixType, typename VectorType>
static Index rankUpdate(MatrixType& mat, const VectorType& vec, const RealScalar& sigma)
{
return Eigen::internal::llt_rank_update_lower(mat, vec, sigma);
}
};
template<typename Scalar> struct llt_inplace<Scalar, Upper>
{
typedef typename NumTraits<Scalar>::Real RealScalar;
template<typename MatrixType>
static EIGEN_STRONG_INLINE Index unblocked(MatrixType& mat)
{
Transpose<MatrixType> matt(mat);
return llt_inplace<Scalar, Lower>::unblocked(matt);
}
template<typename MatrixType>
static EIGEN_STRONG_INLINE Index blocked(MatrixType& mat)
{
Transpose<MatrixType> matt(mat);
return llt_inplace<Scalar, Lower>::blocked(matt);
}
template<typename MatrixType, typename VectorType>
static Index rankUpdate(MatrixType& mat, const VectorType& vec, const RealScalar& sigma)
{
Transpose<MatrixType> matt(mat);
return llt_inplace<Scalar, Lower>::rankUpdate(matt, vec.conjugate(), sigma);
}
};
template<typename MatrixType> struct LLT_Traits<MatrixType,Lower>
{
typedef const TriangularView<const MatrixType, Lower> MatrixL;
typedef const TriangularView<const typename MatrixType::AdjointReturnType, Upper> MatrixU;
static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
static bool inplace_decomposition(MatrixType& m)
{ return llt_inplace<typename MatrixType::Scalar, Lower>::blocked(m)==-1; }
};
template<typename MatrixType> struct LLT_Traits<MatrixType,Upper>
{
typedef const TriangularView<const typename MatrixType::AdjointReturnType, Lower> MatrixL;
typedef const TriangularView<const MatrixType, Upper> MatrixU;
static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); }
static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
static bool inplace_decomposition(MatrixType& m)
{ return llt_inplace<typename MatrixType::Scalar, Upper>::blocked(m)==-1; }
};
} // end namespace internal
/** Computes / recomputes the Cholesky decomposition A = LL^* = U^*U of \a matrix
*
* \returns a reference to *this
*
* Example: \include TutorialLinAlgComputeTwice.cpp
* Output: \verbinclude TutorialLinAlgComputeTwice.out
*/
template<typename MatrixType, int _UpLo>
template<typename InputType>
LLT<MatrixType,_UpLo>& LLT<MatrixType,_UpLo>::compute(const EigenBase<InputType>& a)
{
check_template_parameters();
eigen_assert(a.rows()==a.cols());
const Index size = a.rows();
m_matrix.resize(size, size);
if (!internal::is_same_dense(m_matrix, a.derived()))
m_matrix = a.derived();
// Compute matrix L1 norm = max abs column sum.
m_l1_norm = RealScalar(0);
// TODO move this code to SelfAdjointView
for (Index col = 0; col < size; ++col) {
RealScalar abs_col_sum;
if (_UpLo == Lower)
abs_col_sum = m_matrix.col(col).tail(size - col).template lpNorm<1>() + m_matrix.row(col).head(col).template lpNorm<1>();
else
abs_col_sum = m_matrix.col(col).head(col).template lpNorm<1>() + m_matrix.row(col).tail(size - col).template lpNorm<1>();
if (abs_col_sum > m_l1_norm)
m_l1_norm = abs_col_sum;
}
m_isInitialized = true;
bool ok = Traits::inplace_decomposition(m_matrix);
m_info = ok ? Success : NumericalIssue;
return *this;
}
/** Performs a rank one update (or dowdate) of the current decomposition.
* If A = LL^* before the rank one update,
* then after it we have LL^* = A + sigma * v v^* where \a v must be a vector
* of same dimension.
*/
template<typename _MatrixType, int _UpLo>
template<typename VectorType>
LLT<_MatrixType,_UpLo> LLT<_MatrixType,_UpLo>::rankUpdate(const VectorType& v, const RealScalar& sigma)
{
EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorType);
eigen_assert(v.size()==m_matrix.cols());
eigen_assert(m_isInitialized);
if(internal::llt_inplace<typename MatrixType::Scalar, UpLo>::rankUpdate(m_matrix,v,sigma)>=0)
m_info = NumericalIssue;
else
m_info = Success;
return *this;
}
#ifndef EIGEN_PARSED_BY_DOXYGEN
template<typename _MatrixType,int _UpLo>
template<typename RhsType, typename DstType>
void LLT<_MatrixType,_UpLo>::_solve_impl(const RhsType &rhs, DstType &dst) const
{
dst = rhs;
solveInPlace(dst);
}
#endif
/** \internal use x = llt_object.solve(x);
*
* This is the \em in-place version of solve().
*
* \param bAndX represents both the right-hand side matrix b and result x.
*
* This version avoids a copy when the right hand side matrix b is not needed anymore.
*
* \warning The parameter is only marked 'const' to make the C++ compiler accept a temporary expression here.
* This function will const_cast it, so constness isn't honored here.
*
* \sa LLT::solve(), MatrixBase::llt()
*/
template<typename MatrixType, int _UpLo>
template<typename Derived>
void LLT<MatrixType,_UpLo>::solveInPlace(const MatrixBase<Derived> &bAndX) const
{
eigen_assert(m_isInitialized && "LLT is not initialized.");
eigen_assert(m_matrix.rows()==bAndX.rows());
matrixL().solveInPlace(bAndX);
matrixU().solveInPlace(bAndX);
}
/** \returns the matrix represented by the decomposition,
* i.e., it returns the product: L L^*.
* This function is provided for debug purpose. */
template<typename MatrixType, int _UpLo>
MatrixType LLT<MatrixType,_UpLo>::reconstructedMatrix() const
{
eigen_assert(m_isInitialized && "LLT is not initialized.");
return matrixL() * matrixL().adjoint().toDenseMatrix();
}
/** \cholesky_module
* \returns the LLT decomposition of \c *this
* \sa SelfAdjointView::llt()
*/
template<typename Derived>
inline const LLT<typename MatrixBase<Derived>::PlainObject>
MatrixBase<Derived>::llt() const
{
return LLT<PlainObject>(derived());
}
/** \cholesky_module
* \returns the LLT decomposition of \c *this
* \sa SelfAdjointView::llt()
*/
template<typename MatrixType, unsigned int UpLo>
inline const LLT<typename SelfAdjointView<MatrixType, UpLo>::PlainObject, UpLo>
SelfAdjointView<MatrixType, UpLo>::llt() const
{
return LLT<PlainObject,UpLo>(m_matrix);
}
} // end namespace Eigen
#endif // EIGEN_LLT_H
data_process_class_dll/eigen-3.3.7/Eigen/src/Cholesky/LLT_LAPACKE.h
-99
View File
@@ -1,99 +0,0 @@
/*
Copyright (c) 2011, Intel Corporation. All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of Intel Corporation nor the names of its contributors may
be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
********************************************************************************
* Content : Eigen bindings to LAPACKe
* LLt decomposition based on LAPACKE_?potrf function.
********************************************************************************
*/
#ifndef EIGEN_LLT_LAPACKE_H
#define EIGEN_LLT_LAPACKE_H
namespace Eigen {
namespace internal {
template<typename Scalar> struct lapacke_llt;
#define EIGEN_LAPACKE_LLT(EIGTYPE, BLASTYPE, LAPACKE_PREFIX) \
template<> struct lapacke_llt<EIGTYPE> \
{ \
template<typename MatrixType> \
static inline Index potrf(MatrixType& m, char uplo) \
{ \
lapack_int matrix_order; \
lapack_int size, lda, info, StorageOrder; \
EIGTYPE* a; \
eigen_assert(m.rows()==m.cols()); \
/* Set up parameters for ?potrf */ \
size = convert_index<lapack_int>(m.rows()); \
StorageOrder = MatrixType::Flags&RowMajorBit?RowMajor:ColMajor; \
matrix_order = StorageOrder==RowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \
a = &(m.coeffRef(0,0)); \
lda = convert_index<lapack_int>(m.outerStride()); \
\
info = LAPACKE_##LAPACKE_PREFIX##potrf( matrix_order, uplo, size, (BLASTYPE*)a, lda ); \
info = (info==0) ? -1 : info>0 ? info-1 : size; \
return info; \
} \
}; \
template<> struct llt_inplace<EIGTYPE, Lower> \
{ \
template<typename MatrixType> \
static Index blocked(MatrixType& m) \
{ \
return lapacke_llt<EIGTYPE>::potrf(m, 'L'); \
} \
template<typename MatrixType, typename VectorType> \
static Index rankUpdate(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma) \
{ return Eigen::internal::llt_rank_update_lower(mat, vec, sigma); } \
}; \
template<> struct llt_inplace<EIGTYPE, Upper> \
{ \
template<typename MatrixType> \
static Index blocked(MatrixType& m) \
{ \
return lapacke_llt<EIGTYPE>::potrf(m, 'U'); \
} \
template<typename MatrixType, typename VectorType> \
static Index rankUpdate(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma) \
{ \
Transpose<MatrixType> matt(mat); \
return llt_inplace<EIGTYPE, Lower>::rankUpdate(matt, vec.conjugate(), sigma); \
} \
};
EIGEN_LAPACKE_LLT(double, double, d)
EIGEN_LAPACKE_LLT(float, float, s)
EIGEN_LAPACKE_LLT(dcomplex, lapack_complex_double, z)
EIGEN_LAPACKE_LLT(scomplex, lapack_complex_float, c)
} // end namespace internal
} // end namespace Eigen
#endif // EIGEN_LLT_LAPACKE_H
data_process_class_dll/eigen-3.3.7/Eigen/src/CholmodSupport/CholmodSupport.h
-639
View File
@@ -1,639 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_CHOLMODSUPPORT_H
#define EIGEN_CHOLMODSUPPORT_H
namespace Eigen {
namespace internal {
template<typename Scalar> struct cholmod_configure_matrix;
template<> struct cholmod_configure_matrix<double> {
template<typename CholmodType>
static void run(CholmodType& mat) {
mat.xtype = CHOLMOD_REAL;
mat.dtype = CHOLMOD_DOUBLE;
}
};
template<> struct cholmod_configure_matrix<std::complex<double> > {
template<typename CholmodType>
static void run(CholmodType& mat) {
mat.xtype = CHOLMOD_COMPLEX;
mat.dtype = CHOLMOD_DOUBLE;
}
};
// Other scalar types are not yet suppotred by Cholmod
// template<> struct cholmod_configure_matrix<float> {
// template<typename CholmodType>
// static void run(CholmodType& mat) {
// mat.xtype = CHOLMOD_REAL;
// mat.dtype = CHOLMOD_SINGLE;
// }
// };
//
// template<> struct cholmod_configure_matrix<std::complex<float> > {
// template<typename CholmodType>
// static void run(CholmodType& mat) {
// mat.xtype = CHOLMOD_COMPLEX;
// mat.dtype = CHOLMOD_SINGLE;
// }
// };
} // namespace internal
/** Wraps the Eigen sparse matrix \a mat into a Cholmod sparse matrix object.
* Note that the data are shared.
*/
template<typename _Scalar, int _Options, typename _StorageIndex>
cholmod_sparse viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_StorageIndex> > mat)
{
cholmod_sparse res;
res.nzmax = mat.nonZeros();
res.nrow = mat.rows();
res.ncol = mat.cols();
res.p = mat.outerIndexPtr();
res.i = mat.innerIndexPtr();
res.x = mat.valuePtr();
res.z = 0;
res.sorted = 1;
if(mat.isCompressed())
{
res.packed = 1;
res.nz = 0;
}
else
{
res.packed = 0;
res.nz = mat.innerNonZeroPtr();
}
res.dtype = 0;
res.stype = -1;
if (internal::is_same<_StorageIndex,int>::value)
{
res.itype = CHOLMOD_INT;
}
else if (internal::is_same<_StorageIndex,long>::value)
{
res.itype = CHOLMOD_LONG;
}
else
{
eigen_assert(false && "Index type not supported yet");
}
// setup res.xtype
internal::cholmod_configure_matrix<_Scalar>::run(res);
res.stype = 0;
return res;
}
template<typename _Scalar, int _Options, typename _Index>
const cholmod_sparse viewAsCholmod(const SparseMatrix<_Scalar,_Options,_Index>& mat)
{
cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_Index> >(mat.const_cast_derived()));
return res;
}
template<typename _Scalar, int _Options, typename _Index>
const cholmod_sparse viewAsCholmod(const SparseVector<_Scalar,_Options,_Index>& mat)
{
cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_Index> >(mat.const_cast_derived()));
return res;
}
/** Returns a view of the Eigen sparse matrix \a mat as Cholmod sparse matrix.
* The data are not copied but shared. */
template<typename _Scalar, int _Options, typename _Index, unsigned int UpLo>
cholmod_sparse viewAsCholmod(const SparseSelfAdjointView<const SparseMatrix<_Scalar,_Options,_Index>, UpLo>& mat)
{
cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_Index> >(mat.matrix().const_cast_derived()));
if(UpLo==Upper) res.stype = 1;
if(UpLo==Lower) res.stype = -1;
return res;
}
/** Returns a view of the Eigen \b dense matrix \a mat as Cholmod dense matrix.
* The data are not copied but shared. */
template<typename Derived>
cholmod_dense viewAsCholmod(MatrixBase<Derived>& mat)
{
EIGEN_STATIC_ASSERT((internal::traits<Derived>::Flags&RowMajorBit)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
typedef typename Derived::Scalar Scalar;
cholmod_dense res;
res.nrow = mat.rows();
res.ncol = mat.cols();
res.nzmax = res.nrow * res.ncol;
res.d = Derived::IsVectorAtCompileTime ? mat.derived().size() : mat.derived().outerStride();
res.x = (void*)(mat.derived().data());
res.z = 0;
internal::cholmod_configure_matrix<Scalar>::run(res);
return res;
}
/** Returns a view of the Cholmod sparse matrix \a cm as an Eigen sparse matrix.
* The data are not copied but shared. */
template<typename Scalar, int Flags, typename StorageIndex>
MappedSparseMatrix<Scalar,Flags,StorageIndex> viewAsEigen(cholmod_sparse& cm)
{
return MappedSparseMatrix<Scalar,Flags,StorageIndex>
(cm.nrow, cm.ncol, static_cast<StorageIndex*>(cm.p)[cm.ncol],
static_cast<StorageIndex*>(cm.p), static_cast<StorageIndex*>(cm.i),static_cast<Scalar*>(cm.x) );
}
enum CholmodMode {
CholmodAuto, CholmodSimplicialLLt, CholmodSupernodalLLt, CholmodLDLt
};
/** \ingroup CholmodSupport_Module
* \class CholmodBase
* \brief The base class for the direct Cholesky factorization of Cholmod
* \sa class CholmodSupernodalLLT, class CholmodSimplicialLDLT, class CholmodSimplicialLLT
*/
template<typename _MatrixType, int _UpLo, typename Derived>
class CholmodBase : public SparseSolverBase<Derived>
{
protected:
typedef SparseSolverBase<Derived> Base;
using Base::derived;
using Base::m_isInitialized;
public:
typedef _MatrixType MatrixType;
enum { UpLo = _UpLo };
typedef typename MatrixType::Scalar Scalar;
typedef typename MatrixType::RealScalar RealScalar;
typedef MatrixType CholMatrixType;
typedef typename MatrixType::StorageIndex StorageIndex;
enum {
ColsAtCompileTime = MatrixType::ColsAtCompileTime,
MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
};
public:
CholmodBase()
: m_cholmodFactor(0), m_info(Success), m_factorizationIsOk(false), m_analysisIsOk(false)
{
EIGEN_STATIC_ASSERT((internal::is_same<double,RealScalar>::value), CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY);
m_shiftOffset[0] = m_shiftOffset[1] = 0.0;
cholmod_start(&m_cholmod);
}
explicit CholmodBase(const MatrixType& matrix)
: m_cholmodFactor(0), m_info(Success), m_factorizationIsOk(false), m_analysisIsOk(false)
{
EIGEN_STATIC_ASSERT((internal::is_same<double,RealScalar>::value), CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY);
m_shiftOffset[0] = m_shiftOffset[1] = 0.0;
cholmod_start(&m_cholmod);
compute(matrix);
}
~CholmodBase()
{
if(m_cholmodFactor)
cholmod_free_factor(&m_cholmodFactor, &m_cholmod);
cholmod_finish(&m_cholmod);
}
inline StorageIndex cols() const { return internal::convert_index<StorageIndex, Index>(m_cholmodFactor->n); }
inline StorageIndex rows() const { return internal::convert_index<StorageIndex, Index>(m_cholmodFactor->n); }
/** \brief Reports whether previous computation was successful.
*
* \returns \c Success if computation was succesful,
* \c NumericalIssue if the matrix.appears to be negative.
*/
ComputationInfo info() const
{
eigen_assert(m_isInitialized && "Decomposition is not initialized.");
return m_info;
}
/** Computes the sparse Cholesky decomposition of \a matrix */
Derived& compute(const MatrixType& matrix)
{
analyzePattern(matrix);
factorize(matrix);
return derived();
}
/** Performs a symbolic decomposition on the sparsity pattern of \a matrix.
*
* This function is particularly useful when solving for several problems having the same structure.
*
* \sa factorize()
*/
void analyzePattern(const MatrixType& matrix)
{
if(m_cholmodFactor)
{
cholmod_free_factor(&m_cholmodFactor, &m_cholmod);
m_cholmodFactor = 0;
}
cholmod_sparse A = viewAsCholmod(matrix.template selfadjointView<UpLo>());
m_cholmodFactor = cholmod_analyze(&A, &m_cholmod);
this->m_isInitialized = true;
this->m_info = Success;
m_analysisIsOk = true;
m_factorizationIsOk = false;
}
/** Performs a numeric decomposition of \a matrix
*
* The given matrix must have the same sparsity pattern as the matrix on which the symbolic decomposition has been performed.
*
* \sa analyzePattern()
*/
void factorize(const MatrixType& matrix)
{
eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
cholmod_sparse A = viewAsCholmod(matrix.template selfadjointView<UpLo>());
cholmod_factorize_p(&A, m_shiftOffset, 0, 0, m_cholmodFactor, &m_cholmod);
// If the factorization failed, minor is the column at which it did. On success minor == n.
this->m_info = (m_cholmodFactor->minor == m_cholmodFactor->n ? Success : NumericalIssue);
m_factorizationIsOk = true;
}
/** Returns a reference to the Cholmod's configuration structure to get a full control over the performed operations.
* See the Cholmod user guide for details. */
cholmod_common& cholmod() { return m_cholmod; }
#ifndef EIGEN_PARSED_BY_DOXYGEN
/** \internal */
template<typename Rhs,typename Dest>
void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const
{
eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
const Index size = m_cholmodFactor->n;
EIGEN_UNUSED_VARIABLE(size);
eigen_assert(size==b.rows());
// Cholmod needs column-major stoarge without inner-stride, which corresponds to the default behavior of Ref.
Ref<const Matrix<typename Rhs::Scalar,Dynamic,Dynamic,ColMajor> > b_ref(b.derived());
cholmod_dense b_cd = viewAsCholmod(b_ref);
cholmod_dense* x_cd = cholmod_solve(CHOLMOD_A, m_cholmodFactor, &b_cd, &m_cholmod);
if(!x_cd)
{
this->m_info = NumericalIssue;
return;
}
// TODO optimize this copy by swapping when possible (be careful with alignment, etc.)
dest = Matrix<Scalar,Dest::RowsAtCompileTime,Dest::ColsAtCompileTime>::Map(reinterpret_cast<Scalar*>(x_cd->x),b.rows(),b.cols());
cholmod_free_dense(&x_cd, &m_cholmod);
}
/** \internal */
template<typename RhsDerived, typename DestDerived>
void _solve_impl(const SparseMatrixBase<RhsDerived> &b, SparseMatrixBase<DestDerived> &dest) const
{
eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
const Index size = m_cholmodFactor->n;
EIGEN_UNUSED_VARIABLE(size);
eigen_assert(size==b.rows());
// note: cs stands for Cholmod Sparse
Ref<SparseMatrix<typename RhsDerived::Scalar,ColMajor,typename RhsDerived::StorageIndex> > b_ref(b.const_cast_derived());
cholmod_sparse b_cs = viewAsCholmod(b_ref);
cholmod_sparse* x_cs = cholmod_spsolve(CHOLMOD_A, m_cholmodFactor, &b_cs, &m_cholmod);
if(!x_cs)
{
this->m_info = NumericalIssue;
return;
}
// TODO optimize this copy by swapping when possible (be careful with alignment, etc.)
dest.derived() = viewAsEigen<typename DestDerived::Scalar,ColMajor,typename DestDerived::StorageIndex>(*x_cs);
cholmod_free_sparse(&x_cs, &m_cholmod);
}
#endif // EIGEN_PARSED_BY_DOXYGEN
/** Sets the shift parameter that will be used to adjust the diagonal coefficients during the numerical factorization.
*
* During the numerical factorization, an offset term is added to the diagonal coefficients:\n
* \c d_ii = \a offset + \c d_ii
*
* The default is \a offset=0.
*
* \returns a reference to \c *this.
*/
Derived& setShift(const RealScalar& offset)
{
m_shiftOffset[0] = double(offset);
return derived();
}
/** \returns the determinant of the underlying matrix from the current factorization */
Scalar determinant() const
{
using std::exp;
return exp(logDeterminant());
}
/** \returns the log determinant of the underlying matrix from the current factorization */
Scalar logDeterminant() const
{
using std::log;
using numext::real;
eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
RealScalar logDet = 0;
Scalar *x = static_cast<Scalar*>(m_cholmodFactor->x);
if (m_cholmodFactor->is_super)
{
// Supernodal factorization stored as a packed list of dense column-major blocs,
// as described by the following structure:
// super[k] == index of the first column of the j-th super node
StorageIndex *super = static_cast<StorageIndex*>(m_cholmodFactor->super);
// pi[k] == offset to the description of row indices
StorageIndex *pi = static_cast<StorageIndex*>(m_cholmodFactor->pi);
// px[k] == offset to the respective dense block
StorageIndex *px = static_cast<StorageIndex*>(m_cholmodFactor->px);
Index nb_super_nodes = m_cholmodFactor->nsuper;
for (Index k=0; k < nb_super_nodes; ++k)
{
StorageIndex ncols = super[k + 1] - super[k];
StorageIndex nrows = pi[k + 1] - pi[k];
Map<const Array<Scalar,1,Dynamic>, 0, InnerStride<> > sk(x + px[k], ncols, InnerStride<>(nrows+1));
logDet += sk.real().log().sum();
}
}
else
{
// Simplicial factorization stored as standard CSC matrix.
StorageIndex *p = static_cast<StorageIndex*>(m_cholmodFactor->p);
Index size = m_cholmodFactor->n;
for (Index k=0; k<size; ++k)
logDet += log(real( x[p[k]] ));
}
if (m_cholmodFactor->is_ll)
logDet *= 2.0;
return logDet;
};
template<typename Stream>
void dumpMemory(Stream& /*s*/)
{}
protected:
mutable cholmod_common m_cholmod;
cholmod_factor* m_cholmodFactor;
double m_shiftOffset[2];
mutable ComputationInfo m_info;
int m_factorizationIsOk;
int m_analysisIsOk;
};
/** \ingroup CholmodSupport_Module
* \class CholmodSimplicialLLT
* \brief A simplicial direct Cholesky (LLT) factorization and solver based on Cholmod
*
* This class allows to solve for A.X = B sparse linear problems via a simplicial LL^T Cholesky factorization
* using the Cholmod library.
* This simplicial variant is equivalent to Eigen's built-in SimplicialLLT class. Therefore, it has little practical interest.
* The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices
* X and B can be either dense or sparse.
*
* \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
* \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
* or Upper. Default is Lower.
*
* \implsparsesolverconcept
*
* This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed.
*
* \warning Only double precision real and complex scalar types are supported by Cholmod.
*
* \sa \ref TutorialSparseSolverConcept, class CholmodSupernodalLLT, class SimplicialLLT
*/
template<typename _MatrixType, int _UpLo = Lower>
class CholmodSimplicialLLT : public CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLLT<_MatrixType, _UpLo> >
{
typedef CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLLT> Base;
using Base::m_cholmod;
public:
typedef _MatrixType MatrixType;
CholmodSimplicialLLT() : Base() { init(); }
CholmodSimplicialLLT(const MatrixType& matrix) : Base()
{
init();
this->compute(matrix);
}
~CholmodSimplicialLLT() {}
protected:
void init()
{
m_cholmod.final_asis = 0;
m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
m_cholmod.final_ll = 1;
}
};
/** \ingroup CholmodSupport_Module
* \class CholmodSimplicialLDLT
* \brief A simplicial direct Cholesky (LDLT) factorization and solver based on Cholmod
*
* This class allows to solve for A.X = B sparse linear problems via a simplicial LDL^T Cholesky factorization
* using the Cholmod library.
* This simplicial variant is equivalent to Eigen's built-in SimplicialLDLT class. Therefore, it has little practical interest.
* The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices
* X and B can be either dense or sparse.
*
* \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
* \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
* or Upper. Default is Lower.
*
* \implsparsesolverconcept
*
* This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed.
*
* \warning Only double precision real and complex scalar types are supported by Cholmod.
*
* \sa \ref TutorialSparseSolverConcept, class CholmodSupernodalLLT, class SimplicialLDLT
*/
template<typename _MatrixType, int _UpLo = Lower>
class CholmodSimplicialLDLT : public CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLDLT<_MatrixType, _UpLo> >
{
typedef CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLDLT> Base;
using Base::m_cholmod;
public:
typedef _MatrixType MatrixType;
CholmodSimplicialLDLT() : Base() { init(); }
CholmodSimplicialLDLT(const MatrixType& matrix) : Base()
{
init();
this->compute(matrix);
}
~CholmodSimplicialLDLT() {}
protected:
void init()
{
m_cholmod.final_asis = 1;
m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
}
};
/** \ingroup CholmodSupport_Module
* \class CholmodSupernodalLLT
* \brief A supernodal Cholesky (LLT) factorization and solver based on Cholmod
*
* This class allows to solve for A.X = B sparse linear problems via a supernodal LL^T Cholesky factorization
* using the Cholmod library.
* This supernodal variant performs best on dense enough problems, e.g., 3D FEM, or very high order 2D FEM.
* The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices
* X and B can be either dense or sparse.
*
* \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
* \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
* or Upper. Default is Lower.
*
* \implsparsesolverconcept
*
* This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed.
*
* \warning Only double precision real and complex scalar types are supported by Cholmod.
*
* \sa \ref TutorialSparseSolverConcept
*/
template<typename _MatrixType, int _UpLo = Lower>
class CholmodSupernodalLLT : public CholmodBase<_MatrixType, _UpLo, CholmodSupernodalLLT<_MatrixType, _UpLo> >
{
typedef CholmodBase<_MatrixType, _UpLo, CholmodSupernodalLLT> Base;
using Base::m_cholmod;
public:
typedef _MatrixType MatrixType;
CholmodSupernodalLLT() : Base() { init(); }
CholmodSupernodalLLT(const MatrixType& matrix) : Base()
{
init();
this->compute(matrix);
}
~CholmodSupernodalLLT() {}
protected:
void init()
{
m_cholmod.final_asis = 1;
m_cholmod.supernodal = CHOLMOD_SUPERNODAL;
}
};
/** \ingroup CholmodSupport_Module
* \class CholmodDecomposition
* \brief A general Cholesky factorization and solver based on Cholmod
*
* This class allows to solve for A.X = B sparse linear problems via a LL^T or LDL^T Cholesky factorization
* using the Cholmod library. The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices
* X and B can be either dense or sparse.
*
* This variant permits to change the underlying Cholesky method at runtime.
* On the other hand, it does not provide access to the result of the factorization.
* The default is to let Cholmod automatically choose between a simplicial and supernodal factorization.
*
* \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
* \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
* or Upper. Default is Lower.
*
* \implsparsesolverconcept
*
* This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed.
*
* \warning Only double precision real and complex scalar types are supported by Cholmod.
*
* \sa \ref TutorialSparseSolverConcept
*/
template<typename _MatrixType, int _UpLo = Lower>
class CholmodDecomposition : public CholmodBase<_MatrixType, _UpLo, CholmodDecomposition<_MatrixType, _UpLo> >
{
typedef CholmodBase<_MatrixType, _UpLo, CholmodDecomposition> Base;
using Base::m_cholmod;
public:
typedef _MatrixType MatrixType;
CholmodDecomposition() : Base() { init(); }
CholmodDecomposition(const MatrixType& matrix) : Base()
{
init();
this->compute(matrix);
}
~CholmodDecomposition() {}
void setMode(CholmodMode mode)
{
switch(mode)
{
case CholmodAuto:
m_cholmod.final_asis = 1;
m_cholmod.supernodal = CHOLMOD_AUTO;
break;
case CholmodSimplicialLLt:
m_cholmod.final_asis = 0;
m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
m_cholmod.final_ll = 1;
break;
case CholmodSupernodalLLt:
m_cholmod.final_asis = 1;
m_cholmod.supernodal = CHOLMOD_SUPERNODAL;
break;
case CholmodLDLt:
m_cholmod.final_asis = 1;
m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
break;
default:
break;
}
}
protected:
void init()
{
m_cholmod.final_asis = 1;
m_cholmod.supernodal = CHOLMOD_AUTO;
}
};
} // end namespace Eigen
#endif // EIGEN_CHOLMODSUPPORT_H
data_process_class_dll/eigen-3.3.7/Eigen/src/Core/Array.h
-329
View File
@@ -1,329 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_ARRAY_H
#define EIGEN_ARRAY_H
namespace Eigen {
namespace internal {
template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
struct traits<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > : traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
{
typedef ArrayXpr XprKind;
typedef ArrayBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > XprBase;
};
}
/** \class Array
* \ingroup Core_Module
*
* \brief General-purpose arrays with easy API for coefficient-wise operations
*
* The %Array class is very similar to the Matrix class. It provides
* general-purpose one- and two-dimensional arrays. The difference between the
* %Array and the %Matrix class is primarily in the API: the API for the
* %Array class provides easy access to coefficient-wise operations, while the
* API for the %Matrix class provides easy access to linear-algebra
* operations.
*
* See documentation of class Matrix for detailed information on the template parameters
* storage layout.
*
* This class can be extended with the help of the plugin mechanism described on the page
* \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_ARRAY_PLUGIN.
*
* \sa \blank \ref TutorialArrayClass, \ref TopicClassHierarchy
*/
template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
class Array
: public PlainObjectBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
{
public:
typedef PlainObjectBase<Array> Base;
EIGEN_DENSE_PUBLIC_INTERFACE(Array)
enum { Options = _Options };
typedef typename Base::PlainObject PlainObject;
protected:
template <typename Derived, typename OtherDerived, bool IsVector>
friend struct internal::conservative_resize_like_impl;
using Base::m_storage;
public:
using Base::base;
using Base::coeff;
using Base::coeffRef;
/**
* The usage of
* using Base::operator=;
* fails on MSVC. Since the code below is working with GCC and MSVC, we skipped
* the usage of 'using'. This should be done only for operator=.
*/
template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array& operator=(const EigenBase<OtherDerived> &other)
{
return Base::operator=(other);
}
/** Set all the entries to \a value.
* \sa DenseBase::setConstant(), DenseBase::fill()
*/
/* This overload is needed because the usage of
* using Base::operator=;
* fails on MSVC. Since the code below is working with GCC and MSVC, we skipped
* the usage of 'using'. This should be done only for operator=.
*/
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array& operator=(const Scalar &value)
{
Base::setConstant(value);
return *this;
}
/** Copies the value of the expression \a other into \c *this with automatic resizing.
*
* *this might be resized to match the dimensions of \a other. If *this was a null matrix (not already initialized),
* it will be initialized.
*
* Note that copying a row-vector into a vector (and conversely) is allowed.
* The resizing, if any, is then done in the appropriate way so that row-vectors
* remain row-vectors and vectors remain vectors.
*/
template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array& operator=(const DenseBase<OtherDerived>& other)
{
return Base::_set(other);
}
/** This is a special case of the templated operator=. Its purpose is to
* prevent a default operator= from hiding the templated operator=.
*/
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array& operator=(const Array& other)
{
return Base::_set(other);
}
/** Default constructor.
*
* For fixed-size matrices, does nothing.
*
* For dynamic-size matrices, creates an empty matrix of size 0. Does not allocate any array. Such a matrix
* is called a null matrix. This constructor is the unique way to create null matrices: resizing
* a matrix to 0 is not supported.
*
* \sa resize(Index,Index)
*/
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array() : Base()
{
Base::_check_template_params();
EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
}
#ifndef EIGEN_PARSED_BY_DOXYGEN
// FIXME is it still needed ??
/** \internal */
EIGEN_DEVICE_FUNC
Array(internal::constructor_without_unaligned_array_assert)
: Base(internal::constructor_without_unaligned_array_assert())
{
Base::_check_template_params();
EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
}
#endif
#if EIGEN_HAS_RVALUE_REFERENCES
EIGEN_DEVICE_FUNC
Array(Array&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_constructible<Scalar>::value)
: Base(std::move(other))
{
Base::_check_template_params();
}
EIGEN_DEVICE_FUNC
Array& operator=(Array&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_assignable<Scalar>::value)
{
other.swap(*this);
return *this;
}
#endif
#ifndef EIGEN_PARSED_BY_DOXYGEN
template<typename T>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE explicit Array(const T& x)
{
Base::_check_template_params();
Base::template _init1<T>(x);
}
template<typename T0, typename T1>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array(const T0& val0, const T1& val1)
{
Base::_check_template_params();
this->template _init2<T0,T1>(val0, val1);
}
#else
/** \brief Constructs a fixed-sized array initialized with coefficients starting at \a data */
EIGEN_DEVICE_FUNC explicit Array(const Scalar *data);
/** Constructs a vector or row-vector with given dimension. \only_for_vectors
*
* Note that this is only useful for dynamic-size vectors. For fixed-size vectors,
* it is redundant to pass the dimension here, so it makes more sense to use the default
* constructor Array() instead.
*/
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE explicit Array(Index dim);
/** constructs an initialized 1x1 Array with the given coefficient */
Array(const Scalar& value);
/** constructs an uninitialized array with \a rows rows and \a cols columns.
*
* This is useful for dynamic-size arrays. For fixed-size arrays,
* it is redundant to pass these parameters, so one should use the default constructor
* Array() instead. */
Array(Index rows, Index cols);
/** constructs an initialized 2D vector with given coefficients */
Array(const Scalar& val0, const Scalar& val1);
#endif
/** constructs an initialized 3D vector with given coefficients */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array(const Scalar& val0, const Scalar& val1, const Scalar& val2)
{
Base::_check_template_params();
EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Array, 3)
m_storage.data()[0] = val0;
m_storage.data()[1] = val1;
m_storage.data()[2] = val2;
}
/** constructs an initialized 4D vector with given coefficients */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array(const Scalar& val0, const Scalar& val1, const Scalar& val2, const Scalar& val3)
{
Base::_check_template_params();
EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Array, 4)
m_storage.data()[0] = val0;
m_storage.data()[1] = val1;
m_storage.data()[2] = val2;
m_storage.data()[3] = val3;
}
/** Copy constructor */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array(const Array& other)
: Base(other)
{ }
private:
struct PrivateType {};
public:
/** \sa MatrixBase::operator=(const EigenBase<OtherDerived>&) */
template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array(const EigenBase<OtherDerived> &other,
typename internal::enable_if<internal::is_convertible<typename OtherDerived::Scalar,Scalar>::value,
PrivateType>::type = PrivateType())
: Base(other.derived())
{ }
EIGEN_DEVICE_FUNC inline Index innerStride() const { return 1; }
EIGEN_DEVICE_FUNC inline Index outerStride() const { return this->innerSize(); }
#ifdef EIGEN_ARRAY_PLUGIN
#include EIGEN_ARRAY_PLUGIN
#endif
private:
template<typename MatrixType, typename OtherDerived, bool SwapPointers>
friend struct internal::matrix_swap_impl;
};
/** \defgroup arraytypedefs Global array typedefs
* \ingroup Core_Module
*
* Eigen defines several typedef shortcuts for most common 1D and 2D array types.
*
* The general patterns are the following:
*
* \c ArrayRowsColsType where \c Rows and \c Cols can be \c 2,\c 3,\c 4 for fixed size square matrices or \c X for dynamic size,
* and where \c Type can be \c i for integer, \c f for float, \c d for double, \c cf for complex float, \c cd
* for complex double.
*
* For example, \c Array33d is a fixed-size 3x3 array type of doubles, and \c ArrayXXf is a dynamic-size matrix of floats.
*
* There are also \c ArraySizeType which are self-explanatory. For example, \c Array4cf is
* a fixed-size 1D array of 4 complex floats.
*
* \sa class Array
*/
#define EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix) \
/** \ingroup arraytypedefs */ \
typedef Array<Type, Size, Size> Array##SizeSuffix##SizeSuffix##TypeSuffix; \
/** \ingroup arraytypedefs */ \
typedef Array<Type, Size, 1> Array##SizeSuffix##TypeSuffix;
#define EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, Size) \
/** \ingroup arraytypedefs */ \
typedef Array<Type, Size, Dynamic> Array##Size##X##TypeSuffix; \
/** \ingroup arraytypedefs */ \
typedef Array<Type, Dynamic, Size> Array##X##Size##TypeSuffix;
#define EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \
EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 2, 2) \
EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 3, 3) \
EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 4, 4) \
EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, Dynamic, X) \
EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 2) \
EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 3) \
EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 4)
EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(int, i)
EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(float, f)
EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(double, d)
EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(std::complex<float>, cf)
EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(std::complex<double>, cd)
#undef EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES
#undef EIGEN_MAKE_ARRAY_TYPEDEFS
#undef EIGEN_MAKE_ARRAY_TYPEDEFS_LARGE
#define EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, SizeSuffix) \
using Eigen::Matrix##SizeSuffix##TypeSuffix; \
using Eigen::Vector##SizeSuffix##TypeSuffix; \
using Eigen::RowVector##SizeSuffix##TypeSuffix;
#define EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(TypeSuffix) \
EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 2) \
EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 3) \
EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 4) \
EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, X) \
#define EIGEN_USING_ARRAY_TYPEDEFS \
EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(i) \
EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(f) \
EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(d) \
EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(cf) \
EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(cd)
} // end namespace Eigen
#endif // EIGEN_ARRAY_H
data_process_class_dll/eigen-3.3.7/Eigen/src/Core/ArrayBase.h
-226
View File
@@ -1,226 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_ARRAYBASE_H
#define EIGEN_ARRAYBASE_H
namespace Eigen {
template<typename ExpressionType> class MatrixWrapper;
/** \class ArrayBase
* \ingroup Core_Module
*
* \brief Base class for all 1D and 2D array, and related expressions
*
* An array is similar to a dense vector or matrix. While matrices are mathematical
* objects with well defined linear algebra operators, an array is just a collection
* of scalar values arranged in a one or two dimensionnal fashion. As the main consequence,
* all operations applied to an array are performed coefficient wise. Furthermore,
* arrays support scalar math functions of the c++ standard library (e.g., std::sin(x)), and convenient
* constructors allowing to easily write generic code working for both scalar values
* and arrays.
*
* This class is the base that is inherited by all array expression types.
*
* \tparam Derived is the derived type, e.g., an array or an expression type.
*
* This class can be extended with the help of the plugin mechanism described on the page
* \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_ARRAYBASE_PLUGIN.
*
* \sa class MatrixBase, \ref TopicClassHierarchy
*/
template<typename Derived> class ArrayBase
: public DenseBase<Derived>
{
public:
#ifndef EIGEN_PARSED_BY_DOXYGEN
/** The base class for a given storage type. */
typedef ArrayBase StorageBaseType;
typedef ArrayBase Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl;
typedef typename internal::traits<Derived>::StorageKind StorageKind;
typedef typename internal::traits<Derived>::Scalar Scalar;
typedef typename internal::packet_traits<Scalar>::type PacketScalar;
typedef typename NumTraits<Scalar>::Real RealScalar;
typedef DenseBase<Derived> Base;
using Base::RowsAtCompileTime;
using Base::ColsAtCompileTime;
using Base::SizeAtCompileTime;
using Base::MaxRowsAtCompileTime;
using Base::MaxColsAtCompileTime;
using Base::MaxSizeAtCompileTime;
using Base::IsVectorAtCompileTime;
using Base::Flags;
using Base::derived;
using Base::const_cast_derived;
using Base::rows;
using Base::cols;
using Base::size;
using Base::coeff;
using Base::coeffRef;
using Base::lazyAssign;
using Base::operator=;
using Base::operator+=;
using Base::operator-=;
using Base::operator*=;
using Base::operator/=;
typedef typename Base::CoeffReturnType CoeffReturnType;
#endif // not EIGEN_PARSED_BY_DOXYGEN
#ifndef EIGEN_PARSED_BY_DOXYGEN
typedef typename Base::PlainObject PlainObject;
/** \internal Represents a matrix with all coefficients equal to one another*/
typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,PlainObject> ConstantReturnType;
#endif // not EIGEN_PARSED_BY_DOXYGEN
#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::ArrayBase
#define EIGEN_DOC_UNARY_ADDONS(X,Y)
# include "../plugins/CommonCwiseUnaryOps.h"
# include "../plugins/MatrixCwiseUnaryOps.h"
# include "../plugins/ArrayCwiseUnaryOps.h"
# include "../plugins/CommonCwiseBinaryOps.h"
# include "../plugins/MatrixCwiseBinaryOps.h"
# include "../plugins/ArrayCwiseBinaryOps.h"
# ifdef EIGEN_ARRAYBASE_PLUGIN
# include EIGEN_ARRAYBASE_PLUGIN
# endif
#undef EIGEN_CURRENT_STORAGE_BASE_CLASS
#undef EIGEN_DOC_UNARY_ADDONS
/** Special case of the template operator=, in order to prevent the compiler
* from generating a default operator= (issue hit with g++ 4.1)
*/
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
Derived& operator=(const ArrayBase& other)
{
internal::call_assignment(derived(), other.derived());
return derived();
}
/** Set all the entries to \a value.
* \sa DenseBase::setConstant(), DenseBase::fill() */
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
Derived& operator=(const Scalar &value)
{ Base::setConstant(value); return derived(); }
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
Derived& operator+=(const Scalar& scalar);
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
Derived& operator-=(const Scalar& scalar);
template<typename OtherDerived>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
Derived& operator+=(const ArrayBase<OtherDerived>& other);
template<typename OtherDerived>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
Derived& operator-=(const ArrayBase<OtherDerived>& other);
template<typename OtherDerived>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
Derived& operator*=(const ArrayBase<OtherDerived>& other);
template<typename OtherDerived>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
Derived& operator/=(const ArrayBase<OtherDerived>& other);
public:
EIGEN_DEVICE_FUNC
ArrayBase<Derived>& array() { return *this; }
EIGEN_DEVICE_FUNC
const ArrayBase<Derived>& array() const { return *this; }
/** \returns an \link Eigen::MatrixBase Matrix \endlink expression of this array
* \sa MatrixBase::array() */
EIGEN_DEVICE_FUNC
MatrixWrapper<Derived> matrix() { return MatrixWrapper<Derived>(derived()); }
EIGEN_DEVICE_FUNC
const MatrixWrapper<const Derived> matrix() const { return MatrixWrapper<const Derived>(derived()); }
// template<typename Dest>
// inline void evalTo(Dest& dst) const { dst = matrix(); }
protected:
EIGEN_DEVICE_FUNC
ArrayBase() : Base() {}
private:
explicit ArrayBase(Index);
ArrayBase(Index,Index);
template<typename OtherDerived> explicit ArrayBase(const ArrayBase<OtherDerived>&);
protected:
// mixing arrays and matrices is not legal
template<typename OtherDerived> Derived& operator+=(const MatrixBase<OtherDerived>& )
{EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
// mixing arrays and matrices is not legal
template<typename OtherDerived> Derived& operator-=(const MatrixBase<OtherDerived>& )
{EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
};
/** replaces \c *this by \c *this - \a other.
*
* \returns a reference to \c *this
*/
template<typename Derived>
template<typename OtherDerived>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
ArrayBase<Derived>::operator-=(const ArrayBase<OtherDerived> &other)
{
call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
return derived();
}
/** replaces \c *this by \c *this + \a other.
*
* \returns a reference to \c *this
*/
template<typename Derived>
template<typename OtherDerived>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
ArrayBase<Derived>::operator+=(const ArrayBase<OtherDerived>& other)
{
call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
return derived();
}
/** replaces \c *this by \c *this * \a other coefficient wise.
*
* \returns a reference to \c *this
*/
template<typename Derived>
template<typename OtherDerived>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
ArrayBase<Derived>::operator*=(const ArrayBase<OtherDerived>& other)
{
call_assignment(derived(), other.derived(), internal::mul_assign_op<Scalar,typename OtherDerived::Scalar>());
return derived();
}
/** replaces \c *this by \c *this / \a other coefficient wise.
*
* \returns a reference to \c *this
*/
template<typename Derived>
template<typename OtherDerived>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
ArrayBase<Derived>::operator/=(const ArrayBase<OtherDerived>& other)
{
call_assignment(derived(), other.derived(), internal::div_assign_op<Scalar,typename OtherDerived::Scalar>());
return derived();
}
} // end namespace Eigen
#endif // EIGEN_ARRAYBASE_H
data_process_class_dll/eigen-3.3.7/Eigen/src/Core/ArrayWrapper.h
-209
View File
@@ -1,209 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_ARRAYWRAPPER_H
#define EIGEN_ARRAYWRAPPER_H
namespace Eigen {
/** \class ArrayWrapper
* \ingroup Core_Module
*
* \brief Expression of a mathematical vector or matrix as an array object
*
* This class is the return type of MatrixBase::array(), and most of the time
* this is the only way it is use.
*
* \sa MatrixBase::array(), class MatrixWrapper
*/
namespace internal {
template<typename ExpressionType>
struct traits<ArrayWrapper<ExpressionType> >
: public traits<typename remove_all<typename ExpressionType::Nested>::type >
{
typedef ArrayXpr XprKind;
// Let's remove NestByRefBit
enum {
Flags0 = traits<typename remove_all<typename ExpressionType::Nested>::type >::Flags,
LvalueBitFlag = is_lvalue<ExpressionType>::value ? LvalueBit : 0,
Flags = (Flags0 & ~(NestByRefBit | LvalueBit)) | LvalueBitFlag
};
};
}
template<typename ExpressionType>
class ArrayWrapper : public ArrayBase<ArrayWrapper<ExpressionType> >
{
public:
typedef ArrayBase<ArrayWrapper> Base;
EIGEN_DENSE_PUBLIC_INTERFACE(ArrayWrapper)
EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ArrayWrapper)
typedef typename internal::remove_all<ExpressionType>::type NestedExpression;
typedef typename internal::conditional<
internal::is_lvalue<ExpressionType>::value,
Scalar,
const Scalar
>::type ScalarWithConstIfNotLvalue;
typedef typename internal::ref_selector<ExpressionType>::non_const_type NestedExpressionType;
using Base::coeffRef;
EIGEN_DEVICE_FUNC
explicit EIGEN_STRONG_INLINE ArrayWrapper(ExpressionType& matrix) : m_expression(matrix) {}
EIGEN_DEVICE_FUNC
inline Index rows() const { return m_expression.rows(); }
EIGEN_DEVICE_FUNC
inline Index cols() const { return m_expression.cols(); }
EIGEN_DEVICE_FUNC
inline Index outerStride() const { return m_expression.outerStride(); }
EIGEN_DEVICE_FUNC
inline Index innerStride() const { return m_expression.innerStride(); }
EIGEN_DEVICE_FUNC
inline ScalarWithConstIfNotLvalue* data() { return m_expression.data(); }
EIGEN_DEVICE_FUNC
inline const Scalar* data() const { return m_expression.data(); }
EIGEN_DEVICE_FUNC
inline const Scalar& coeffRef(Index rowId, Index colId) const
{
return m_expression.coeffRef(rowId, colId);
}
EIGEN_DEVICE_FUNC
inline const Scalar& coeffRef(Index index) const
{
return m_expression.coeffRef(index);
}
template<typename Dest>
EIGEN_DEVICE_FUNC
inline void evalTo(Dest& dst) const { dst = m_expression; }
const typename internal::remove_all<NestedExpressionType>::type&
EIGEN_DEVICE_FUNC
nestedExpression() const
{
return m_expression;
}
/** Forwards the resizing request to the nested expression
* \sa DenseBase::resize(Index) */
EIGEN_DEVICE_FUNC
void resize(Index newSize) { m_expression.resize(newSize); }
/** Forwards the resizing request to the nested expression
* \sa DenseBase::resize(Index,Index)*/
EIGEN_DEVICE_FUNC
void resize(Index rows, Index cols) { m_expression.resize(rows,cols); }
protected:
NestedExpressionType m_expression;
};
/** \class MatrixWrapper
* \ingroup Core_Module
*
* \brief Expression of an array as a mathematical vector or matrix
*
* This class is the return type of ArrayBase::matrix(), and most of the time
* this is the only way it is use.
*
* \sa MatrixBase::matrix(), class ArrayWrapper
*/
namespace internal {
template<typename ExpressionType>
struct traits<MatrixWrapper<ExpressionType> >
: public traits<typename remove_all<typename ExpressionType::Nested>::type >
{
typedef MatrixXpr XprKind;
// Let's remove NestByRefBit
enum {
Flags0 = traits<typename remove_all<typename ExpressionType::Nested>::type >::Flags,
LvalueBitFlag = is_lvalue<ExpressionType>::value ? LvalueBit : 0,
Flags = (Flags0 & ~(NestByRefBit | LvalueBit)) | LvalueBitFlag
};
};
}
template<typename ExpressionType>
class MatrixWrapper : public MatrixBase<MatrixWrapper<ExpressionType> >
{
public:
typedef MatrixBase<MatrixWrapper<ExpressionType> > Base;
EIGEN_DENSE_PUBLIC_INTERFACE(MatrixWrapper)
EIGEN_INHERIT_ASSIGNMENT_OPERATORS(MatrixWrapper)
typedef typename internal::remove_all<ExpressionType>::type NestedExpression;
typedef typename internal::conditional<
internal::is_lvalue<ExpressionType>::value,
Scalar,
const Scalar
>::type ScalarWithConstIfNotLvalue;
typedef typename internal::ref_selector<ExpressionType>::non_const_type NestedExpressionType;
using Base::coeffRef;
EIGEN_DEVICE_FUNC
explicit inline MatrixWrapper(ExpressionType& matrix) : m_expression(matrix) {}
EIGEN_DEVICE_FUNC
inline Index rows() const { return m_expression.rows(); }
EIGEN_DEVICE_FUNC
inline Index cols() const { return m_expression.cols(); }
EIGEN_DEVICE_FUNC
inline Index outerStride() const { return m_expression.outerStride(); }
EIGEN_DEVICE_FUNC
inline Index innerStride() const { return m_expression.innerStride(); }
EIGEN_DEVICE_FUNC
inline ScalarWithConstIfNotLvalue* data() { return m_expression.data(); }
EIGEN_DEVICE_FUNC
inline const Scalar* data() const { return m_expression.data(); }
EIGEN_DEVICE_FUNC
inline const Scalar& coeffRef(Index rowId, Index colId) const
{
return m_expression.derived().coeffRef(rowId, colId);
}
EIGEN_DEVICE_FUNC
inline const Scalar& coeffRef(Index index) const
{
return m_expression.coeffRef(index);
}
EIGEN_DEVICE_FUNC
const typename internal::remove_all<NestedExpressionType>::type&
nestedExpression() const
{
return m_expression;
}
/** Forwards the resizing request to the nested expression
* \sa DenseBase::resize(Index) */
EIGEN_DEVICE_FUNC
void resize(Index newSize) { m_expression.resize(newSize); }
/** Forwards the resizing request to the nested expression
* \sa DenseBase::resize(Index,Index)*/
EIGEN_DEVICE_FUNC
void resize(Index rows, Index cols) { m_expression.resize(rows,cols); }
protected:
NestedExpressionType m_expression;
};
} // end namespace Eigen
#endif // EIGEN_ARRAYWRAPPER_H
data_process_class_dll/eigen-3.3.7/Eigen/src/Core/Assign.h
-90
View File
@@ -1,90 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2007 Michael Olbrich <michael.olbrich@gmx.net>
// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_ASSIGN_H
#define EIGEN_ASSIGN_H
namespace Eigen {
template<typename Derived>
template<typename OtherDerived>
EIGEN_STRONG_INLINE Derived& DenseBase<Derived>
::lazyAssign(const DenseBase<OtherDerived>& other)
{
enum{
SameType = internal::is_same<typename Derived::Scalar,typename OtherDerived::Scalar>::value
};
EIGEN_STATIC_ASSERT_LVALUE(Derived)
EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived,OtherDerived)
EIGEN_STATIC_ASSERT(SameType,YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
eigen_assert(rows() == other.rows() && cols() == other.cols());
internal::call_assignment_no_alias(derived(),other.derived());
return derived();
}
template<typename Derived>
template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator=(const DenseBase<OtherDerived>& other)
{
internal::call_assignment(derived(), other.derived());
return derived();
}
template<typename Derived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator=(const DenseBase& other)
{
internal::call_assignment(derived(), other.derived());
return derived();
}
template<typename Derived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const MatrixBase& other)
{
internal::call_assignment(derived(), other.derived());
return derived();
}
template<typename Derived>
template <typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const DenseBase<OtherDerived>& other)
{
internal::call_assignment(derived(), other.derived());
return derived();
}
template<typename Derived>
template <typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const EigenBase<OtherDerived>& other)
{
internal::call_assignment(derived(), other.derived());
return derived();
}
template<typename Derived>
template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const ReturnByValue<OtherDerived>& other)
{
other.derived().evalTo(derived());
return derived();
}
} // end namespace Eigen
#endif // EIGEN_ASSIGN_H
data_process_class_dll/eigen-3.3.7/Eigen/src/Core/AssignEvaluator.h
-935
View File
@@ -1,935 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2011 Benoit Jacob <jacob.benoit.1@gmail.com>
// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2011-2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_ASSIGN_EVALUATOR_H
#define EIGEN_ASSIGN_EVALUATOR_H
namespace Eigen {
// This implementation is based on Assign.h
namespace internal {
/***************************************************************************
* Part 1 : the logic deciding a strategy for traversal and unrolling *
***************************************************************************/
// copy_using_evaluator_traits is based on assign_traits
template <typename DstEvaluator, typename SrcEvaluator, typename AssignFunc>
struct copy_using_evaluator_traits
{
typedef typename DstEvaluator::XprType Dst;
typedef typename Dst::Scalar DstScalar;
enum {
DstFlags = DstEvaluator::Flags,
SrcFlags = SrcEvaluator::Flags
};
public:
enum {
DstAlignment = DstEvaluator::Alignment,
SrcAlignment = SrcEvaluator::Alignment,
DstHasDirectAccess = (DstFlags & DirectAccessBit) == DirectAccessBit,
JointAlignment = EIGEN_PLAIN_ENUM_MIN(DstAlignment,SrcAlignment)
};
private:
enum {
InnerSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::SizeAtCompileTime)
: int(DstFlags)&RowMajorBit ? int(Dst::ColsAtCompileTime)
: int(Dst::RowsAtCompileTime),
InnerMaxSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::MaxSizeAtCompileTime)
: int(DstFlags)&RowMajorBit ? int(Dst::MaxColsAtCompileTime)
: int(Dst::MaxRowsAtCompileTime),
OuterStride = int(outer_stride_at_compile_time<Dst>::ret),
MaxSizeAtCompileTime = Dst::SizeAtCompileTime
};
// TODO distinguish between linear traversal and inner-traversals
typedef typename find_best_packet<DstScalar,Dst::SizeAtCompileTime>::type LinearPacketType;
typedef typename find_best_packet<DstScalar,InnerSize>::type InnerPacketType;
enum {
LinearPacketSize = unpacket_traits<LinearPacketType>::size,
InnerPacketSize = unpacket_traits<InnerPacketType>::size
};
public:
enum {
LinearRequiredAlignment = unpacket_traits<LinearPacketType>::alignment,
InnerRequiredAlignment = unpacket_traits<InnerPacketType>::alignment
};
private:
enum {
DstIsRowMajor = DstFlags&RowMajorBit,
SrcIsRowMajor = SrcFlags&RowMajorBit,
StorageOrdersAgree = (int(DstIsRowMajor) == int(SrcIsRowMajor)),
MightVectorize = bool(StorageOrdersAgree)
&& (int(DstFlags) & int(SrcFlags) & ActualPacketAccessBit)
&& bool(functor_traits<AssignFunc>::PacketAccess),
MayInnerVectorize = MightVectorize
&& int(InnerSize)!=Dynamic && int(InnerSize)%int(InnerPacketSize)==0
&& int(OuterStride)!=Dynamic && int(OuterStride)%int(InnerPacketSize)==0
&& (EIGEN_UNALIGNED_VECTORIZE || int(JointAlignment)>=int(InnerRequiredAlignment)),
MayLinearize = bool(StorageOrdersAgree) && (int(DstFlags) & int(SrcFlags) & LinearAccessBit),
MayLinearVectorize = bool(MightVectorize) && bool(MayLinearize) && bool(DstHasDirectAccess)
&& (EIGEN_UNALIGNED_VECTORIZE || (int(DstAlignment)>=int(LinearRequiredAlignment)) || MaxSizeAtCompileTime == Dynamic),
/* If the destination isn't aligned, we have to do runtime checks and we don't unroll,
so it's only good for large enough sizes. */
MaySliceVectorize = bool(MightVectorize) && bool(DstHasDirectAccess)
&& (int(InnerMaxSize)==Dynamic || int(InnerMaxSize)>=(EIGEN_UNALIGNED_VECTORIZE?InnerPacketSize:(3*InnerPacketSize)))
/* slice vectorization can be slow, so we only want it if the slices are big, which is
indicated by InnerMaxSize rather than InnerSize, think of the case of a dynamic block
in a fixed-size matrix
However, with EIGEN_UNALIGNED_VECTORIZE and unrolling, slice vectorization is still worth it */
};
public:
enum {
Traversal = int(MayLinearVectorize) && (LinearPacketSize>InnerPacketSize) ? int(LinearVectorizedTraversal)
: int(MayInnerVectorize) ? int(InnerVectorizedTraversal)
: int(MayLinearVectorize) ? int(LinearVectorizedTraversal)
: int(MaySliceVectorize) ? int(SliceVectorizedTraversal)
: int(MayLinearize) ? int(LinearTraversal)
: int(DefaultTraversal),
Vectorized = int(Traversal) == InnerVectorizedTraversal
|| int(Traversal) == LinearVectorizedTraversal
|| int(Traversal) == SliceVectorizedTraversal
};
typedef typename conditional<int(Traversal)==LinearVectorizedTraversal, LinearPacketType, InnerPacketType>::type PacketType;
private:
enum {
ActualPacketSize = int(Traversal)==LinearVectorizedTraversal ? LinearPacketSize
: Vectorized ? InnerPacketSize
: 1,
UnrollingLimit = EIGEN_UNROLLING_LIMIT * ActualPacketSize,
MayUnrollCompletely = int(Dst::SizeAtCompileTime) != Dynamic
&& int(Dst::SizeAtCompileTime) * (int(DstEvaluator::CoeffReadCost)+int(SrcEvaluator::CoeffReadCost)) <= int(UnrollingLimit),
MayUnrollInner = int(InnerSize) != Dynamic
&& int(InnerSize) * (int(DstEvaluator::CoeffReadCost)+int(SrcEvaluator::CoeffReadCost)) <= int(UnrollingLimit)
};
public:
enum {
Unrolling = (int(Traversal) == int(InnerVectorizedTraversal) || int(Traversal) == int(DefaultTraversal))
? (
int(MayUnrollCompletely) ? int(CompleteUnrolling)
: int(MayUnrollInner) ? int(InnerUnrolling)
: int(NoUnrolling)
)
: int(Traversal) == int(LinearVectorizedTraversal)
? ( bool(MayUnrollCompletely) && ( EIGEN_UNALIGNED_VECTORIZE || (int(DstAlignment)>=int(LinearRequiredAlignment)))
? int(CompleteUnrolling)
: int(NoUnrolling) )
: int(Traversal) == int(LinearTraversal)
? ( bool(MayUnrollCompletely) ? int(CompleteUnrolling)
: int(NoUnrolling) )
#if EIGEN_UNALIGNED_VECTORIZE
: int(Traversal) == int(SliceVectorizedTraversal)
? ( bool(MayUnrollInner) ? int(InnerUnrolling)
: int(NoUnrolling) )
#endif
: int(NoUnrolling)
};
#ifdef EIGEN_DEBUG_ASSIGN
static void debug()
{
std::cerr << "DstXpr: " << typeid(typename DstEvaluator::XprType).name() << std::endl;
std::cerr << "SrcXpr: " << typeid(typename SrcEvaluator::XprType).name() << std::endl;
std::cerr.setf(std::ios::hex, std::ios::basefield);
std::cerr << "DstFlags" << " = " << DstFlags << " (" << demangle_flags(DstFlags) << " )" << std::endl;
std::cerr << "SrcFlags" << " = " << SrcFlags << " (" << demangle_flags(SrcFlags) << " )" << std::endl;
std::cerr.unsetf(std::ios::hex);
EIGEN_DEBUG_VAR(DstAlignment)
EIGEN_DEBUG_VAR(SrcAlignment)
EIGEN_DEBUG_VAR(LinearRequiredAlignment)
EIGEN_DEBUG_VAR(InnerRequiredAlignment)
EIGEN_DEBUG_VAR(JointAlignment)
EIGEN_DEBUG_VAR(InnerSize)
EIGEN_DEBUG_VAR(InnerMaxSize)
EIGEN_DEBUG_VAR(LinearPacketSize)
EIGEN_DEBUG_VAR(InnerPacketSize)
EIGEN_DEBUG_VAR(ActualPacketSize)
EIGEN_DEBUG_VAR(StorageOrdersAgree)
EIGEN_DEBUG_VAR(MightVectorize)
EIGEN_DEBUG_VAR(MayLinearize)
EIGEN_DEBUG_VAR(MayInnerVectorize)
EIGEN_DEBUG_VAR(MayLinearVectorize)
EIGEN_DEBUG_VAR(MaySliceVectorize)
std::cerr << "Traversal" << " = " << Traversal << " (" << demangle_traversal(Traversal) << ")" << std::endl;
EIGEN_DEBUG_VAR(SrcEvaluator::CoeffReadCost)
EIGEN_DEBUG_VAR(UnrollingLimit)
EIGEN_DEBUG_VAR(MayUnrollCompletely)
EIGEN_DEBUG_VAR(MayUnrollInner)
std::cerr << "Unrolling" << " = " << Unrolling << " (" << demangle_unrolling(Unrolling) << ")" << std::endl;
std::cerr << std::endl;
}
#endif
};
/***************************************************************************
* Part 2 : meta-unrollers
***************************************************************************/
/************************
*** Default traversal ***
************************/
template<typename Kernel, int Index, int Stop>
struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling
{
// FIXME: this is not very clean, perhaps this information should be provided by the kernel?
typedef typename Kernel::DstEvaluatorType DstEvaluatorType;
typedef typename DstEvaluatorType::XprType DstXprType;
enum {
outer = Index / DstXprType::InnerSizeAtCompileTime,
inner = Index % DstXprType::InnerSizeAtCompileTime
};
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
kernel.assignCoeffByOuterInner(outer, inner);
copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, Index+1, Stop>::run(kernel);
}
};
template<typename Kernel, int Stop>
struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, Stop, Stop>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&) { }
};
template<typename Kernel, int Index_, int Stop>
struct copy_using_evaluator_DefaultTraversal_InnerUnrolling
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel, Index outer)
{
kernel.assignCoeffByOuterInner(outer, Index_);
copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, Index_+1, Stop>::run(kernel, outer);
}
};
template<typename Kernel, int Stop>
struct copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, Stop, Stop>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&, Index) { }
};
/***********************
*** Linear traversal ***
***********************/
template<typename Kernel, int Index, int Stop>
struct copy_using_evaluator_LinearTraversal_CompleteUnrolling
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel& kernel)
{
kernel.assignCoeff(Index);
copy_using_evaluator_LinearTraversal_CompleteUnrolling<Kernel, Index+1, Stop>::run(kernel);
}
};
template<typename Kernel, int Stop>
struct copy_using_evaluator_LinearTraversal_CompleteUnrolling<Kernel, Stop, Stop>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&) { }
};
/**************************
*** Inner vectorization ***
**************************/
template<typename Kernel, int Index, int Stop>
struct copy_using_evaluator_innervec_CompleteUnrolling
{
// FIXME: this is not very clean, perhaps this information should be provided by the kernel?
typedef typename Kernel::DstEvaluatorType DstEvaluatorType;
typedef typename DstEvaluatorType::XprType DstXprType;
typedef typename Kernel::PacketType PacketType;
enum {
outer = Index / DstXprType::InnerSizeAtCompileTime,
inner = Index % DstXprType::InnerSizeAtCompileTime,
SrcAlignment = Kernel::AssignmentTraits::SrcAlignment,
DstAlignment = Kernel::AssignmentTraits::DstAlignment
};
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(outer, inner);
enum { NextIndex = Index + unpacket_traits<PacketType>::size };
copy_using_evaluator_innervec_CompleteUnrolling<Kernel, NextIndex, Stop>::run(kernel);
}
};
template<typename Kernel, int Stop>
struct copy_using_evaluator_innervec_CompleteUnrolling<Kernel, Stop, Stop>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&) { }
};
template<typename Kernel, int Index_, int Stop, int SrcAlignment, int DstAlignment>
struct copy_using_evaluator_innervec_InnerUnrolling
{
typedef typename Kernel::PacketType PacketType;
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel, Index outer)
{
kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(outer, Index_);
enum { NextIndex = Index_ + unpacket_traits<PacketType>::size };
copy_using_evaluator_innervec_InnerUnrolling<Kernel, NextIndex, Stop, SrcAlignment, DstAlignment>::run(kernel, outer);
}
};
template<typename Kernel, int Stop, int SrcAlignment, int DstAlignment>
struct copy_using_evaluator_innervec_InnerUnrolling<Kernel, Stop, Stop, SrcAlignment, DstAlignment>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &, Index) { }
};
/***************************************************************************
* Part 3 : implementation of all cases
***************************************************************************/
// dense_assignment_loop is based on assign_impl
template<typename Kernel,
int Traversal = Kernel::AssignmentTraits::Traversal,
int Unrolling = Kernel::AssignmentTraits::Unrolling>
struct dense_assignment_loop;
/************************
*** Default traversal ***
************************/
template<typename Kernel>
struct dense_assignment_loop<Kernel, DefaultTraversal, NoUnrolling>
{
EIGEN_DEVICE_FUNC static void EIGEN_STRONG_INLINE run(Kernel &kernel)
{
for(Index outer = 0; outer < kernel.outerSize(); ++outer) {
for(Index inner = 0; inner < kernel.innerSize(); ++inner) {
kernel.assignCoeffByOuterInner(outer, inner);
}
}
}
};
template<typename Kernel>
struct dense_assignment_loop<Kernel, DefaultTraversal, CompleteUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, 0, DstXprType::SizeAtCompileTime>::run(kernel);
}
};
template<typename Kernel>
struct dense_assignment_loop<Kernel, DefaultTraversal, InnerUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
const Index outerSize = kernel.outerSize();
for(Index outer = 0; outer < outerSize; ++outer)
copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, 0, DstXprType::InnerSizeAtCompileTime>::run(kernel, outer);
}
};
/***************************
*** Linear vectorization ***
***************************/
// The goal of unaligned_dense_assignment_loop is simply to factorize the handling
// of the non vectorizable beginning and ending parts
template <bool IsAligned = false>
struct unaligned_dense_assignment_loop
{
// if IsAligned = true, then do nothing
template <typename Kernel>
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&, Index, Index) {}
};
template <>
struct unaligned_dense_assignment_loop<false>
{
// MSVC must not inline this functions. If it does, it fails to optimize the
// packet access path.
// FIXME check which version exhibits this issue
#if EIGEN_COMP_MSVC
template <typename Kernel>
static EIGEN_DONT_INLINE void run(Kernel &kernel,
Index start,
Index end)
#else
template <typename Kernel>
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel,
Index start,
Index end)
#endif
{
for (Index index = start; index < end; ++index)
kernel.assignCoeff(index);
}
};
template<typename Kernel>
struct dense_assignment_loop<Kernel, LinearVectorizedTraversal, NoUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
const Index size = kernel.size();
typedef typename Kernel::Scalar Scalar;
typedef typename Kernel::PacketType PacketType;
enum {
requestedAlignment = Kernel::AssignmentTraits::LinearRequiredAlignment,
packetSize = unpacket_traits<PacketType>::size,
dstIsAligned = int(Kernel::AssignmentTraits::DstAlignment)>=int(requestedAlignment),
dstAlignment = packet_traits<Scalar>::AlignedOnScalar ? int(requestedAlignment)
: int(Kernel::AssignmentTraits::DstAlignment),
srcAlignment = Kernel::AssignmentTraits::JointAlignment
};
const Index alignedStart = dstIsAligned ? 0 : internal::first_aligned<requestedAlignment>(kernel.dstDataPtr(), size);
const Index alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize;
unaligned_dense_assignment_loop<dstIsAligned!=0>::run(kernel, 0, alignedStart);
for(Index index = alignedStart; index < alignedEnd; index += packetSize)
kernel.template assignPacket<dstAlignment, srcAlignment, PacketType>(index);
unaligned_dense_assignment_loop<>::run(kernel, alignedEnd, size);
}
};
template<typename Kernel>
struct dense_assignment_loop<Kernel, LinearVectorizedTraversal, CompleteUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
typedef typename Kernel::PacketType PacketType;
enum { size = DstXprType::SizeAtCompileTime,
packetSize =unpacket_traits<PacketType>::size,
alignedSize = (size/packetSize)*packetSize };
copy_using_evaluator_innervec_CompleteUnrolling<Kernel, 0, alignedSize>::run(kernel);
copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, alignedSize, size>::run(kernel);
}
};
/**************************
*** Inner vectorization ***
**************************/
template<typename Kernel>
struct dense_assignment_loop<Kernel, InnerVectorizedTraversal, NoUnrolling>
{
typedef typename Kernel::PacketType PacketType;
enum {
SrcAlignment = Kernel::AssignmentTraits::SrcAlignment,
DstAlignment = Kernel::AssignmentTraits::DstAlignment
};
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
const Index innerSize = kernel.innerSize();
const Index outerSize = kernel.outerSize();
const Index packetSize = unpacket_traits<PacketType>::size;
for(Index outer = 0; outer < outerSize; ++outer)
for(Index inner = 0; inner < innerSize; inner+=packetSize)
kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(outer, inner);
}
};
template<typename Kernel>
struct dense_assignment_loop<Kernel, InnerVectorizedTraversal, CompleteUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
copy_using_evaluator_innervec_CompleteUnrolling<Kernel, 0, DstXprType::SizeAtCompileTime>::run(kernel);
}
};
template<typename Kernel>
struct dense_assignment_loop<Kernel, InnerVectorizedTraversal, InnerUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
typedef typename Kernel::AssignmentTraits Traits;
const Index outerSize = kernel.outerSize();
for(Index outer = 0; outer < outerSize; ++outer)
copy_using_evaluator_innervec_InnerUnrolling<Kernel, 0, DstXprType::InnerSizeAtCompileTime,
Traits::SrcAlignment, Traits::DstAlignment>::run(kernel, outer);
}
};
/***********************
*** Linear traversal ***
***********************/
template<typename Kernel>
struct dense_assignment_loop<Kernel, LinearTraversal, NoUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
const Index size = kernel.size();
for(Index i = 0; i < size; ++i)
kernel.assignCoeff(i);
}
};
template<typename Kernel>
struct dense_assignment_loop<Kernel, LinearTraversal, CompleteUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
copy_using_evaluator_LinearTraversal_CompleteUnrolling<Kernel, 0, DstXprType::SizeAtCompileTime>::run(kernel);
}
};
/**************************
*** Slice vectorization ***
***************************/
template<typename Kernel>
struct dense_assignment_loop<Kernel, SliceVectorizedTraversal, NoUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
typedef typename Kernel::Scalar Scalar;
typedef typename Kernel::PacketType PacketType;
enum {
packetSize = unpacket_traits<PacketType>::size,
requestedAlignment = int(Kernel::AssignmentTraits::InnerRequiredAlignment),
alignable = packet_traits<Scalar>::AlignedOnScalar || int(Kernel::AssignmentTraits::DstAlignment)>=sizeof(Scalar),
dstIsAligned = int(Kernel::AssignmentTraits::DstAlignment)>=int(requestedAlignment),
dstAlignment = alignable ? int(requestedAlignment)
: int(Kernel::AssignmentTraits::DstAlignment)
};
const Scalar *dst_ptr = kernel.dstDataPtr();
if((!bool(dstIsAligned)) && (UIntPtr(dst_ptr) % sizeof(Scalar))>0)
{
// the pointer is not aligend-on scalar, so alignment is not possible
return dense_assignment_loop<Kernel,DefaultTraversal,NoUnrolling>::run(kernel);
}
const Index packetAlignedMask = packetSize - 1;
const Index innerSize = kernel.innerSize();
const Index outerSize = kernel.outerSize();
const Index alignedStep = alignable ? (packetSize - kernel.outerStride() % packetSize) & packetAlignedMask : 0;
Index alignedStart = ((!alignable) || bool(dstIsAligned)) ? 0 : internal::first_aligned<requestedAlignment>(dst_ptr, innerSize);
for(Index outer = 0; outer < outerSize; ++outer)
{
const Index alignedEnd = alignedStart + ((innerSize-alignedStart) & ~packetAlignedMask);
// do the non-vectorizable part of the assignment
for(Index inner = 0; inner<alignedStart ; ++inner)
kernel.assignCoeffByOuterInner(outer, inner);
// do the vectorizable part of the assignment
for(Index inner = alignedStart; inner<alignedEnd; inner+=packetSize)
kernel.template assignPacketByOuterInner<dstAlignment, Unaligned, PacketType>(outer, inner);
// do the non-vectorizable part of the assignment
for(Index inner = alignedEnd; inner<innerSize ; ++inner)
kernel.assignCoeffByOuterInner(outer, inner);
alignedStart = numext::mini((alignedStart+alignedStep)%packetSize, innerSize);
}
}
};
#if EIGEN_UNALIGNED_VECTORIZE
template<typename Kernel>
struct dense_assignment_loop<Kernel, SliceVectorizedTraversal, InnerUnrolling>
{
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
{
typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
typedef typename Kernel::PacketType PacketType;
enum { size = DstXprType::InnerSizeAtCompileTime,
packetSize =unpacket_traits<PacketType>::size,
vectorizableSize = (size/packetSize)*packetSize };
for(Index outer = 0; outer < kernel.outerSize(); ++outer)
{
copy_using_evaluator_innervec_InnerUnrolling<Kernel, 0, vectorizableSize, 0, 0>::run(kernel, outer);
copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, vectorizableSize, size>::run(kernel, outer);
}
}
};
#endif
/***************************************************************************
* Part 4 : Generic dense assignment kernel
***************************************************************************/
// This class generalize the assignment of a coefficient (or packet) from one dense evaluator
// to another dense writable evaluator.
// It is parametrized by the two evaluators, and the actual assignment functor.
// This abstraction level permits to keep the evaluation loops as simple and as generic as possible.
// One can customize the assignment using this generic dense_assignment_kernel with different
// functors, or by completely overloading it, by-passing a functor.
template<typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor, int Version = Specialized>
class generic_dense_assignment_kernel
{
protected:
typedef typename DstEvaluatorTypeT::XprType DstXprType;
typedef typename SrcEvaluatorTypeT::XprType SrcXprType;
public:
typedef DstEvaluatorTypeT DstEvaluatorType;
typedef SrcEvaluatorTypeT SrcEvaluatorType;
typedef typename DstEvaluatorType::Scalar Scalar;
typedef copy_using_evaluator_traits<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor> AssignmentTraits;
typedef typename AssignmentTraits::PacketType PacketType;
EIGEN_DEVICE_FUNC generic_dense_assignment_kernel(DstEvaluatorType &dst, const SrcEvaluatorType &src, const Functor &func, DstXprType& dstExpr)
: m_dst(dst), m_src(src), m_functor(func), m_dstExpr(dstExpr)
{
#ifdef EIGEN_DEBUG_ASSIGN
AssignmentTraits::debug();
#endif
}
EIGEN_DEVICE_FUNC Index size() const { return m_dstExpr.size(); }
EIGEN_DEVICE_FUNC Index innerSize() const { return m_dstExpr.innerSize(); }
EIGEN_DEVICE_FUNC Index outerSize() const { return m_dstExpr.outerSize(); }
EIGEN_DEVICE_FUNC Index rows() const { return m_dstExpr.rows(); }
EIGEN_DEVICE_FUNC Index cols() const { return m_dstExpr.cols(); }
EIGEN_DEVICE_FUNC Index outerStride() const { return m_dstExpr.outerStride(); }
EIGEN_DEVICE_FUNC DstEvaluatorType& dstEvaluator() { return m_dst; }
EIGEN_DEVICE_FUNC const SrcEvaluatorType& srcEvaluator() const { return m_src; }
/// Assign src(row,col) to dst(row,col) through the assignment functor.
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(Index row, Index col)
{
m_functor.assignCoeff(m_dst.coeffRef(row,col), m_src.coeff(row,col));
}
/// \sa assignCoeff(Index,Index)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(Index index)
{
m_functor.assignCoeff(m_dst.coeffRef(index), m_src.coeff(index));
}
/// \sa assignCoeff(Index,Index)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeffByOuterInner(Index outer, Index inner)
{
Index row = rowIndexByOuterInner(outer, inner);
Index col = colIndexByOuterInner(outer, inner);
assignCoeff(row, col);
}
template<int StoreMode, int LoadMode, typename PacketType>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacket(Index row, Index col)
{
m_functor.template assignPacket<StoreMode>(&m_dst.coeffRef(row,col), m_src.template packet<LoadMode,PacketType>(row,col));
}
template<int StoreMode, int LoadMode, typename PacketType>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacket(Index index)
{
m_functor.template assignPacket<StoreMode>(&m_dst.coeffRef(index), m_src.template packet<LoadMode,PacketType>(index));
}
template<int StoreMode, int LoadMode, typename PacketType>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacketByOuterInner(Index outer, Index inner)
{
Index row = rowIndexByOuterInner(outer, inner);
Index col = colIndexByOuterInner(outer, inner);
assignPacket<StoreMode,LoadMode,PacketType>(row, col);
}
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index rowIndexByOuterInner(Index outer, Index inner)
{
typedef typename DstEvaluatorType::ExpressionTraits Traits;
return int(Traits::RowsAtCompileTime) == 1 ? 0
: int(Traits::ColsAtCompileTime) == 1 ? inner
: int(DstEvaluatorType::Flags)&RowMajorBit ? outer
: inner;
}
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index colIndexByOuterInner(Index outer, Index inner)
{
typedef typename DstEvaluatorType::ExpressionTraits Traits;
return int(Traits::ColsAtCompileTime) == 1 ? 0
: int(Traits::RowsAtCompileTime) == 1 ? inner
: int(DstEvaluatorType::Flags)&RowMajorBit ? inner
: outer;
}
EIGEN_DEVICE_FUNC const Scalar* dstDataPtr() const
{
return m_dstExpr.data();
}
protected:
DstEvaluatorType& m_dst;
const SrcEvaluatorType& m_src;
const Functor &m_functor;
// TODO find a way to avoid the needs of the original expression
DstXprType& m_dstExpr;
};
/***************************************************************************
* Part 5 : Entry point for dense rectangular assignment
***************************************************************************/
template<typename DstXprType,typename SrcXprType, typename Functor>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const Functor &/*func*/)
{
EIGEN_ONLY_USED_FOR_DEBUG(dst);
EIGEN_ONLY_USED_FOR_DEBUG(src);
eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
}
template<typename DstXprType,typename SrcXprType, typename T1, typename T2>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const internal::assign_op<T1,T2> &/*func*/)
{
Index dstRows = src.rows();
Index dstCols = src.cols();
if(((dst.rows()!=dstRows) || (dst.cols()!=dstCols)))
dst.resize(dstRows, dstCols);
eigen_assert(dst.rows() == dstRows && dst.cols() == dstCols);
}
template<typename DstXprType, typename SrcXprType, typename Functor>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
SrcEvaluatorType srcEvaluator(src);
// NOTE To properly handle A = (A*A.transpose())/s with A rectangular,
// we need to resize the destination after the source evaluator has been created.
resize_if_allowed(dst, src, func);
DstEvaluatorType dstEvaluator(dst);
typedef generic_dense_assignment_kernel<DstEvaluatorType,SrcEvaluatorType,Functor> Kernel;
Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
dense_assignment_loop<Kernel>::run(kernel);
}
template<typename DstXprType, typename SrcXprType>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src)
{
call_dense_assignment_loop(dst, src, internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>());
}
/***************************************************************************
* Part 6 : Generic assignment
***************************************************************************/
// Based on the respective shapes of the destination and source,
// the class AssignmentKind determine the kind of assignment mechanism.
// AssignmentKind must define a Kind typedef.
template<typename DstShape, typename SrcShape> struct AssignmentKind;
// Assignement kind defined in this file:
struct Dense2Dense {};
struct EigenBase2EigenBase {};
template<typename,typename> struct AssignmentKind { typedef EigenBase2EigenBase Kind; };
template<> struct AssignmentKind<DenseShape,DenseShape> { typedef Dense2Dense Kind; };
// This is the main assignment class
template< typename DstXprType, typename SrcXprType, typename Functor,
typename Kind = typename AssignmentKind< typename evaluator_traits<DstXprType>::Shape , typename evaluator_traits<SrcXprType>::Shape >::Kind,
typename EnableIf = void>
struct Assignment;
// The only purpose of this call_assignment() function is to deal with noalias() / "assume-aliasing" and automatic transposition.
// Indeed, I (Gael) think that this concept of "assume-aliasing" was a mistake, and it makes thing quite complicated.
// So this intermediate function removes everything related to "assume-aliasing" such that Assignment
// does not has to bother about these annoying details.
template<typename Dst, typename Src>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment(Dst& dst, const Src& src)
{
call_assignment(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
}
template<typename Dst, typename Src>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment(const Dst& dst, const Src& src)
{
call_assignment(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
}
// Deal with "assume-aliasing"
template<typename Dst, typename Src, typename Func>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if< evaluator_assume_aliasing<Src>::value, void*>::type = 0)
{
typename plain_matrix_type<Src>::type tmp(src);
call_assignment_no_alias(dst, tmp, func);
}
template<typename Dst, typename Src, typename Func>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if<!evaluator_assume_aliasing<Src>::value, void*>::type = 0)
{
call_assignment_no_alias(dst, src, func);
}
// by-pass "assume-aliasing"
// When there is no aliasing, we require that 'dst' has been properly resized
template<typename Dst, template <typename> class StorageBase, typename Src, typename Func>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment(NoAlias<Dst,StorageBase>& dst, const Src& src, const Func& func)
{
call_assignment_no_alias(dst.expression(), src, func);
}
template<typename Dst, typename Src, typename Func>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment_no_alias(Dst& dst, const Src& src, const Func& func)
{
enum {
NeedToTranspose = ( (int(Dst::RowsAtCompileTime) == 1 && int(Src::ColsAtCompileTime) == 1)
|| (int(Dst::ColsAtCompileTime) == 1 && int(Src::RowsAtCompileTime) == 1)
) && int(Dst::SizeAtCompileTime) != 1
};
typedef typename internal::conditional<NeedToTranspose, Transpose<Dst>, Dst>::type ActualDstTypeCleaned;
typedef typename internal::conditional<NeedToTranspose, Transpose<Dst>, Dst&>::type ActualDstType;
ActualDstType actualDst(dst);
// TODO check whether this is the right place to perform these checks:
EIGEN_STATIC_ASSERT_LVALUE(Dst)
EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(ActualDstTypeCleaned,Src)
EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename ActualDstTypeCleaned::Scalar,typename Src::Scalar);
Assignment<ActualDstTypeCleaned,Src,Func>::run(actualDst, src, func);
}
template<typename Dst, typename Src>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment_no_alias(Dst& dst, const Src& src)
{
call_assignment_no_alias(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
}
template<typename Dst, typename Src, typename Func>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src, const Func& func)
{
// TODO check whether this is the right place to perform these checks:
EIGEN_STATIC_ASSERT_LVALUE(Dst)
EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Dst,Src)
EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename Dst::Scalar,typename Src::Scalar);
Assignment<Dst,Src,Func>::run(dst, src, func);
}
template<typename Dst, typename Src>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src)
{
call_assignment_no_alias_no_transpose(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
}
// forward declaration
template<typename Dst, typename Src> void check_for_aliasing(const Dst &dst, const Src &src);
// Generic Dense to Dense assignment
// Note that the last template argument "Weak" is needed to make it possible to perform
// both partial specialization+SFINAE without ambiguous specialization
template< typename DstXprType, typename SrcXprType, typename Functor, typename Weak>
struct Assignment<DstXprType, SrcXprType, Functor, Dense2Dense, Weak>
{
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
{
#ifndef EIGEN_NO_DEBUG
internal::check_for_aliasing(dst, src);
#endif
call_dense_assignment_loop(dst, src, func);
}
};
// Generic assignment through evalTo.
// TODO: not sure we have to keep that one, but it helps porting current code to new evaluator mechanism.
// Note that the last template argument "Weak" is needed to make it possible to perform
// both partial specialization+SFINAE without ambiguous specialization
template< typename DstXprType, typename SrcXprType, typename Functor, typename Weak>
struct Assignment<DstXprType, SrcXprType, Functor, EigenBase2EigenBase, Weak>
{
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
{
Index dstRows = src.rows();
Index dstCols = src.cols();
if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
dst.resize(dstRows, dstCols);
eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
src.evalTo(dst);
}
// NOTE The following two functions are templated to avoid their instanciation if not needed
// This is needed because some expressions supports evalTo only and/or have 'void' as scalar type.
template<typename SrcScalarType>
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,SrcScalarType> &/*func*/)
{
Index dstRows = src.rows();
Index dstCols = src.cols();
if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
dst.resize(dstRows, dstCols);
eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
src.addTo(dst);
}
template<typename SrcScalarType>
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,SrcScalarType> &/*func*/)
{
Index dstRows = src.rows();
Index dstCols = src.cols();
if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
dst.resize(dstRows, dstCols);
eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
src.subTo(dst);
}
};
} // namespace internal
} // end namespace Eigen
#endif // EIGEN_ASSIGN_EVALUATOR_H
data_process_class_dll/eigen-3.3.7/Eigen/src/Core/Assign_MKL.h
-178
View File
@@ -1,178 +0,0 @@
/*
Copyright (c) 2011, Intel Corporation. All rights reserved.
Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of Intel Corporation nor the names of its contributors may
be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
********************************************************************************
* Content : Eigen bindings to Intel(R) MKL
* MKL VML support for coefficient-wise unary Eigen expressions like a=b.sin()
********************************************************************************
*/
#ifndef EIGEN_ASSIGN_VML_H
#define EIGEN_ASSIGN_VML_H
namespace Eigen {
namespace internal {
template<typename Dst, typename Src>
class vml_assign_traits
{
private:
enum {
DstHasDirectAccess = Dst::Flags & DirectAccessBit,
SrcHasDirectAccess = Src::Flags & DirectAccessBit,
StorageOrdersAgree = (int(Dst::IsRowMajor) == int(Src::IsRowMajor)),
InnerSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::SizeAtCompileTime)
: int(Dst::Flags)&RowMajorBit ? int(Dst::ColsAtCompileTime)
: int(Dst::RowsAtCompileTime),
InnerMaxSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::MaxSizeAtCompileTime)
: int(Dst::Flags)&RowMajorBit ? int(Dst::MaxColsAtCompileTime)
: int(Dst::MaxRowsAtCompileTime),
MaxSizeAtCompileTime = Dst::SizeAtCompileTime,
MightEnableVml = StorageOrdersAgree && DstHasDirectAccess && SrcHasDirectAccess && Src::InnerStrideAtCompileTime==1 && Dst::InnerStrideAtCompileTime==1,
MightLinearize = MightEnableVml && (int(Dst::Flags) & int(Src::Flags) & LinearAccessBit),
VmlSize = MightLinearize ? MaxSizeAtCompileTime : InnerMaxSize,
LargeEnough = VmlSize==Dynamic || VmlSize>=EIGEN_MKL_VML_THRESHOLD
};
public:
enum {
EnableVml = MightEnableVml && LargeEnough,
Traversal = MightLinearize ? LinearTraversal : DefaultTraversal
};
};
#define EIGEN_PP_EXPAND(ARG) ARG
#if !defined (EIGEN_FAST_MATH) || (EIGEN_FAST_MATH != 1)
#define EIGEN_VMLMODE_EXPAND_LA , VML_HA
#else
#define EIGEN_VMLMODE_EXPAND_LA , VML_LA
#endif
#define EIGEN_VMLMODE_EXPAND__
#define EIGEN_VMLMODE_PREFIX_LA vm
#define EIGEN_VMLMODE_PREFIX__ v
#define EIGEN_VMLMODE_PREFIX(VMLMODE) EIGEN_CAT(EIGEN_VMLMODE_PREFIX_,VMLMODE)
#define EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, VMLOP, EIGENTYPE, VMLTYPE, VMLMODE) \
template< typename DstXprType, typename SrcXprNested> \
struct Assignment<DstXprType, CwiseUnaryOp<scalar_##EIGENOP##_op<EIGENTYPE>, SrcXprNested>, assign_op<EIGENTYPE,EIGENTYPE>, \
Dense2Dense, typename enable_if<vml_assign_traits<DstXprType,SrcXprNested>::EnableVml>::type> { \
typedef CwiseUnaryOp<scalar_##EIGENOP##_op<EIGENTYPE>, SrcXprNested> SrcXprType; \
static void run(DstXprType &dst, const SrcXprType &src, const assign_op<EIGENTYPE,EIGENTYPE> &func) { \
resize_if_allowed(dst, src, func); \
eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols()); \
if(vml_assign_traits<DstXprType,SrcXprNested>::Traversal==LinearTraversal) { \
VMLOP(dst.size(), (const VMLTYPE*)src.nestedExpression().data(), \
(VMLTYPE*)dst.data() EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_##VMLMODE) ); \
} else { \
const Index outerSize = dst.outerSize(); \
for(Index outer = 0; outer < outerSize; ++outer) { \
const EIGENTYPE *src_ptr = src.IsRowMajor ? &(src.nestedExpression().coeffRef(outer,0)) : \
&(src.nestedExpression().coeffRef(0, outer)); \
EIGENTYPE *dst_ptr = dst.IsRowMajor ? &(dst.coeffRef(outer,0)) : &(dst.coeffRef(0, outer)); \
VMLOP( dst.innerSize(), (const VMLTYPE*)src_ptr, \
(VMLTYPE*)dst_ptr EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_##VMLMODE)); \
} \
} \
} \
}; \
#define EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(EIGENOP, VMLOP, VMLMODE) \
EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),s##VMLOP), float, float, VMLMODE) \
EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),d##VMLOP), double, double, VMLMODE)
#define EIGEN_MKL_VML_DECLARE_UNARY_CALLS_CPLX(EIGENOP, VMLOP, VMLMODE) \
EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),c##VMLOP), scomplex, MKL_Complex8, VMLMODE) \
EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),z##VMLOP), dcomplex, MKL_Complex16, VMLMODE)
#define EIGEN_MKL_VML_DECLARE_UNARY_CALLS(EIGENOP, VMLOP, VMLMODE) \
EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(EIGENOP, VMLOP, VMLMODE) \
EIGEN_MKL_VML_DECLARE_UNARY_CALLS_CPLX(EIGENOP, VMLOP, VMLMODE)
EIGEN_MKL_VML_DECLARE_UNARY_CALLS(sin, Sin, LA)
EIGEN_MKL_VML_DECLARE_UNARY_CALLS(asin, Asin, LA)
EIGEN_MKL_VML_DECLARE_UNARY_CALLS(sinh, Sinh, LA)
EIGEN_MKL_VML_DECLARE_UNARY_CALLS(cos, Cos, LA)
EIGEN_MKL_VML_DECLARE_UNARY_CALLS(acos, Acos, LA)
EIGEN_MKL_VML_DECLARE_UNARY_CALLS(cosh, Cosh, LA)
EIGEN_MKL_VML_DECLARE_UNARY_CALLS(tan, Tan, LA)
EIGEN_MKL_VML_DECLARE_UNARY_CALLS(atan, Atan, LA)
EIGEN_MKL_VML_DECLARE_UNARY_CALLS(tanh, Tanh, LA)
// EIGEN_MKL_VML_DECLARE_UNARY_CALLS(abs, Abs, _)
EIGEN_MKL_VML_DECLARE_UNARY_CALLS(exp, Exp, LA)
EIGEN_MKL_VML_DECLARE_UNARY_CALLS(log, Ln, LA)
EIGEN_MKL_VML_DECLARE_UNARY_CALLS(log10, Log10, LA)
EIGEN_MKL_VML_DECLARE_UNARY_CALLS(sqrt, Sqrt, _)
EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(square, Sqr, _)
EIGEN_MKL_VML_DECLARE_UNARY_CALLS_CPLX(arg, Arg, _)
EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(round, Round, _)
EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(floor, Floor, _)
EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(ceil, Ceil, _)
#define EIGEN_MKL_VML_DECLARE_POW_CALL(EIGENOP, VMLOP, EIGENTYPE, VMLTYPE, VMLMODE) \
template< typename DstXprType, typename SrcXprNested, typename Plain> \
struct Assignment<DstXprType, CwiseBinaryOp<scalar_##EIGENOP##_op<EIGENTYPE,EIGENTYPE>, SrcXprNested, \
const CwiseNullaryOp<internal::scalar_constant_op<EIGENTYPE>,Plain> >, assign_op<EIGENTYPE,EIGENTYPE>, \
Dense2Dense, typename enable_if<vml_assign_traits<DstXprType,SrcXprNested>::EnableVml>::type> { \
typedef CwiseBinaryOp<scalar_##EIGENOP##_op<EIGENTYPE,EIGENTYPE>, SrcXprNested, \
const CwiseNullaryOp<internal::scalar_constant_op<EIGENTYPE>,Plain> > SrcXprType; \
static void run(DstXprType &dst, const SrcXprType &src, const assign_op<EIGENTYPE,EIGENTYPE> &func) { \
resize_if_allowed(dst, src, func); \
eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols()); \
VMLTYPE exponent = reinterpret_cast<const VMLTYPE&>(src.rhs().functor().m_other); \
if(vml_assign_traits<DstXprType,SrcXprNested>::Traversal==LinearTraversal) \
{ \
VMLOP( dst.size(), (const VMLTYPE*)src.lhs().data(), exponent, \
(VMLTYPE*)dst.data() EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_##VMLMODE) ); \
} else { \
const Index outerSize = dst.outerSize(); \
for(Index outer = 0; outer < outerSize; ++outer) { \
const EIGENTYPE *src_ptr = src.IsRowMajor ? &(src.lhs().coeffRef(outer,0)) : \
&(src.lhs().coeffRef(0, outer)); \
EIGENTYPE *dst_ptr = dst.IsRowMajor ? &(dst.coeffRef(outer,0)) : &(dst.coeffRef(0, outer)); \
VMLOP( dst.innerSize(), (const VMLTYPE*)src_ptr, exponent, \
(VMLTYPE*)dst_ptr EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_##VMLMODE)); \
} \
} \
} \
};
EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmsPowx, float, float, LA)
EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmdPowx, double, double, LA)
EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmcPowx, scomplex, MKL_Complex8, LA)
EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmzPowx, dcomplex, MKL_Complex16, LA)
} // end namespace internal
} // end namespace Eigen
#endif // EIGEN_ASSIGN_VML_H
data_process_class_dll/eigen-3.3.7/Eigen/src/Core/BandMatrix.h
-353
View File
@@ -1,353 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_BANDMATRIX_H
#define EIGEN_BANDMATRIX_H
namespace Eigen {
namespace internal {
template<typename Derived>
class BandMatrixBase : public EigenBase<Derived>
{
public:
enum {
Flags = internal::traits<Derived>::Flags,
CoeffReadCost = internal::traits<Derived>::CoeffReadCost,
RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
Supers = internal::traits<Derived>::Supers,
Subs = internal::traits<Derived>::Subs,
Options = internal::traits<Derived>::Options
};
typedef typename internal::traits<Derived>::Scalar Scalar;
typedef Matrix<Scalar,RowsAtCompileTime,ColsAtCompileTime> DenseMatrixType;
typedef typename DenseMatrixType::StorageIndex StorageIndex;
typedef typename internal::traits<Derived>::CoefficientsType CoefficientsType;
typedef EigenBase<Derived> Base;
protected:
enum {
DataRowsAtCompileTime = ((Supers!=Dynamic) && (Subs!=Dynamic))
? 1 + Supers + Subs
: Dynamic,
SizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime,ColsAtCompileTime)
};
public:
using Base::derived;
using Base::rows;
using Base::cols;
/** \returns the number of super diagonals */
inline Index supers() const { return derived().supers(); }
/** \returns the number of sub diagonals */
inline Index subs() const { return derived().subs(); }
/** \returns an expression of the underlying coefficient matrix */
inline const CoefficientsType& coeffs() const { return derived().coeffs(); }
/** \returns an expression of the underlying coefficient matrix */
inline CoefficientsType& coeffs() { return derived().coeffs(); }
/** \returns a vector expression of the \a i -th column,
* only the meaningful part is returned.
* \warning the internal storage must be column major. */
inline Block<CoefficientsType,Dynamic,1> col(Index i)
{
EIGEN_STATIC_ASSERT((Options&RowMajor)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
Index start = 0;
Index len = coeffs().rows();
if (i<=supers())
{
start = supers()-i;
len = (std::min)(rows(),std::max<Index>(0,coeffs().rows() - (supers()-i)));
}
else if (i>=rows()-subs())
len = std::max<Index>(0,coeffs().rows() - (i + 1 - rows() + subs()));
return Block<CoefficientsType,Dynamic,1>(coeffs(), start, i, len, 1);
}
/** \returns a vector expression of the main diagonal */
inline Block<CoefficientsType,1,SizeAtCompileTime> diagonal()
{ return Block<CoefficientsType,1,SizeAtCompileTime>(coeffs(),supers(),0,1,(std::min)(rows(),cols())); }
/** \returns a vector expression of the main diagonal (const version) */
inline const Block<const CoefficientsType,1,SizeAtCompileTime> diagonal() const
{ return Block<const CoefficientsType,1,SizeAtCompileTime>(coeffs(),supers(),0,1,(std::min)(rows(),cols())); }
template<int Index> struct DiagonalIntReturnType {
enum {
ReturnOpposite = (Options&SelfAdjoint) && (((Index)>0 && Supers==0) || ((Index)<0 && Subs==0)),
Conjugate = ReturnOpposite && NumTraits<Scalar>::IsComplex,
ActualIndex = ReturnOpposite ? -Index : Index,
DiagonalSize = (RowsAtCompileTime==Dynamic || ColsAtCompileTime==Dynamic)
? Dynamic
: (ActualIndex<0
? EIGEN_SIZE_MIN_PREFER_DYNAMIC(ColsAtCompileTime, RowsAtCompileTime + ActualIndex)
: EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime, ColsAtCompileTime - ActualIndex))
};
typedef Block<CoefficientsType,1, DiagonalSize> BuildType;
typedef typename internal::conditional<Conjugate,
CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>,BuildType >,
BuildType>::type Type;
};
/** \returns a vector expression of the \a N -th sub or super diagonal */
template<int N> inline typename DiagonalIntReturnType<N>::Type diagonal()
{
return typename DiagonalIntReturnType<N>::BuildType(coeffs(), supers()-N, (std::max)(0,N), 1, diagonalLength(N));
}
/** \returns a vector expression of the \a N -th sub or super diagonal */
template<int N> inline const typename DiagonalIntReturnType<N>::Type diagonal() const
{
return typename DiagonalIntReturnType<N>::BuildType(coeffs(), supers()-N, (std::max)(0,N), 1, diagonalLength(N));
}
/** \returns a vector expression of the \a i -th sub or super diagonal */
inline Block<CoefficientsType,1,Dynamic> diagonal(Index i)
{
eigen_assert((i<0 && -i<=subs()) || (i>=0 && i<=supers()));
return Block<CoefficientsType,1,Dynamic>(coeffs(), supers()-i, std::max<Index>(0,i), 1, diagonalLength(i));
}
/** \returns a vector expression of the \a i -th sub or super diagonal */
inline const Block<const CoefficientsType,1,Dynamic> diagonal(Index i) const
{
eigen_assert((i<0 && -i<=subs()) || (i>=0 && i<=supers()));
return Block<const CoefficientsType,1,Dynamic>(coeffs(), supers()-i, std::max<Index>(0,i), 1, diagonalLength(i));
}
template<typename Dest> inline void evalTo(Dest& dst) const
{
dst.resize(rows(),cols());
dst.setZero();
dst.diagonal() = diagonal();
for (Index i=1; i<=supers();++i)
dst.diagonal(i) = diagonal(i);
for (Index i=1; i<=subs();++i)
dst.diagonal(-i) = diagonal(-i);
}
DenseMatrixType toDenseMatrix() const
{
DenseMatrixType res(rows(),cols());
evalTo(res);
return res;
}
protected:
inline Index diagonalLength(Index i) const
{ return i<0 ? (std::min)(cols(),rows()+i) : (std::min)(rows(),cols()-i); }
};
/**
* \class BandMatrix
* \ingroup Core_Module
*
* \brief Represents a rectangular matrix with a banded storage
*
* \tparam _Scalar Numeric type, i.e. float, double, int
* \tparam _Rows Number of rows, or \b Dynamic
* \tparam _Cols Number of columns, or \b Dynamic
* \tparam _Supers Number of super diagonal
* \tparam _Subs Number of sub diagonal
* \tparam _Options A combination of either \b #RowMajor or \b #ColMajor, and of \b #SelfAdjoint
* The former controls \ref TopicStorageOrders "storage order", and defaults to
* column-major. The latter controls whether the matrix represents a selfadjoint
* matrix in which case either Supers of Subs have to be null.
*
* \sa class TridiagonalMatrix
*/
template<typename _Scalar, int _Rows, int _Cols, int _Supers, int _Subs, int _Options>
struct traits<BandMatrix<_Scalar,_Rows,_Cols,_Supers,_Subs,_Options> >
{
typedef _Scalar Scalar;
typedef Dense StorageKind;
typedef Eigen::Index StorageIndex;
enum {
CoeffReadCost = NumTraits<Scalar>::ReadCost,
RowsAtCompileTime = _Rows,
ColsAtCompileTime = _Cols,
MaxRowsAtCompileTime = _Rows,
MaxColsAtCompileTime = _Cols,
Flags = LvalueBit,
Supers = _Supers,
Subs = _Subs,
Options = _Options,
DataRowsAtCompileTime = ((Supers!=Dynamic) && (Subs!=Dynamic)) ? 1 + Supers + Subs : Dynamic
};
typedef Matrix<Scalar,DataRowsAtCompileTime,ColsAtCompileTime,Options&RowMajor?RowMajor:ColMajor> CoefficientsType;
};
template<typename _Scalar, int Rows, int Cols, int Supers, int Subs, int Options>
class BandMatrix : public BandMatrixBase<BandMatrix<_Scalar,Rows,Cols,Supers,Subs,Options> >
{
public:
typedef typename internal::traits<BandMatrix>::Scalar Scalar;
typedef typename internal::traits<BandMatrix>::StorageIndex StorageIndex;
typedef typename internal::traits<BandMatrix>::CoefficientsType CoefficientsType;
explicit inline BandMatrix(Index rows=Rows, Index cols=Cols, Index supers=Supers, Index subs=Subs)
: m_coeffs(1+supers+subs,cols),
m_rows(rows), m_supers(supers), m_subs(subs)
{
}
/** \returns the number of columns */
inline Index rows() const { return m_rows.value(); }
/** \returns the number of rows */
inline Index cols() const { return m_coeffs.cols(); }
/** \returns the number of super diagonals */
inline Index supers() const { return m_supers.value(); }
/** \returns the number of sub diagonals */
inline Index subs() const { return m_subs.value(); }
inline const CoefficientsType& coeffs() const { return m_coeffs; }
inline CoefficientsType& coeffs() { return m_coeffs; }
protected:
CoefficientsType m_coeffs;
internal::variable_if_dynamic<Index, Rows> m_rows;
internal::variable_if_dynamic<Index, Supers> m_supers;
internal::variable_if_dynamic<Index, Subs> m_subs;
};
template<typename _CoefficientsType,int _Rows, int _Cols, int _Supers, int _Subs,int _Options>
class BandMatrixWrapper;
template<typename _CoefficientsType,int _Rows, int _Cols, int _Supers, int _Subs,int _Options>
struct traits<BandMatrixWrapper<_CoefficientsType,_Rows,_Cols,_Supers,_Subs,_Options> >
{
typedef typename _CoefficientsType::Scalar Scalar;
typedef typename _CoefficientsType::StorageKind StorageKind;
typedef typename _CoefficientsType::StorageIndex StorageIndex;
enum {
CoeffReadCost = internal::traits<_CoefficientsType>::CoeffReadCost,
RowsAtCompileTime = _Rows,
ColsAtCompileTime = _Cols,
MaxRowsAtCompileTime = _Rows,
MaxColsAtCompileTime = _Cols,
Flags = LvalueBit,
Supers = _Supers,
Subs = _Subs,
Options = _Options,
DataRowsAtCompileTime = ((Supers!=Dynamic) && (Subs!=Dynamic)) ? 1 + Supers + Subs : Dynamic
};
typedef _CoefficientsType CoefficientsType;
};
template<typename _CoefficientsType,int _Rows, int _Cols, int _Supers, int _Subs,int _Options>
class BandMatrixWrapper : public BandMatrixBase<BandMatrixWrapper<_CoefficientsType,_Rows,_Cols,_Supers,_Subs,_Options> >
{
public:
typedef typename internal::traits<BandMatrixWrapper>::Scalar Scalar;
typedef typename internal::traits<BandMatrixWrapper>::CoefficientsType CoefficientsType;
typedef typename internal::traits<BandMatrixWrapper>::StorageIndex StorageIndex;
explicit inline BandMatrixWrapper(const CoefficientsType& coeffs, Index rows=_Rows, Index cols=_Cols, Index supers=_Supers, Index subs=_Subs)
: m_coeffs(coeffs),
m_rows(rows), m_supers(supers), m_subs(subs)
{
EIGEN_UNUSED_VARIABLE(cols);
//internal::assert(coeffs.cols()==cols() && (supers()+subs()+1)==coeffs.rows());
}
/** \returns the number of columns */
inline Index rows() const { return m_rows.value(); }
/** \returns the number of rows */
inline Index cols() const { return m_coeffs.cols(); }
/** \returns the number of super diagonals */
inline Index supers() const { return m_supers.value(); }
/** \returns the number of sub diagonals */
inline Index subs() const { return m_subs.value(); }
inline const CoefficientsType& coeffs() const { return m_coeffs; }
protected:
const CoefficientsType& m_coeffs;
internal::variable_if_dynamic<Index, _Rows> m_rows;
internal::variable_if_dynamic<Index, _Supers> m_supers;
internal::variable_if_dynamic<Index, _Subs> m_subs;
};
/**
* \class TridiagonalMatrix
* \ingroup Core_Module
*
* \brief Represents a tridiagonal matrix with a compact banded storage
*
* \tparam Scalar Numeric type, i.e. float, double, int
* \tparam Size Number of rows and cols, or \b Dynamic
* \tparam Options Can be 0 or \b SelfAdjoint
*
* \sa class BandMatrix
*/
template<typename Scalar, int Size, int Options>
class TridiagonalMatrix : public BandMatrix<Scalar,Size,Size,Options&SelfAdjoint?0:1,1,Options|RowMajor>
{
typedef BandMatrix<Scalar,Size,Size,Options&SelfAdjoint?0:1,1,Options|RowMajor> Base;
typedef typename Base::StorageIndex StorageIndex;
public:
explicit TridiagonalMatrix(Index size = Size) : Base(size,size,Options&SelfAdjoint?0:1,1) {}
inline typename Base::template DiagonalIntReturnType<1>::Type super()
{ return Base::template diagonal<1>(); }
inline const typename Base::template DiagonalIntReturnType<1>::Type super() const
{ return Base::template diagonal<1>(); }
inline typename Base::template DiagonalIntReturnType<-1>::Type sub()
{ return Base::template diagonal<-1>(); }
inline const typename Base::template DiagonalIntReturnType<-1>::Type sub() const
{ return Base::template diagonal<-1>(); }
protected:
};
struct BandShape {};
template<typename _Scalar, int _Rows, int _Cols, int _Supers, int _Subs, int _Options>
struct evaluator_traits<BandMatrix<_Scalar,_Rows,_Cols,_Supers,_Subs,_Options> >
: public evaluator_traits_base<BandMatrix<_Scalar,_Rows,_Cols,_Supers,_Subs,_Options> >
{
typedef BandShape Shape;
};
template<typename _CoefficientsType,int _Rows, int _Cols, int _Supers, int _Subs,int _Options>
struct evaluator_traits<BandMatrixWrapper<_CoefficientsType,_Rows,_Cols,_Supers,_Subs,_Options> >
: public evaluator_traits_base<BandMatrixWrapper<_CoefficientsType,_Rows,_Cols,_Supers,_Subs,_Options> >
{
typedef BandShape Shape;
};
template<> struct AssignmentKind<DenseShape,BandShape> { typedef EigenBase2EigenBase Kind; };
} // end namespace internal
} // end namespace Eigen
#endif // EIGEN_BANDMATRIX_H
data_process_class_dll/eigen-3.3.7/Eigen/src/Core/Block.h
-452
View File
@@ -1,452 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_BLOCK_H
#define EIGEN_BLOCK_H
namespace Eigen {
namespace internal {
template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
struct traits<Block<XprType, BlockRows, BlockCols, InnerPanel> > : traits<XprType>
{
typedef typename traits<XprType>::Scalar Scalar;
typedef typename traits<XprType>::StorageKind StorageKind;
typedef typename traits<XprType>::XprKind XprKind;
typedef typename ref_selector<XprType>::type XprTypeNested;
typedef typename remove_reference<XprTypeNested>::type _XprTypeNested;
enum{
MatrixRows = traits<XprType>::RowsAtCompileTime,
MatrixCols = traits<XprType>::ColsAtCompileTime,
RowsAtCompileTime = MatrixRows == 0 ? 0 : BlockRows,
ColsAtCompileTime = MatrixCols == 0 ? 0 : BlockCols,
MaxRowsAtCompileTime = BlockRows==0 ? 0
: RowsAtCompileTime != Dynamic ? int(RowsAtCompileTime)
: int(traits<XprType>::MaxRowsAtCompileTime),
MaxColsAtCompileTime = BlockCols==0 ? 0
: ColsAtCompileTime != Dynamic ? int(ColsAtCompileTime)
: int(traits<XprType>::MaxColsAtCompileTime),
XprTypeIsRowMajor = (int(traits<XprType>::Flags)&RowMajorBit) != 0,
IsRowMajor = (MaxRowsAtCompileTime==1&&MaxColsAtCompileTime!=1) ? 1
: (MaxColsAtCompileTime==1&&MaxRowsAtCompileTime!=1) ? 0
: XprTypeIsRowMajor,
HasSameStorageOrderAsXprType = (IsRowMajor == XprTypeIsRowMajor),
InnerSize = IsRowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
InnerStrideAtCompileTime = HasSameStorageOrderAsXprType
? int(inner_stride_at_compile_time<XprType>::ret)
: int(outer_stride_at_compile_time<XprType>::ret),
OuterStrideAtCompileTime = HasSameStorageOrderAsXprType
? int(outer_stride_at_compile_time<XprType>::ret)
: int(inner_stride_at_compile_time<XprType>::ret),
// FIXME, this traits is rather specialized for dense object and it needs to be cleaned further
FlagsLvalueBit = is_lvalue<XprType>::value ? LvalueBit : 0,
FlagsRowMajorBit = IsRowMajor ? RowMajorBit : 0,
Flags = (traits<XprType>::Flags & (DirectAccessBit | (InnerPanel?CompressedAccessBit:0))) | FlagsLvalueBit | FlagsRowMajorBit,
// FIXME DirectAccessBit should not be handled by expressions
//
// Alignment is needed by MapBase's assertions
// We can sefely set it to false here. Internal alignment errors will be detected by an eigen_internal_assert in the respective evaluator
Alignment = 0
};
};
template<typename XprType, int BlockRows=Dynamic, int BlockCols=Dynamic, bool InnerPanel = false,
bool HasDirectAccess = internal::has_direct_access<XprType>::ret> class BlockImpl_dense;
} // end namespace internal
template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, typename StorageKind> class BlockImpl;
/** \class Block
* \ingroup Core_Module
*
* \brief Expression of a fixed-size or dynamic-size block
*
* \tparam XprType the type of the expression in which we are taking a block
* \tparam BlockRows the number of rows of the block we are taking at compile time (optional)
* \tparam BlockCols the number of columns of the block we are taking at compile time (optional)
* \tparam InnerPanel is true, if the block maps to a set of rows of a row major matrix or
* to set of columns of a column major matrix (optional). The parameter allows to determine
* at compile time whether aligned access is possible on the block expression.
*
* This class represents an expression of either a fixed-size or dynamic-size block. It is the return
* type of DenseBase::block(Index,Index,Index,Index) and DenseBase::block<int,int>(Index,Index) and
* most of the time this is the only way it is used.
*
* However, if you want to directly maniputate block expressions,
* for instance if you want to write a function returning such an expression, you
* will need to use this class.
*
* Here is an example illustrating the dynamic case:
* \include class_Block.cpp
* Output: \verbinclude class_Block.out
*
* \note Even though this expression has dynamic size, in the case where \a XprType
* has fixed size, this expression inherits a fixed maximal size which means that evaluating
* it does not cause a dynamic memory allocation.
*
* Here is an example illustrating the fixed-size case:
* \include class_FixedBlock.cpp
* Output: \verbinclude class_FixedBlock.out
*
* \sa DenseBase::block(Index,Index,Index,Index), DenseBase::block(Index,Index), class VectorBlock
*/
template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel> class Block
: public BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits<XprType>::StorageKind>
{
typedef BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits<XprType>::StorageKind> Impl;
public:
//typedef typename Impl::Base Base;
typedef Impl Base;
EIGEN_GENERIC_PUBLIC_INTERFACE(Block)
EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block)
typedef typename internal::remove_all<XprType>::type NestedExpression;
/** Column or Row constructor
*/
EIGEN_DEVICE_FUNC
inline Block(XprType& xpr, Index i) : Impl(xpr,i)
{
eigen_assert( (i>=0) && (
((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && i<xpr.rows())
||((BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) && i<xpr.cols())));
}
/** Fixed-size constructor
*/
EIGEN_DEVICE_FUNC
inline Block(XprType& xpr, Index startRow, Index startCol)
: Impl(xpr, startRow, startCol)
{
EIGEN_STATIC_ASSERT(RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic,THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE)
eigen_assert(startRow >= 0 && BlockRows >= 0 && startRow + BlockRows <= xpr.rows()
&& startCol >= 0 && BlockCols >= 0 && startCol + BlockCols <= xpr.cols());
}
/** Dynamic-size constructor
*/
EIGEN_DEVICE_FUNC
inline Block(XprType& xpr,
Index startRow, Index startCol,
Index blockRows, Index blockCols)
: Impl(xpr, startRow, startCol, blockRows, blockCols)
{
eigen_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows)
&& (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols));
eigen_assert(startRow >= 0 && blockRows >= 0 && startRow <= xpr.rows() - blockRows
&& startCol >= 0 && blockCols >= 0 && startCol <= xpr.cols() - blockCols);
}
};
// The generic default implementation for dense block simplu forward to the internal::BlockImpl_dense
// that must be specialized for direct and non-direct access...
template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
class BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, Dense>
: public internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel>
{
typedef internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel> Impl;
typedef typename XprType::StorageIndex StorageIndex;
public:
typedef Impl Base;
EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl)
EIGEN_DEVICE_FUNC inline BlockImpl(XprType& xpr, Index i) : Impl(xpr,i) {}
EIGEN_DEVICE_FUNC inline BlockImpl(XprType& xpr, Index startRow, Index startCol) : Impl(xpr, startRow, startCol) {}
EIGEN_DEVICE_FUNC
inline BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
: Impl(xpr, startRow, startCol, blockRows, blockCols) {}
};
namespace internal {
/** \internal Internal implementation of dense Blocks in the general case. */
template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool HasDirectAccess> class BlockImpl_dense
: public internal::dense_xpr_base<Block<XprType, BlockRows, BlockCols, InnerPanel> >::type
{
typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
public:
typedef typename internal::dense_xpr_base<BlockType>::type Base;
EIGEN_DENSE_PUBLIC_INTERFACE(BlockType)
EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl_dense)
// class InnerIterator; // FIXME apparently never used
/** Column or Row constructor
*/
EIGEN_DEVICE_FUNC
inline BlockImpl_dense(XprType& xpr, Index i)
: m_xpr(xpr),
// It is a row if and only if BlockRows==1 and BlockCols==XprType::ColsAtCompileTime,
// and it is a column if and only if BlockRows==XprType::RowsAtCompileTime and BlockCols==1,
// all other cases are invalid.
// The case a 1x1 matrix seems ambiguous, but the result is the same anyway.
m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? i : 0),
m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? i : 0),
m_blockRows(BlockRows==1 ? 1 : xpr.rows()),
m_blockCols(BlockCols==1 ? 1 : xpr.cols())
{}
/** Fixed-size constructor
*/
EIGEN_DEVICE_FUNC
inline BlockImpl_dense(XprType& xpr, Index startRow, Index startCol)
: m_xpr(xpr), m_startRow(startRow), m_startCol(startCol),
m_blockRows(BlockRows), m_blockCols(BlockCols)
{}
/** Dynamic-size constructor
*/
EIGEN_DEVICE_FUNC
inline BlockImpl_dense(XprType& xpr,
Index startRow, Index startCol,
Index blockRows, Index blockCols)
: m_xpr(xpr), m_startRow(startRow), m_startCol(startCol),
m_blockRows(blockRows), m_blockCols(blockCols)
{}
EIGEN_DEVICE_FUNC inline Index rows() const { return m_blockRows.value(); }
EIGEN_DEVICE_FUNC inline Index cols() const { return m_blockCols.value(); }
EIGEN_DEVICE_FUNC
inline Scalar& coeffRef(Index rowId, Index colId)
{
EIGEN_STATIC_ASSERT_LVALUE(XprType)
return m_xpr.coeffRef(rowId + m_startRow.value(), colId + m_startCol.value());
}
EIGEN_DEVICE_FUNC
inline const Scalar& coeffRef(Index rowId, Index colId) const
{
return m_xpr.derived().coeffRef(rowId + m_startRow.value(), colId + m_startCol.value());
}
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index rowId, Index colId) const
{
return m_xpr.coeff(rowId + m_startRow.value(), colId + m_startCol.value());
}
EIGEN_DEVICE_FUNC
inline Scalar& coeffRef(Index index)
{
EIGEN_STATIC_ASSERT_LVALUE(XprType)
return m_xpr.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
}
EIGEN_DEVICE_FUNC
inline const Scalar& coeffRef(Index index) const
{
return m_xpr.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
}
EIGEN_DEVICE_FUNC
inline const CoeffReturnType coeff(Index index) const
{
return m_xpr.coeff(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
}
template<int LoadMode>
inline PacketScalar packet(Index rowId, Index colId) const
{
return m_xpr.template packet<Unaligned>(rowId + m_startRow.value(), colId + m_startCol.value());
}
template<int LoadMode>
inline void writePacket(Index rowId, Index colId, const PacketScalar& val)
{
m_xpr.template writePacket<Unaligned>(rowId + m_startRow.value(), colId + m_startCol.value(), val);
}
template<int LoadMode>
inline PacketScalar packet(Index index) const
{
return m_xpr.template packet<Unaligned>
(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
}
template<int LoadMode>
inline void writePacket(Index index, const PacketScalar& val)
{
m_xpr.template writePacket<Unaligned>
(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0), val);
}
#ifdef EIGEN_PARSED_BY_DOXYGEN
/** \sa MapBase::data() */
EIGEN_DEVICE_FUNC inline const Scalar* data() const;
EIGEN_DEVICE_FUNC inline Index innerStride() const;
EIGEN_DEVICE_FUNC inline Index outerStride() const;
#endif
EIGEN_DEVICE_FUNC
const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const
{
return m_xpr;
}
EIGEN_DEVICE_FUNC
XprType& nestedExpression() { return m_xpr; }
EIGEN_DEVICE_FUNC
StorageIndex startRow() const
{
return m_startRow.value();
}
EIGEN_DEVICE_FUNC
StorageIndex startCol() const
{
return m_startCol.value();
}
protected:
XprTypeNested m_xpr;
const internal::variable_if_dynamic<StorageIndex, (XprType::RowsAtCompileTime == 1 && BlockRows==1) ? 0 : Dynamic> m_startRow;
const internal::variable_if_dynamic<StorageIndex, (XprType::ColsAtCompileTime == 1 && BlockCols==1) ? 0 : Dynamic> m_startCol;
const internal::variable_if_dynamic<StorageIndex, RowsAtCompileTime> m_blockRows;
const internal::variable_if_dynamic<StorageIndex, ColsAtCompileTime> m_blockCols;
};
/** \internal Internal implementation of dense Blocks in the direct access case.*/
template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
class BlockImpl_dense<XprType,BlockRows,BlockCols, InnerPanel,true>
: public MapBase<Block<XprType, BlockRows, BlockCols, InnerPanel> >
{
typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
enum {
XprTypeIsRowMajor = (int(traits<XprType>::Flags)&RowMajorBit) != 0
};
public:
typedef MapBase<BlockType> Base;
EIGEN_DENSE_PUBLIC_INTERFACE(BlockType)
EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl_dense)
/** Column or Row constructor
*/
EIGEN_DEVICE_FUNC
inline BlockImpl_dense(XprType& xpr, Index i)
: Base(xpr.data() + i * ( ((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && (!XprTypeIsRowMajor))
|| ((BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) && ( XprTypeIsRowMajor)) ? xpr.innerStride() : xpr.outerStride()),
BlockRows==1 ? 1 : xpr.rows(),
BlockCols==1 ? 1 : xpr.cols()),
m_xpr(xpr),
m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? i : 0),
m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? i : 0)
{
init();
}
/** Fixed-size constructor
*/
EIGEN_DEVICE_FUNC
inline BlockImpl_dense(XprType& xpr, Index startRow, Index startCol)
: Base(xpr.data()+xpr.innerStride()*(XprTypeIsRowMajor?startCol:startRow) + xpr.outerStride()*(XprTypeIsRowMajor?startRow:startCol)),
m_xpr(xpr), m_startRow(startRow), m_startCol(startCol)
{
init();
}
/** Dynamic-size constructor
*/
EIGEN_DEVICE_FUNC
inline BlockImpl_dense(XprType& xpr,
Index startRow, Index startCol,
Index blockRows, Index blockCols)
: Base(xpr.data()+xpr.innerStride()*(XprTypeIsRowMajor?startCol:startRow) + xpr.outerStride()*(XprTypeIsRowMajor?startRow:startCol), blockRows, blockCols),
m_xpr(xpr), m_startRow(startRow), m_startCol(startCol)
{
init();
}
EIGEN_DEVICE_FUNC
const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const
{
return m_xpr;
}
EIGEN_DEVICE_FUNC
XprType& nestedExpression() { return m_xpr; }
/** \sa MapBase::innerStride() */
EIGEN_DEVICE_FUNC
inline Index innerStride() const
{
return internal::traits<BlockType>::HasSameStorageOrderAsXprType
? m_xpr.innerStride()
: m_xpr.outerStride();
}
/** \sa MapBase::outerStride() */
EIGEN_DEVICE_FUNC
inline Index outerStride() const
{
return m_outerStride;
}
EIGEN_DEVICE_FUNC
StorageIndex startRow() const
{
return m_startRow.value();
}
EIGEN_DEVICE_FUNC
StorageIndex startCol() const
{
return m_startCol.value();
}
#ifndef __SUNPRO_CC
// FIXME sunstudio is not friendly with the above friend...
// META-FIXME there is no 'friend' keyword around here. Is this obsolete?
protected:
#endif
#ifndef EIGEN_PARSED_BY_DOXYGEN
/** \internal used by allowAligned() */
EIGEN_DEVICE_FUNC
inline BlockImpl_dense(XprType& xpr, const Scalar* data, Index blockRows, Index blockCols)
: Base(data, blockRows, blockCols), m_xpr(xpr)
{
init();
}
#endif
protected:
EIGEN_DEVICE_FUNC
void init()
{
m_outerStride = internal::traits<BlockType>::HasSameStorageOrderAsXprType
? m_xpr.outerStride()
: m_xpr.innerStride();
}
XprTypeNested m_xpr;
const internal::variable_if_dynamic<StorageIndex, (XprType::RowsAtCompileTime == 1 && BlockRows==1) ? 0 : Dynamic> m_startRow;
const internal::variable_if_dynamic<StorageIndex, (XprType::ColsAtCompileTime == 1 && BlockCols==1) ? 0 : Dynamic> m_startCol;
Index m_outerStride;
};
} // end namespace internal
} // end namespace Eigen
#endif // EIGEN_BLOCK_H
data_process_class_dll/eigen-3.3.7/Eigen/src/Core/BooleanRedux.h
-164
View File
@@ -1,164 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_ALLANDANY_H
#define EIGEN_ALLANDANY_H
namespace Eigen {
namespace internal {
template<typename Derived, int UnrollCount>
struct all_unroller
{
typedef typename Derived::ExpressionTraits Traits;
enum {
col = (UnrollCount-1) / Traits::RowsAtCompileTime,
row = (UnrollCount-1) % Traits::RowsAtCompileTime
};
static inline bool run(const Derived &mat)
{
return all_unroller<Derived, UnrollCount-1>::run(mat) && mat.coeff(row, col);
}
};
template<typename Derived>
struct all_unroller<Derived, 0>
{
static inline bool run(const Derived &/*mat*/) { return true; }
};
template<typename Derived>
struct all_unroller<Derived, Dynamic>
{
static inline bool run(const Derived &) { return false; }
};
template<typename Derived, int UnrollCount>
struct any_unroller
{
typedef typename Derived::ExpressionTraits Traits;
enum {
col = (UnrollCount-1) / Traits::RowsAtCompileTime,
row = (UnrollCount-1) % Traits::RowsAtCompileTime
};
static inline bool run(const Derived &mat)
{
return any_unroller<Derived, UnrollCount-1>::run(mat) || mat.coeff(row, col);
}
};
template<typename Derived>
struct any_unroller<Derived, 0>
{
static inline bool run(const Derived & /*mat*/) { return false; }
};
template<typename Derived>
struct any_unroller<Derived, Dynamic>
{
static inline bool run(const Derived &) { return false; }
};
} // end namespace internal
/** \returns true if all coefficients are true
*
* Example: \include MatrixBase_all.cpp
* Output: \verbinclude MatrixBase_all.out
*
* \sa any(), Cwise::operator<()
*/
template<typename Derived>
inline bool DenseBase<Derived>::all() const
{
typedef internal::evaluator<Derived> Evaluator;
enum {
unroll = SizeAtCompileTime != Dynamic
&& SizeAtCompileTime * (Evaluator::CoeffReadCost + NumTraits<Scalar>::AddCost) <= EIGEN_UNROLLING_LIMIT
};
Evaluator evaluator(derived());
if(unroll)
return internal::all_unroller<Evaluator, unroll ? int(SizeAtCompileTime) : Dynamic>::run(evaluator);
else
{
for(Index j = 0; j < cols(); ++j)
for(Index i = 0; i < rows(); ++i)
if (!evaluator.coeff(i, j)) return false;
return true;
}
}
/** \returns true if at least one coefficient is true
*
* \sa all()
*/
template<typename Derived>
inline bool DenseBase<Derived>::any() const
{
typedef internal::evaluator<Derived> Evaluator;
enum {
unroll = SizeAtCompileTime != Dynamic
&& SizeAtCompileTime * (Evaluator::CoeffReadCost + NumTraits<Scalar>::AddCost) <= EIGEN_UNROLLING_LIMIT
};
Evaluator evaluator(derived());
if(unroll)
return internal::any_unroller<Evaluator, unroll ? int(SizeAtCompileTime) : Dynamic>::run(evaluator);
else
{
for(Index j = 0; j < cols(); ++j)
for(Index i = 0; i < rows(); ++i)
if (evaluator.coeff(i, j)) return true;
return false;
}
}
/** \returns the number of coefficients which evaluate to true
*
* \sa all(), any()
*/
template<typename Derived>
inline Eigen::Index DenseBase<Derived>::count() const
{
return derived().template cast<bool>().template cast<Index>().sum();
}
/** \returns true is \c *this contains at least one Not A Number (NaN).
*
* \sa allFinite()
*/
template<typename Derived>
inline bool DenseBase<Derived>::hasNaN() const
{
#if EIGEN_COMP_MSVC || (defined __FAST_MATH__)
return derived().array().isNaN().any();
#else
return !((derived().array()==derived().array()).all());
#endif
}
/** \returns true if \c *this contains only finite numbers, i.e., no NaN and no +/-INF values.
*
* \sa hasNaN()
*/
template<typename Derived>
inline bool DenseBase<Derived>::allFinite() const
{
#if EIGEN_COMP_MSVC || (defined __FAST_MATH__)
return derived().array().isFinite().all();
#else
return !((derived()-derived()).hasNaN());
#endif
}
} // end namespace Eigen
#endif // EIGEN_ALLANDANY_H
data_process_class_dll/eigen-3.3.7/Eigen/src/Core/CommaInitializer.h
-160
View File
@@ -1,160 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_COMMAINITIALIZER_H
#define EIGEN_COMMAINITIALIZER_H
namespace Eigen {
/** \class CommaInitializer
* \ingroup Core_Module
*
* \brief Helper class used by the comma initializer operator
*
* This class is internally used to implement the comma initializer feature. It is
* the return type of MatrixBase::operator<<, and most of the time this is the only
* way it is used.
*
* \sa \blank \ref MatrixBaseCommaInitRef "MatrixBase::operator<<", CommaInitializer::finished()
*/
template<typename XprType>
struct CommaInitializer
{
typedef typename XprType::Scalar Scalar;
EIGEN_DEVICE_FUNC
inline CommaInitializer(XprType& xpr, const Scalar& s)
: m_xpr(xpr), m_row(0), m_col(1), m_currentBlockRows(1)
{
m_xpr.coeffRef(0,0) = s;
}
template<typename OtherDerived>
EIGEN_DEVICE_FUNC
inline CommaInitializer(XprType& xpr, const DenseBase<OtherDerived>& other)
: m_xpr(xpr), m_row(0), m_col(other.cols()), m_currentBlockRows(other.rows())
{
m_xpr.block(0, 0, other.rows(), other.cols()) = other;
}
/* Copy/Move constructor which transfers ownership. This is crucial in
* absence of return value optimization to avoid assertions during destruction. */
// FIXME in C++11 mode this could be replaced by a proper RValue constructor
EIGEN_DEVICE_FUNC
inline CommaInitializer(const CommaInitializer& o)
: m_xpr(o.m_xpr), m_row(o.m_row), m_col(o.m_col), m_currentBlockRows(o.m_currentBlockRows) {
// Mark original object as finished. In absence of R-value references we need to const_cast:
const_cast<CommaInitializer&>(o).m_row = m_xpr.rows();
const_cast<CommaInitializer&>(o).m_col = m_xpr.cols();
const_cast<CommaInitializer&>(o).m_currentBlockRows = 0;
}
/* inserts a scalar value in the target matrix */
EIGEN_DEVICE_FUNC
CommaInitializer& operator,(const Scalar& s)
{
if (m_col==m_xpr.cols())
{
m_row+=m_currentBlockRows;
m_col = 0;
m_currentBlockRows = 1;
eigen_assert(m_row<m_xpr.rows()
&& "Too many rows passed to comma initializer (operator<<)");
}
eigen_assert(m_col<m_xpr.cols()
&& "Too many coefficients passed to comma initializer (operator<<)");
eigen_assert(m_currentBlockRows==1);
m_xpr.coeffRef(m_row, m_col++) = s;
return *this;
}
/* inserts a matrix expression in the target matrix */
template<typename OtherDerived>
EIGEN_DEVICE_FUNC
CommaInitializer& operator,(const DenseBase<OtherDerived>& other)
{
if (m_col==m_xpr.cols() && (other.cols()!=0 || other.rows()!=m_currentBlockRows))
{
m_row+=m_currentBlockRows;
m_col = 0;
m_currentBlockRows = other.rows();
eigen_assert(m_row+m_currentBlockRows<=m_xpr.rows()
&& "Too many rows passed to comma initializer (operator<<)");
}
eigen_assert((m_col + other.cols() <= m_xpr.cols())
&& "Too many coefficients passed to comma initializer (operator<<)");
eigen_assert(m_currentBlockRows==other.rows());
m_xpr.template block<OtherDerived::RowsAtCompileTime, OtherDerived::ColsAtCompileTime>
(m_row, m_col, other.rows(), other.cols()) = other;
m_col += other.cols();
return *this;
}
EIGEN_DEVICE_FUNC
inline ~CommaInitializer()
#if defined VERIFY_RAISES_ASSERT && (!defined EIGEN_NO_ASSERTION_CHECKING) && defined EIGEN_EXCEPTIONS
EIGEN_EXCEPTION_SPEC(Eigen::eigen_assert_exception)
#endif
{
finished();
}
/** \returns the built matrix once all its coefficients have been set.
* Calling finished is 100% optional. Its purpose is to write expressions
* like this:
* \code
* quaternion.fromRotationMatrix((Matrix3f() << axis0, axis1, axis2).finished());
* \endcode
*/
EIGEN_DEVICE_FUNC
inline XprType& finished() {
eigen_assert(((m_row+m_currentBlockRows) == m_xpr.rows() || m_xpr.cols() == 0)
&& m_col == m_xpr.cols()
&& "Too few coefficients passed to comma initializer (operator<<)");
return m_xpr;
}
XprType& m_xpr; // target expression
Index m_row; // current row id
Index m_col; // current col id
Index m_currentBlockRows; // current block height
};
/** \anchor MatrixBaseCommaInitRef
* Convenient operator to set the coefficients of a matrix.
*
* The coefficients must be provided in a row major order and exactly match
* the size of the matrix. Otherwise an assertion is raised.
*
* Example: \include MatrixBase_set.cpp
* Output: \verbinclude MatrixBase_set.out
*
* \note According the c++ standard, the argument expressions of this comma initializer are evaluated in arbitrary order.
*
* \sa CommaInitializer::finished(), class CommaInitializer
*/
template<typename Derived>
inline CommaInitializer<Derived> DenseBase<Derived>::operator<< (const Scalar& s)
{
return CommaInitializer<Derived>(*static_cast<Derived*>(this), s);
}
/** \sa operator<<(const Scalar&) */
template<typename Derived>
template<typename OtherDerived>
inline CommaInitializer<Derived>
DenseBase<Derived>::operator<<(const DenseBase<OtherDerived>& other)
{
return CommaInitializer<Derived>(*static_cast<Derived *>(this), other);
}
} // end namespace Eigen
#endif // EIGEN_COMMAINITIALIZER_H
data_process_class_dll/eigen-3.3.7/Eigen/src/Core/ConditionEstimator.h
-175
View File
@@ -1,175 +0,0 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2016 Rasmus Munk Larsen (rmlarsen@google.com)
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_CONDITIONESTIMATOR_H
#define EIGEN_CONDITIONESTIMATOR_H
namespace Eigen {
namespace internal {
template <typename Vector, typename RealVector, bool IsComplex>
struct rcond_compute_sign {
static inline Vector run(const Vector& v) {
const RealVector v_abs = v.cwiseAbs();
return (v_abs.array() == static_cast<typename Vector::RealScalar>(0))
.select(Vector::Ones(v.size()), v.cwiseQuotient(v_abs));
}
};
// Partial specialization to avoid elementwise division for real vectors.
template <typename Vector>
struct rcond_compute_sign<Vector, Vector, false> {
static inline Vector run(const Vector& v) {
return (v.array() < static_cast<typename Vector::RealScalar>(0))
.select(-Vector::Ones(v.size()), Vector::Ones(v.size()));
}
};
/**
* \returns an estimate of ||inv(matrix)||_1 given a decomposition of
* \a matrix that implements .solve() and .adjoint().solve() methods.
*
* This function implements Algorithms 4.1 and 5.1 from
* http://www.maths.manchester.ac.uk/~higham/narep/narep135.pdf
* which also forms the basis for the condition number estimators in
* LAPACK. Since at most 10 calls to the solve method of dec are
* performed, the total cost is O(dims^2), as opposed to O(dims^3)
* needed to compute the inverse matrix explicitly.
*
* The most common usage is in estimating the condition number
* ||matrix||_1 * ||inv(matrix)||_1. The first term ||matrix||_1 can be
* computed directly in O(n^2) operations.
*
* Supports the following decompositions: FullPivLU, PartialPivLU, LDLT, and
* LLT.
*
* \sa FullPivLU, PartialPivLU, LDLT, LLT.
*/
template <typename Decomposition>
typename Decomposition::RealScalar rcond_invmatrix_L1_norm_estimate(const Decomposition& dec)
{
typedef typename Decomposition::MatrixType MatrixType;
typedef typename Decomposition::Scalar Scalar;
typedef typename Decomposition::RealScalar RealScalar;
typedef typename internal::plain_col_type<MatrixType>::type Vector;
typedef typename internal::plain_col_type<MatrixType, RealScalar>::type RealVector;
const bool is_complex = (NumTraits<Scalar>::IsComplex != 0);
eigen_assert(dec.rows() == dec.cols());
const Index n = dec.rows();
if (n == 0)
return 0;
// Disable Index to float conversion warning
#ifdef __INTEL_COMPILER
#pragma warning push
#pragma warning ( disable : 2259 )
#endif
Vector v = dec.solve(Vector::Ones(n) / Scalar(n));
#ifdef __INTEL_COMPILER
#pragma warning pop
#endif
// lower_bound is a lower bound on
// ||inv(matrix)||_1 = sup_v ||inv(matrix) v||_1 / ||v||_1
// and is the objective maximized by the ("super-") gradient ascent
// algorithm below.
RealScalar lower_bound = v.template lpNorm<1>();
if (n == 1)
return lower_bound;
// Gradient ascent algorithm follows: We know that the optimum is achieved at
// one of the simplices v = e_i, so in each iteration we follow a
// super-gradient to move towards the optimal one.
RealScalar old_lower_bound = lower_bound;
Vector sign_vector(n);
Vector old_sign_vector;
Index v_max_abs_index = -1;
Index old_v_max_abs_index = v_max_abs_index;
for (int k = 0; k < 4; ++k)
{
sign_vector = internal::rcond_compute_sign<Vector, RealVector, is_complex>::run(v);
if (k > 0 && !is_complex && sign_vector == old_sign_vector) {
// Break if the solution stagnated.
break;
}
// v_max_abs_index = argmax |real( inv(matrix)^T * sign_vector )|
v = dec.adjoint().solve(sign_vector);
v.real().cwiseAbs().maxCoeff(&v_max_abs_index);
if (v_max_abs_index == old_v_max_abs_index) {
// Break if the solution stagnated.
break;
}
// Move to the new simplex e_j, where j = v_max_abs_index.
v = dec.solve(Vector::Unit(n, v_max_abs_index)); // v = inv(matrix) * e_j.
lower_bound = v.template lpNorm<1>();
if (lower_bound <= old_lower_bound) {
// Break if the gradient step did not increase the lower_bound.
break;
}
if (!is_complex) {
old_sign_vector = sign_vector;
}
old_v_max_abs_index = v_max_abs_index;
old_lower_bound = lower_bound;
}
// The following calculates an independent estimate of ||matrix||_1 by
// multiplying matrix by a vector with entries of slowly increasing
// magnitude and alternating sign:
// v_i = (-1)^{i} (1 + (i / (dim-1))), i = 0,...,dim-1.
// This improvement to Hager's algorithm above is due to Higham. It was
// added to make the algorithm more robust in certain corner cases where
// large elements in the matrix might otherwise escape detection due to
// exact cancellation (especially when op and op_adjoint correspond to a
// sequence of backsubstitutions and permutations), which could cause
// Hager's algorithm to vastly underestimate ||matrix||_1.
Scalar alternating_sign(RealScalar(1));
for (Index i = 0; i < n; ++i) {
// The static_cast is needed when Scalar is a complex and RealScalar implements expression templates
v[i] = alternating_sign * static_cast<RealScalar>(RealScalar(1) + (RealScalar(i) / (RealScalar(n - 1))));
alternating_sign = -alternating_sign;
}
v = dec.solve(v);
const RealScalar alternate_lower_bound = (2 * v.template lpNorm<1>()) / (3 * RealScalar(n));
return numext::maxi(lower_bound, alternate_lower_bound);
}
/** \brief Reciprocal condition number estimator.
*
* Computing a decomposition of a dense matrix takes O(n^3) operations, while
* this method estimates the condition number quickly and reliably in O(n^2)
* operations.
*
* \returns an estimate of the reciprocal condition number
* (1 / (||matrix||_1 * ||inv(matrix)||_1)) of matrix, given ||matrix||_1 and
* its decomposition. Supports the following decompositions: FullPivLU,
* PartialPivLU, LDLT, and LLT.
*
* \sa FullPivLU, PartialPivLU, LDLT, LLT.
*/
template <typename Decomposition>
typename Decomposition::RealScalar
rcond_estimate_helper(typename Decomposition::RealScalar matrix_norm, const Decomposition& dec)
{
typedef typename Decomposition::RealScalar RealScalar;
eigen_assert(dec.rows() == dec.cols());
if (dec.rows() == 0) return NumTraits<RealScalar>::infinity();
if (matrix_norm == RealScalar(0)) return RealScalar(0);
if (dec.rows() == 1) return RealScalar(1);
const RealScalar inverse_matrix_norm = rcond_invmatrix_L1_norm_estimate(dec);
return (inverse_matrix_norm == RealScalar(0) ? RealScalar(0)
: (RealScalar(1) / inverse_matrix_norm) / matrix_norm);
}
} // namespace internal
} // namespace Eigen
#endif

Some files were not shown because too many files have changed in this diff Show More