diff --git a/App/WeldSeam/WeldSeamApp/Presenter/Inc/DetectPresenter.h b/App/WeldSeam/WeldSeamApp/Presenter/Inc/DetectPresenter.h
index e04e9e7d..cf50780e 100644
--- a/App/WeldSeam/WeldSeamApp/Presenter/Inc/DetectPresenter.h
+++ b/App/WeldSeam/WeldSeamApp/Presenter/Inc/DetectPresenter.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <QString>
+#include <mutex>
 #include <utility>
 #include <vector>
 
@@ -16,6 +17,14 @@ public:
     DetectPresenter();
     static QString GetAlgoVersion();
 
+    void ResetIncrementalData();
+    bool ProcessDetectionLine(EVzResultDataType dataType,
+                              const SVzLaserLineData& lineData,
+                              const VrAlgorithmParams& algorithmParams,
+                              const SSG_planeCalibPara& groundCalibParam,
+                              LaserDataLoader& dataLoader);
+    bool HasIncrementalData() const;
+
     int DetectWeldSeam(
         int cameraIndex,
         std::vector<std::pair<EVzResultDataType, SVzLaserLineData>>& laserLines,
@@ -24,4 +33,9 @@ public:
         const VrDebugParam& debugParam,
         LaserDataLoader& dataLoader,
         DetectionResult& detectionResult);
+
+private:
+    mutable std::mutex m_incrementalMutex;
+    std::vector<std::vector<SVzNL3DPosition>> m_incrementalScanLines;
+    std::vector<std::vector<SSG_basicFeatureGap>> m_incrementalLineValleys;
 };
diff --git a/App/WeldSeam/WeldSeamApp/Presenter/Inc/WeldSeamPresenter.h b/App/WeldSeam/WeldSeamApp/Presenter/Inc/WeldSeamPresenter.h
index dcf5f0fc..51359b76 100644
--- a/App/WeldSeam/WeldSeamApp/Presenter/Inc/WeldSeamPresenter.h
+++ b/App/WeldSeam/WeldSeamApp/Presenter/Inc/WeldSeamPresenter.h
@@ -58,6 +58,10 @@ protected:
     int InitAlgoParams() override;
     int ProcessAlgoDetection(
         std::vector<std::pair<EVzResultDataType, SVzLaserLineData>>& detectionDataCache) override;
+    bool OnDetectionData(EVzResultDataType dataType,
+                         SVzLaserLineData* laserData) override;
+    bool HasPendingDetectionData() const override;
+    void ClearDetectionDataCache() override;
     EVzResultDataType GetDetectionDataType() override { return keResultDataType_Position; }
     VzNL_OnNotifyStatusCBEx GetCameraStatusCallback() override;
     void OnCameraStatusChanged(int cameraIndex, bool isConnected) override;
diff --git a/App/WeldSeam/WeldSeamApp/Presenter/Src/DetectPresenter.cpp b/App/WeldSeam/WeldSeamApp/Presenter/Src/DetectPresenter.cpp
index 0fcc739e..7eec23ec 100644
--- a/App/WeldSeam/WeldSeamApp/Presenter/Src/DetectPresenter.cpp
+++ b/App/WeldSeam/WeldSeamApp/Presenter/Src/DetectPresenter.cpp
@@ -2,6 +2,7 @@
 
 #include "AlgorithmParamConverter.h"
 #include "PointCloudImageUtils.h"
+#include "SG_baseAlgo_Export.h"
 #include "SX_lapWeldDetection_Export.h"
 #include "VrDateUtils.h"
 #include "VrError.h"
@@ -13,19 +14,6 @@
 #include <QDir>
 #include <algorithm>
 
-SG_APISHARED_EXPORT void wd_getLineVFlaws(
-    std::vector<SVzNL3DPosition>& line,
-    int lineIndex,
-    SWD_valleyParam valleyParam,
-    std::vector<SSG_basicFeatureGap>& valleys);
-
-SG_APISHARED_EXPORT void sg_lineGapsGrowing(
-    int lineIndex,
-    bool isLastLine,
-    std::vector<SSG_basicFeatureGap>& features,
-    std::vector<SSG_gapFeatureTree>& trees,
-    SSG_treeGrowParam growParam);
-
 namespace {
 
 int ValidPointCount(const std::vector<SVzNL3DPosition>& line)
@@ -105,6 +93,49 @@ DetectPresenter::DetectPresenter()
     LOG_INFO("lapWeldDetection version: %s\n", wd_weldSeamAlgoVersion());
 }
 
+void DetectPresenter::ResetIncrementalData()
+{
+    std::lock_guard<std::mutex> lock(m_incrementalMutex);
+    m_incrementalScanLines.clear();
+    m_incrementalLineValleys.clear();
+}
+
+bool DetectPresenter::HasIncrementalData() const
+{
+    std::lock_guard<std::mutex> lock(m_incrementalMutex);
+    return !m_incrementalScanLines.empty();
+}
+
+bool DetectPresenter::ProcessDetectionLine(
+    EVzResultDataType dataType,
+    const SVzLaserLineData& lineData,
+    const VrAlgorithmParams& algorithmParams,
+    const SSG_planeCalibPara& groundCalibParam,
+    LaserDataLoader& dataLoader)
+{
+    std::vector<std::pair<EVzResultDataType, SVzLaserLineData>> oneLine;
+    oneLine.emplace_back(dataType, lineData);
+    std::vector<std::vector<SVzNL3DPosition>> converted;
+    if (dataLoader.ConvertToSVzNL3DPosition(oneLine, converted) != SUCCESS ||
+        converted.empty() || converted.front().empty() ||
+        ValidPointCount(converted.front()) == 0) {
+        return false;
+    }
+
+    std::vector<SVzNL3DPosition> scanLine = std::move(converted.front());
+    sx_lineDataR(scanLine, groundCalibParam.planeCalib, -1.0);
+    const WeldSeamAlgorithmParams params =
+        AlgorithmParamConverter::ToAlgorithmParams(algorithmParams);
+    std::vector<SSG_basicFeatureGap> valleys;
+    std::lock_guard<std::mutex> lock(m_incrementalMutex);
+    const int lineIndex = static_cast<int>(m_incrementalScanLines.size());
+    wd_getLineVFlaws(scanLine, lineIndex, params.valleyParam,
+                     params.detectFlawType, valleys);
+    m_incrementalScanLines.push_back(std::move(scanLine));
+    m_incrementalLineValleys.push_back(std::move(valleys));
+    return true;
+}
+
 QString DetectPresenter::GetAlgoVersion()
 {
     return QString::fromUtf8(wd_weldSeamAlgoVersion());
@@ -119,17 +150,24 @@ int DetectPresenter::DetectWeldSeam(
     LaserDataLoader& dataLoader,
     DetectionResult& detectionResult)
 {
-    if (laserLines.empty()) {
-        detectionResult.message = QStringLiteral("扫描数据为空");
-        return ERR_CODE(DEV_DATA_INVALID);
-    }
-
     std::vector<std::vector<SVzNL3DPosition>> scanLines;
-    const int convertResult = dataLoader.ConvertToSVzNL3DPosition(laserLines, scanLines);
-    RemoveEmptyEdgeLines(scanLines);
-    if (convertResult != SUCCESS || scanLines.empty()) {
-        detectionResult.message = QStringLiteral("扫描数据转换失败");
-        return ERR_CODE(DEV_DATA_INVALID);
+    std::vector<std::vector<SSG_basicFeatureGap>> preprocessedValleys;
+    const bool useIncrementalData = HasIncrementalData();
+    if (useIncrementalData) {
+        std::lock_guard<std::mutex> lock(m_incrementalMutex);
+        scanLines = m_incrementalScanLines;
+        preprocessedValleys = m_incrementalLineValleys;
+        if (scanLines.empty() || scanLines.size() != preprocessedValleys.size()) {
+            detectionResult.message = QStringLiteral("扫描数据为空");
+            return ERR_CODE(DEV_DATA_INVALID);
+        }
+    } else {
+        const int convertResult = dataLoader.ConvertToSVzNL3DPosition(laserLines, scanLines);
+        RemoveEmptyEdgeLines(scanLines);
+        if (convertResult != SUCCESS || scanLines.empty()) {
+            detectionResult.message = QStringLiteral("扫描数据转换失败");
+            return ERR_CODE(DEV_DATA_INVALID);
+        }
     }
 
     const WeldSeamAlgorithmParams params = AlgorithmParamConverter::ToAlgorithmParams(algorithmParams);
@@ -157,16 +195,22 @@ int DetectPresenter::DetectWeldSeam(
     }
 
     CVrTimeUtils timer;
-    for (auto& line : scanLines) {
-        sx_lineDataR(line, groundCalibParam.planeCalib, -1.0);
+    if (!useIncrementalData) {
+        for (auto& line : scanLines) {
+            sx_lineDataR(line, groundCalibParam.planeCalib, -1.0);
+        }
     }
 
     std::vector<SSG_gapFeatureTree> trees;
     trees.reserve(scanLines.size());
     for (size_t lineIndex = 0; lineIndex < scanLines.size(); ++lineIndex) {
         std::vector<SSG_basicFeatureGap> lineValleys;
-        wd_getLineVFlaws(scanLines[lineIndex], static_cast<int>(lineIndex),
-                         params.valleyParam, lineValleys);
+        if (useIncrementalData) {
+            lineValleys = preprocessedValleys[lineIndex];
+        } else {
+            wd_getLineVFlaws(scanLines[lineIndex], static_cast<int>(lineIndex),
+                             params.valleyParam, params.detectFlawType, lineValleys);
+        }
         const bool isLastLine = lineIndex + 1 == scanLines.size();
         sg_lineGapsGrowing(static_cast<int>(lineIndex), isLastLine,
                            lineValleys, trees, params.treeGrowParam);
diff --git a/App/WeldSeam/WeldSeamApp/Presenter/Src/WeldSeamPresenter.cpp b/App/WeldSeam/WeldSeamApp/Presenter/Src/WeldSeamPresenter.cpp
index da927d8a..39f7a5ba 100644
--- a/App/WeldSeam/WeldSeamApp/Presenter/Src/WeldSeamPresenter.cpp
+++ b/App/WeldSeam/WeldSeamApp/Presenter/Src/WeldSeamPresenter.cpp
@@ -85,6 +85,8 @@ int WeldSeamPresenter::InitAlgoParams()
              p.treeGrowParam.maxLineSkipNum, p.treeGrowParam.yDeviationMax,
              p.treeGrowParam.maxSkipDistance, p.treeGrowParam.zDeviationMax,
              p.treeGrowParam.minLTypeTreeLen, p.treeGrowParam.minVTypeTreeLen);
+    LOG_INFO("WeldSeam flaw type=%d\n",
+             static_cast<int>(p.weldSeamParam.detectFlawType));
     return SUCCESS;
 }
 
@@ -179,7 +181,7 @@ QString WeldSeamPresenter::StopDynamicScanAndDetect()
 
     // StopDetect 成功后才检查缓存。空扫描仍属于已受理的 STOP 请求：
     // 先让调用方返回 STOP_ACK，再在 Presenter 线程异步发布 RESULT_NG。
-    if (GetDetectionDataCacheSize() <= 0) {
+    if (!HasPendingDetectionData()) {
         UpdateModbusStatus(2);
         OnStatusUpdate("动态扫描已结束，未采集到有效数据");
         QMetaObject::invokeMethod(this, [this]() {
@@ -240,6 +242,13 @@ int WeldSeamPresenter::ProcessAlgoDetection(
     int code = ERR_CODE(DEV_NOT_FIND);
     if (m_pDetectPresenter && m_pConfigManager) {
         const ConfigResult config = m_pConfigManager->GetConfigResult();
+        // Live WeldSeam scans are preprocessed line-by-line. The base cache is
+        // only populated in debug mode for persistence, so release that copy
+        // before asking DetectPresenter to consume its incremental data.
+        if (m_pDetectPresenter->HasIncrementalData() && !detectionDataCache.empty()) {
+            m_dataLoader.FreeLaserScanData(detectionDataCache);
+            detectionDataCache.clear();
+        }
         code = m_pDetectPresenter->DetectWeldSeam(
             m_currentCameraIndex, detectionDataCache, config.algorithmParams,
             GetCameraCalibParam(m_currentCameraIndex), config.debugParam, m_dataLoader, result);
@@ -264,6 +273,39 @@ int WeldSeamPresenter::ProcessAlgoDetection(
     return code;
 }
 
+bool WeldSeamPresenter::OnDetectionData(EVzResultDataType dataType,
+                                         SVzLaserLineData* laserData)
+{
+    if (!laserData || !m_pDetectPresenter || !m_pConfigManager ||
+        dataType != keResultDataType_Position) {
+        return false;
+    }
+
+    const ConfigResult config = m_pConfigManager->GetConfigResult();
+    const bool processed = m_pDetectPresenter->ProcessDetectionLine(
+        dataType, *laserData, config.algorithmParams,
+        GetCameraCalibParam(m_currentCameraIndex), m_dataLoader);
+    if (!processed) {
+        LOG_WARNING("WeldSeam failed to preprocess one point-cloud line\n");
+        return true;
+    }
+
+    // Keep the original line only when debug persistence is enabled. In the
+    // normal path BasePresenter immediately drops its temporary callback data.
+    return !config.debugParam.enableDebug;
+}
+
+bool WeldSeamPresenter::HasPendingDetectionData() const
+{
+    return m_pDetectPresenter && m_pDetectPresenter->HasIncrementalData();
+}
+
+void WeldSeamPresenter::ClearDetectionDataCache()
+{
+    BasePresenter::ClearDetectionDataCache();
+    if (m_pDetectPresenter) m_pDetectPresenter->ResetIncrementalData();
+}
+
 int WeldSeamPresenter::LoadAndDetect(const QString& fileName)
 {
     ScanState expected = ScanState::Ready;
diff --git a/App/WeldSeam/WeldSeamApp/Version.h b/App/WeldSeam/WeldSeamApp/Version.h
index 3b9b49a2..5855d1e3 100644
--- a/App/WeldSeam/WeldSeamApp/Version.h
+++ b/App/WeldSeam/WeldSeamApp/Version.h
@@ -2,7 +2,7 @@
 #define WELDSEAM_VERSION_H
 
 #define WELDSEAM_APP_NAME "焊缝定位"
-#define WELDSEAM_VERSION_STRING "1.0.0"
+#define WELDSEAM_VERSION_STRING "1.0.1"
 #define WELDSEAM_BUILD_STRING "1"
 #define WELDSEAM_FULL_VERSION_STRING "V" WELDSEAM_VERSION_STRING "_" WELDSEAM_BUILD_STRING
 
diff --git a/App/WeldSeam/WeldSeamApp/Version.md b/App/WeldSeam/WeldSeamApp/Version.md
index f8a16d33..858aaa3c 100644
--- a/App/WeldSeam/WeldSeamApp/Version.md
+++ b/App/WeldSeam/WeldSeamApp/Version.md
@@ -1,6 +1,8 @@
-# WeldSeam 版本记录
+# 1.0.1
+## build_1
+1. 更新算法版本，增加了焊缝类型
 
-## 1.0.0
+# 1.0.0
 
 - 使用 VzNLSDK 非摆动动态扫描模式。
 - 实现 `START_SCAN` / `STOP_SCAN` TCP 交互流程。
diff --git a/App/WeldSeam/WeldSeamApp/WeldSeamApp.pro b/App/WeldSeam/WeldSeamApp/WeldSeamApp.pro
index 74789cc0..85e2303b 100644
--- a/App/WeldSeam/WeldSeamApp/WeldSeamApp.pro
+++ b/App/WeldSeam/WeldSeamApp/WeldSeamApp.pro
@@ -4,7 +4,8 @@ QT       += core gui network serialport
 
 greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 
-CONFIG += c++17
+# OpenCV 3.2 still uses std::random_shuffle, which was removed in C++17.
+CONFIG += c++14
 
 # 项目名称
 TARGET = WeldSeamApp
@@ -148,6 +149,8 @@ else:unix:!macx: {
 
 # 焊缝检测算法（lapWeldDetection）
 INCLUDEPATH += ../../../AppAlgo/lapWeldDetection/Inc
+# OpenCV 3.2 headers required by SG_baseAlgo_Export.h
+INCLUDEPATH += $$PWD/../../../SDK/OpenCV320/include
 
 win32:CONFIG(release, debug|release): {
     LIBS += -L$$PWD/../../../AppAlgo/lapWeldDetection/Windows/x64/Release -llapWeldDetection -lbaseAlgorithm
diff --git a/App/WeldSeam/WeldSeamApp/dialogalgoarg.cpp b/App/WeldSeam/WeldSeamApp/dialogalgoarg.cpp
index b93ba6ea..df8f472f 100644
--- a/App/WeldSeam/WeldSeamApp/dialogalgoarg.cpp
+++ b/App/WeldSeam/WeldSeamApp/dialogalgoarg.cpp
@@ -11,6 +11,7 @@
 #include <QIntValidator>
 #include <QLineEdit>
 #include <QMessageBox>
+#include <QComboBox>
 
 #include <cmath>
 #include <cstring>
@@ -34,6 +35,10 @@ DialogAlgoArg::DialogAlgoArg(QWidget* parent)
 {
     ui->setupUi(this);
     setWindowTitle(QStringLiteral("焊缝定位 - 算法参数设置"));
+    ui->comboDetectFlawType->addItem(QStringLiteral("未知/全部"), 0);
+    ui->comboDetectFlawType->addItem(QStringLiteral("凹陷"), 1);
+    ui->comboDetectFlawType->addItem(QStringLiteral("凸起"), 2);
+    ui->comboDetectFlawType->addItem(QStringLiteral("凹陷+凸起"), 3);
     InitNumericEditors();
     InitCommunicationWidgets();
 }
@@ -149,6 +154,9 @@ void DialogAlgoArg::Load()
     SetDoubleText(ui->editMinLTypeTreeLen, p.treeGrowParam.minLTypeTreeLen);
     SetDoubleText(ui->editMinVTypeTreeLen, p.treeGrowParam.minVTypeTreeLen);
     SetIntText(ui->editWeldRefPoints, p.weldSeamParam.weldRefPoints);
+    const int flawType = static_cast<int>(p.weldSeamParam.detectFlawType);
+    const int flawTypeIndex = ui->comboDetectFlawType->findData(flawType);
+    ui->comboDetectFlawType->setCurrentIndex(flawTypeIndex >= 0 ? flawTypeIndex : 0);
     SetIntText(ui->editTcpPort, config.tcpPort);
     LoadCommunicationConfig();
 }
@@ -225,6 +233,14 @@ bool DialogAlgoArg::Save()
                       p.treeGrowParam.minVTypeTreeLen)) return false;
     if (!TryGetInt(ui->editWeldRefPoints, QStringLiteral("焊缝中间参考点数"),
                    p.weldSeamParam.weldRefPoints)) return false;
+    const int flawType = ui->comboDetectFlawType->currentData().toInt();
+    if (flawType < static_cast<int>(keWD_FlawType_Uknown) ||
+        flawType > static_cast<int>(keSG_FlawType_Dep_Prot)) {
+        StyledMessageBox::warning(this, QStringLiteral("参数错误"),
+                                  QStringLiteral("焊缝类型无效。"));
+        return false;
+    }
+    p.weldSeamParam.detectFlawType = static_cast<EWD_FlawType>(flawType);
 
     int tcpPort = 0;
     if (!TryGetInt(ui->editTcpPort, QStringLiteral("TCP 服务端口"), tcpPort)) return false;
diff --git a/App/WeldSeam/WeldSeamApp/dialogalgoarg.ui b/App/WeldSeam/WeldSeamApp/dialogalgoarg.ui
index 6043bc15..4fd1a031 100644
--- a/App/WeldSeam/WeldSeamApp/dialogalgoarg.ui
+++ b/App/WeldSeam/WeldSeamApp/dialogalgoarg.ui
@@ -140,6 +140,23 @@ QGroupBox::title { subcontrol-origin: margin; left: 10px; padding: 0 3px 0 3px;
             </property>
            </widget>
           </item>
+          <item row="1" column="0">
+           <widget class="QLabel" name="label_detectFlawType">
+            <property name="text">
+             <string>焊缝类型:</string>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="1">
+           <widget class="QComboBox" name="comboDetectFlawType">
+            <property name="minimumSize">
+             <size>
+              <width>200</width>
+              <height>35</height>
+             </size>
+            </property>
+           </widget>
+          </item>
          </layout>
         </widget>
        </item>
diff --git a/App/WeldSeam/WeldSeamConfig/Inc/AlgorithmParamConverter.h b/App/WeldSeam/WeldSeamConfig/Inc/AlgorithmParamConverter.h
index 1396110c..99e4e035 100644
--- a/App/WeldSeam/WeldSeamConfig/Inc/AlgorithmParamConverter.h
+++ b/App/WeldSeam/WeldSeamConfig/Inc/AlgorithmParamConverter.h
@@ -9,6 +9,7 @@ struct WeldSeamAlgorithmParams
     SWD_valleyParam valleyParam{};
     SSG_treeGrowParam treeGrowParam{};
     int weldRefPoints = 3;
+    EWD_FlawType detectFlawType = keWD_FlawType_Uknown;
 };
 
 class AlgorithmParamConverter
diff --git a/App/WeldSeam/WeldSeamConfig/Inc/IVrConfig.h b/App/WeldSeam/WeldSeamConfig/Inc/IVrConfig.h
index b88b9a4a..9b69ab5b 100644
--- a/App/WeldSeam/WeldSeamConfig/Inc/IVrConfig.h
+++ b/App/WeldSeam/WeldSeamConfig/Inc/IVrConfig.h
@@ -7,6 +7,7 @@
 
 #include "VrCommonConfig.h"
 #include "VrHandEyeCalibConfig.h"
+#include "SG_baseDataType.h"
 
 // 参数默认值与 AppAlgo/lapWeldDetection/lapWeldDetection_test.cpp
 // 中 BQ_thinWeldSeamTest 的 BQ_getWeldSeamPose 调用保持一致。
@@ -30,6 +31,7 @@ struct VrTreeGrowParam
 struct VrWeldSeamParam
 {
     int weldRefPoints = 3;
+    EWD_FlawType detectFlawType = keWD_FlawType_Uknown;
 };
 
 struct VrAlgorithmParams
diff --git a/App/WeldSeam/WeldSeamConfig/Src/AlgorithmParamConverter.cpp b/App/WeldSeam/WeldSeamConfig/Src/AlgorithmParamConverter.cpp
index 46b6e3bb..713718c1 100644
--- a/App/WeldSeam/WeldSeamConfig/Src/AlgorithmParamConverter.cpp
+++ b/App/WeldSeam/WeldSeamConfig/Src/AlgorithmParamConverter.cpp
@@ -14,5 +14,6 @@ WeldSeamAlgorithmParams AlgorithmParamConverter::ToAlgorithmParams(const VrAlgor
     result.treeGrowParam.minLTypeTreeLen = params.treeGrowParam.minLTypeTreeLen;
     result.treeGrowParam.minVTypeTreeLen = params.treeGrowParam.minVTypeTreeLen;
     result.weldRefPoints = params.weldSeamParam.weldRefPoints;
+    result.detectFlawType = params.weldSeamParam.detectFlawType;
     return result;
 }
diff --git a/App/WeldSeam/WeldSeamConfig/Src/VrConfig.cpp b/App/WeldSeam/WeldSeamConfig/Src/VrConfig.cpp
index 45d7c798..2ffa9285 100644
--- a/App/WeldSeam/WeldSeamConfig/Src/VrConfig.cpp
+++ b/App/WeldSeam/WeldSeamConfig/Src/VrConfig.cpp
@@ -33,6 +33,12 @@ void LoadAlgorithmParams(XMLElement* algoElement, VrAlgorithmParams& params)
 
     if (XMLElement* e = algoElement->FirstChildElement("WeldSeamParam")) {
         e->QueryIntAttribute("weldRefPoints", &params.weldSeamParam.weldRefPoints);
+        int detectFlawType = static_cast<int>(params.weldSeamParam.detectFlawType);
+        if (e->QueryIntAttribute("detectFlawType", &detectFlawType) == XML_SUCCESS &&
+            detectFlawType >= static_cast<int>(keWD_FlawType_Uknown) &&
+            detectFlawType <= static_cast<int>(keSG_FlawType_Dep_Prot)) {
+            params.weldSeamParam.detectFlawType = static_cast<EWD_FlawType>(detectFlawType);
+        }
     }
 
     // 解析多相机平面校准参数
@@ -58,6 +64,8 @@ void SaveAlgorithmParams(XMLDocument& doc, XMLElement* algoElement, const VrAlgo
 
     XMLElement* weldElement = doc.NewElement("WeldSeamParam");
     weldElement->SetAttribute("weldRefPoints", params.weldSeamParam.weldRefPoints);
+    weldElement->SetAttribute("detectFlawType",
+                              static_cast<int>(params.weldSeamParam.detectFlawType));
     algoElement->InsertEndChild(weldElement);
 
     // 多相机平面校准参数
diff --git a/App/WeldSeam/WeldSeamConfig/config/config.xml b/App/WeldSeam/WeldSeamConfig/config/config.xml
index add597e6..37ae2b39 100644
--- a/App/WeldSeam/WeldSeamConfig/config/config.xml
+++ b/App/WeldSeam/WeldSeamConfig/config/config.xml
@@ -9,7 +9,7 @@
         <TreeGrowParam maxLineSkipNum="50" yDeviationMax="1"
             maxSkipDistance="30" zDeviationMax="5"
             minLTypeTreeLen="50" minVTypeTreeLen="50"/>
-        <WeldSeamParam weldRefPoints="3"/>
+        <WeldSeamParam weldRefPoints="3" detectFlawType="0"/>
         <PlaneCalibParams/>
     </AlgorithmParams>
 
diff --git a/AppAlgo/lapWeldDetection/Arm/aarch64/libbaseAlgorithm.so b/AppAlgo/lapWeldDetection/Arm/aarch64/libbaseAlgorithm.so
index 4dde63c4..dfc8c33c 100644
Binary files a/AppAlgo/lapWeldDetection/Arm/aarch64/libbaseAlgorithm.so and b/AppAlgo/lapWeldDetection/Arm/aarch64/libbaseAlgorithm.so differ
diff --git a/AppAlgo/lapWeldDetection/Arm/aarch64/liblapWeldDetection.so b/AppAlgo/lapWeldDetection/Arm/aarch64/liblapWeldDetection.so
index 4fe60fab..796aa3e1 100644
Binary files a/AppAlgo/lapWeldDetection/Arm/aarch64/liblapWeldDetection.so and b/AppAlgo/lapWeldDetection/Arm/aarch64/liblapWeldDetection.so differ
diff --git a/AppAlgo/lapWeldDetection/Inc/SG_baseAlgo_Export.h b/AppAlgo/lapWeldDetection/Inc/SG_baseAlgo_Export.h
new file mode 100644
index 00000000..cfd82f6b
--- /dev/null
+++ b/AppAlgo/lapWeldDetection/Inc/SG_baseAlgo_Export.h
@@ -0,0 +1,1137 @@
+#pragma once
+
+#include "SG_algo_Export.h"
+#include <vector>
+#include <opencv2/opencv.hpp>
+
+//�������
+SG_APISHARED_EXPORT SVzNL3DPoint vec3_cross(const SVzNL3DPoint& a, const SVzNL3DPoint& b);
+// ��������
+SG_APISHARED_EXPORT SVzNL3DPoint vec3_multiply(const SVzNL3DPoint& a, const double s);
+// ��� dot
+SG_APISHARED_EXPORT double vec3_dotMultiply(const SVzNL3DPoint& a, const SVzNL3DPoint& b);
+// ģ��
+SG_APISHARED_EXPORT double vec3_length(const SVzNL3DPoint& a);
+// ��һ������λ������
+SG_APISHARED_EXPORT SVzNL3DPoint vec3_normalize(const SVzNL3DPoint& a);
+// �������������нǣ����� �Ƕȣ�
+SG_APISHARED_EXPORT float vec3_computeVecAngle(const SVzNL3DPoint& a, const SVzNL3DPoint& b);
+//����ת
+SG_APISHARED_EXPORT SVzNL3DPoint wd_ptRotate(SVzNL3DPoint pt3D, const double matrix3d[9]);
+//��ά����ת
+SG_APISHARED_EXPORT SVzNL2DPointD wd_pt2dRotate(SVzNL2DPointD pt2D_in, double rotateAngle);
+//���������ֵ�������׼��
+SG_APISHARED_EXPORT void CalcStats(const std::vector<double>& data, SSG_meanVar& result);
+
+/**
+ * @brief ƽ�������� v ��ƽ�淨���� n ��ת theta ����
+ * ��v ������ƽ���ڣ��Զ�ʹ�ü򻯰��޵����˹��
+ */
+SG_APISHARED_EXPORT SVzNL3DPoint wd_rotateVectorInPlane(const SVzNL3DPoint& v, const SVzNL3DPoint& n, double theta);
+
+//��ʱ����תʱ �� > 0 ��˳ʱ����תʱ �� < 0 
+SG_APISHARED_EXPORT SVzNL3DPoint wd_rotate2D(const SVzNL3DPoint& pt, const double angle);
+
+//�˳���Ⱥ��:z�������޷���������������Ϊ�����������������ε������ж�������
+SG_APISHARED_EXPORT void sg_lineDataRemoveOutlier(
+    SVzNL3DPosition* lineData, 
+    int dataSize, 
+    SSG_outlierFilterParam filterParam, 
+    std::vector<SVzNL3DPosition>& filerData, 
+    std::vector<int>& noisePts);
+//�˳���Ⱥ�㣺z�������޷���,�ı�ԭʼ����
+SG_APISHARED_EXPORT void sg_lineDataRemoveOutlier_changeOriginData(
+    SVzNL3DPosition* lineData, 
+    int dataSize, 
+    SSG_outlierFilterParam filterParam);
+//�˳���Ⱥ�㣺z�������޷���, vecotr����
+SG_APISHARED_EXPORT void wd_vectorDataRemoveOutlier_overwrite(
+    std::vector<SVzNL3DPosition>& a_line,
+    SSG_outlierFilterParam filterParam);
+//�˳���Ⱥ�㣺��������޷���������������Ϊ�����������������ε������ж�������
+SG_APISHARED_EXPORT void sg_lineDataRemoveOutlier_ptDistMethod(
+    SVzNL3DPosition* lineData,
+    int dataSize,
+    SSG_outlierFilterParam filterParam,
+    std::vector<SVzNL3DPosition>& filerData,
+    std::vector<int>& noisePts);
+
+//ƽ��
+SG_APISHARED_EXPORT void sg_lineDataSmoothing(
+    std::vector<SVzNL3DPosition>& input, 
+    int smoothWin, 
+    std::vector<SVzNL3DPosition>& output);
+//�ֶ�ƽ������������Ӱ��ֶζ˵�
+SG_APISHARED_EXPORT void sg_lineSegSmoothing(
+    std::vector<SVzNL3DPosition>& input,
+    double seg_y_deltaTh, //�ֶε�Y��������ڴ˼����Ϊ�µķֶ�
+    double seg_z_deltaTh,//�ֶε�Z��������ڴ˼����Ϊ�µķֶ�
+    int smoothWin,
+    std::vector<SVzNL3DPosition>& output);
+
+//VZ_APISHARED_EXPORT void sg_getLineMeanVar();
+SG_APISHARED_EXPORT void sg_getLineLVFeature(
+    SVzNL3DPosition* lineData, 
+    int dataSize, 
+    int lineIdx, 
+    const SSG_slopeParam slopeParam, 
+    const SSG_VFeatureParam valleyPara, 
+    SSG_lineFeature* line_features);
+
+//��ȡɨ���߹յ�����
+SG_APISHARED_EXPORT void sg_getLineCornerFeature(
+    SVzNL3DPosition* lineData,
+    int dataSize,
+    int lineIdx,
+    const SSG_cornerParam cornerPara, //scaleͨ��ȡbagH��1/4
+    SSG_lineFeature* line_features);
+
+// �Լ���������Mask(nPointIdxת�嶨�壩ָ���ĵ���ȡ�������ϵĹյ�����
+SG_APISHARED_EXPORT void sg_maskData_getLineCornerFeature(
+    std::vector< SVzNL3DPosition>& lineData,
+    int lineIdx,
+    int maskID,
+    const SSG_cornerParam cornerPara, //scaleͨ��ȡbagH��1/4
+    std::vector<SSG_basicFeature1D>& features);
+
+//��ȡGap������Gap����������������Corner���ɵ�����
+SG_APISHARED_EXPORT void sg_getLineGapFeature(
+    std::vector<SVzNL3DPosition>& lineData, //ɨ����
+    int lineIdx, //��ǰɨ�������
+    const SSG_cornerParam cornerPara,
+    const SVzNLRangeD gapParam,
+    std::vector<SSG_basicFeatureGap>& line_gaps);
+
+SG_APISHARED_EXPORT void sg_getLineCornerFeature_BQ(
+    SVzNL3DPosition* lineData,
+    int dataSize,
+    int lineIdx,
+    double refSteppingZ,
+    const SSG_cornerParam cornerPara, 
+    std::vector<SSG_basicFeature1D>& line_features);
+
+/// <summary>
+/// ��ȡ�������ϵĹյ�����������˵㸽���Ĺյ���Ϊ�ϸ�յ�
+/// ����Seg����corner��ȡ
+/// nPointIdx�����¶����Feature����
+/// �㷨���̣�
+/// ��1��������ǰ��Ǻͺ����
+/// ��2��������սǣ�˳ʱ��Ϊ������ʱ��Ϊ��
+/// ��3���������սǵļ���ֵ��
+/// ��4���жϹս��Ƿ�Ϊ����
+/// </summary>
+SG_APISHARED_EXPORT void sg_getLineContourCornerFeature_groundMask_BQ(
+    std::vector<SVzNL3DPosition>& lineData,
+    std::vector<int> groundMask,
+    int lineIdx,
+    double contourWin, //ground��Ե��Χ
+    const SSG_cornerParam cornerPara, //scaleͨ��ȡbagH��1/4
+    std::vector<SSG_basicFeature1D>& line_features);
+
+SG_APISHARED_EXPORT void wd_getLineDataIntervals(
+    std::vector<SVzNL3DPosition>& lineData,
+    const SSG_lineSegParam lineSegPara,
+    std::vector<SSG_RUN>& segs);
+
+//��ȡGap��
+SG_APISHARED_EXPORT void wd_getLineDataNullIntervals(
+    std::vector<SVzNL3DPosition>& lineData,
+    const SSG_lineSegParam lineSegPara,
+    std::vector<SSG_RUN>& segs);
+
+// ��С�㼯������С�ڴ����޷����ֱ�ߣ�
+const int MIN_POINT_COUNT = 3;
+//ʹ�ö˵�ֱ�ߣ����㵽ֱ�ߵľ��룬�������޵ķָ�
+SG_APISHARED_EXPORT void split(
+    SSG_RUN a_run,
+    std::vector< SVzNL3DPosition>& lineData,
+    const double maxError,
+    std::vector< SSG_RUN>& lineSegs);
+
+/// <summary>
+/// ��ȡ�������ϵ����������䡢����z��ֵ��V��L�ͣ�����������⣨PSM)
+/// seg�˵㣺z�����������
+/// nPointIdx�����¶����Feature����
+/// �㷨���̣�
+/// ��1��������ǰ��Ǻͺ����
+/// ��2��������սǣ�˳ʱ��Ϊ������ʱ��Ϊ��
+/// ��3���������սǵļ���ֵ��
+/// ��4���жϹս��Ƿ�Ϊ����
+/// </summary>
+SG_APISHARED_EXPORT void wd_getLineCornerFeature_PSM(
+    SVzNL3DPosition* lineData,
+    int dataSize,
+    int lineIdx,
+    const double groundZ,
+    const SSG_cornerParam cornerPara,
+    SSG_lineFeature* line_features);
+
+//���ݾ��������Էֶ�
+SG_APISHARED_EXPORT void wd_lineDataSegment_dist(
+    std::vector< SWD3DPointPostion>& lineData,
+    std::vector<SSG_RUN>& segs,
+    const double maxDistTh,
+    const int minSegSize
+);
+
+//���ݾ��������Էֶ�
+SG_APISHARED_EXPORT void wd_lineDataSegment_dist_2(
+    std::vector< SVzNL3DPosition>& lineData,
+    std::vector<SSG_RUN>& segs,
+    const double maxDistTh,
+    const double minSegSize
+);
+
+SG_APISHARED_EXPORT void wd_lineDataSegment_zDist(
+    std::vector< SVzNL3DPosition>& lineData,
+    std::vector< SVzNL3DPosition>& vldPts,
+    std::vector<SSG_RUN_EX>& segs,
+    std::vector<int>& backIndexing,
+    const SSG_cornerParam cornerPara
+);
+
+//���㷽���(���ֶΣ�
+SG_APISHARED_EXPORT void wd_computeDirAngle_wholeLine(
+    std::vector< SVzNL3DPosition>& line_data,
+    const SSG_cornerParam cornerPara,
+    std::vector< SSG_pntDirAngle>& ptDirAngles
+);
+
+//���㷽���(���ֶΣ�:�ڼ���scale��ǰ���£�����������������ʱ�Ĵ�����
+SG_APISHARED_EXPORT void wd_computeDirAngle_wholeLine2(
+    std::vector< SVzNL3DPosition>& line_data,
+    const double steppingScale,
+    const double invalidScale, //�����˳߶ȣ�����Ǽ�����Ч
+    std::vector< SSG_pntDirAngle>& ptDirAngles
+);
+
+/// ��ȡ�������ϵ�Բ�����ϰ�λ���������Բ���Ŀ���ȷ��
+/// seg�˵㣺z�����������
+/// nPointIdx�����¶����Feature����
+/// �㷨���̣�
+/// ��1��������ǰ��Ǻͺ����
+/// ��2��������սǣ�˳ʱ��Ϊ������ʱ��Ϊ��
+/// ��3���������սǵļ���ֵ��
+/// ��4���жϹս��Ƿ�Ϊ����
+/// </summary>
+SG_APISHARED_EXPORT void wd_getRingArcFeature(
+    std::vector< SVzNL3DPosition>& lineData,
+    int lineIdx,
+    const SSG_cornerParam cornerPara,
+    SVzNLRangeD ringArcWidth, //���ӵĻ�����
+    std::vector<SWD_segFeature>& line_ringArcs  //��
+);
+//���������������ݰ���Arc�Ķ���������Z��Сֵ���������Z��Сֵ���Ĺս����
+SG_APISHARED_EXPORT void wd_getRodArcFeature_peakCornerMethod(
+    std::vector< SVzNL3DPosition>& lineData,
+    int lineIdx,
+    const double peakChkWin,
+    const SSG_cornerParam cornerPara,
+    std::vector<SWD_rodArcFeature>& line_rodArcs  //��
+);
+
+/// <summary>
+/// ͨ������YZƽ���ڵ����ʷ�����ȡԲ����
+/// seg�˵㣺z�����������
+/// </summary>
+SG_APISHARED_EXPORT void wd_getRodArcFeature_YZCurvatureMethod(
+    std::vector< SVzNL3DPosition>& lineData,
+    int lineIdx,
+    const double maxDistTh,
+    const double minSegSize,
+    const double curvatureWin,
+    const double rodDiameter,
+    const double arcTotalCornerMinValue,
+    std::vector<SWD_rodArcFeature>& line_rodArcs  //��
+);
+
+/// <summary>
+/// ��ȡ�������ϵ�Բ�����ϰ�λ���
+/// seg�˵㣺z�����������
+/// nPointIdx�����¶����Feature����
+/// �㷨���̣�
+/// ��1����μ���ǰ��Ǻͺ����
+/// ��2������ͬ����Ĺս�������
+/// ��2������Z��ֵ��
+/// ��2��������սǣ�˳ʱ��Ϊ������ʱ��Ϊ��
+/// ��3���������սǵļ���ֵ��
+/// ��4���жϹս��Ƿ�Ϊ����
+/// 
+/// </summary>
+SG_APISHARED_EXPORT void wd_getRodArcFeature_segmentPeakCornerMethod(
+    std::vector< SVzNL3DPosition>& lineData,
+    int lineIdx,
+    const double maxDistTh,
+    const double minSegSize,
+    const double peakChkWin,
+    const SSG_cornerParam cornerPara,
+    bool doSmoothing,
+    std::vector<SWD_rodArcFeature>& line_rodArcs  //��
+);
+
+//��ȡcorner��ֵ������ʵ�ֺ�������ʹ�ô˺������д����Ż���
+SG_APISHARED_EXPORT void wd_searchCornerPeaks(
+    std::vector< SSG_pntDirAngle>& corners,
+    std::vector< SVzNL3DPosition>& vldPts,
+    const double minCornerTh,
+    double cornerMergeScale,
+    std::vector< SSG_pntDirAngle>& cornerPeakP,
+    std::vector< SSG_pntDirAngle>& cornerPeakM
+);
+
+//��ȡbackwardAngle��ֵ������ʵ�ֺ�������ʹ�ô˺������д����Ż���
+SG_APISHARED_EXPORT void wd_searchBackwardAnglePeaks(
+    std::vector< SSG_pntDirAngle>& corners,
+    std::vector< SVzNL3DPosition>& vldPts,
+    const double minCornerTh,
+    double cornerMergeScale,
+    std::vector< SSG_pntDirAngle>& backwardAnglePeakP,
+    std::vector< SSG_pntDirAngle>& backwardAnglePeakM
+);
+
+//��ȡforwardAngle��ֵ������ʵ�ֺ�������ʹ�ô˺������д����Ż���
+SG_APISHARED_EXPORT void wd_searchForwardAnglePeaks(
+    std::vector< SSG_pntDirAngle>& corners,
+    std::vector< SVzNL3DPosition>& vldPts,
+    const double minCornerTh,
+    double cornerMergeScale,
+    std::vector< SSG_pntDirAngle>& forwardAnglePeakP,
+    std::vector< SSG_pntDirAngle>& forwardAnglePeakM
+);
+
+/// <summary>
+/// ��ȡ�������ϵĹյ�����������PSM�� LVTypeFeature, BQ�ȹյ��㷨�Ļ����ϵİ汾��
+/// nPointIdx�����¶����Feature����
+/// �㷨���̣�
+/// ��1��������ǰ��Ǻͺ����
+/// ��2��������սǣ�˳ʱ��Ϊ������ʱ��Ϊ��
+/// ��3���������սǵļ���ֵ��
+/// ��4���жϹս��Ƿ�Ϊ����
+/// </summary>
+SG_APISHARED_EXPORT void wd_getLineCorerFeature(
+    std::vector< SVzNL3DPosition>& lineData,
+    int lineIdx,
+    const SSG_cornerParam cornerPara,
+    std::vector<SSG_basicFeature1D>& line_cornerFeatures  //�յ�
+);
+
+/// <summary>
+/// ��ȡ�������ϵ���XYƽ�洹ֱ����������ֱ�Σ�
+/// </summary>
+SG_APISHARED_EXPORT void wd_getXYVertialFeature_dirAngleMethod(
+    std::vector< SVzNL3DPosition>& lineData,
+    int lineIdx,
+    const SSG_cornerParam cornerPara,
+    std::vector<int>& xyVerticalFlags  //��
+);
+/// <summary>
+/// ������ȡ�������ϵ���XYƽ�洹ֱ����������ֱ�Σ�
+/// </summary>
+SG_APISHARED_EXPORT void wd_getXYVertialFeature_perSeg_dirAngleMethod(
+    std::vector< SVzNL3DPosition>& lineData,
+    std::vector<SSG_RUN>& segs,
+    int lineIdx,
+    const SSG_cornerParam cornerPara,
+    std::vector<int>& xyVerticalFlags
+);
+
+/// <summary>
+/// ��ȡ�������ϵ���XYƽ��ˮƽ��������ˮƽ�Σ�
+/// </summary>
+SG_APISHARED_EXPORT void wd_getXYHorizontalFeature_dirAngleMethod(
+    std::vector< SVzNL3DPosition>& lineData,
+    int lineIdx,
+    const double maxDistTh,
+    const double minSegSize,
+    const SSG_cornerParam cornerPara,
+    std::vector<int>& xyHorizontalFlags
+);
+
+SG_APISHARED_EXPORT void wd_getRimConvexFeature(
+    std::vector< SVzNL3DPosition>& lineData,
+    std::vector<SSG_RUN>& segs,
+    int lineIdx,
+    const SWDRimEdgeParam rimPara_1,
+    const SWDRimEdgeParam rimPara_2,
+    const SVzNLRangeD rimWidth,
+    std::vector<SSG_RUN>& rimFeatures
+);
+
+/// ��ȡ�������ϵĹյ�����������PSM�� LVTypeFeature, BQ�ȹյ��㷨�Ļ����ϵİ汾��
+/// ʹ��ƽ�������м���
+/// nPointIdx�����¶����Feature����
+/// �㷨���̣�
+/// ��1��������ǰ��Ǻͺ����
+/// ��2��������սǣ�˳ʱ��Ϊ������ʱ��Ϊ��
+/// ��3���������սǵļ���ֵ��
+/// ��4���жϹս��Ƿ�Ϊ����
+/// </summary>
+SG_APISHARED_EXPORT void wd_getLineCorerFeature_accelerate(
+    std::vector< SVzNL3DPosition>& lineData,
+    int lineIdx,
+    const SSG_cornerParam cornerPara,
+    const double pointInterval,
+    std::vector<SSG_RUN_EX>& segs,
+    std::vector<SSG_basicFeature1D>& line_cornerFeatures  //�յ�����
+);
+
+//��ȡ͹���
+SG_APISHARED_EXPORT void wd_getLineRaisedFeature(
+    std::vector< SVzNL3DPosition>& lineData,
+    int lineIdx,
+    SSG_raisedFeatureParam raisedFeaturePara, //͹�����
+    std::vector<SWD_segFeature>& line_raisedFeatures  //͹��
+);
+
+//��ȡָ������߶ȵ�������
+SG_APISHARED_EXPORT void wd_getSpecifiedHeightJumping(
+    std::vector< SVzNL3DPosition>& lineData,
+    int lineIdx,
+    SVzNLRangeD jumpHeight, //����߶Ȳ���
+    std::vector<SSG_basicFeature1D>& line_jumpFeatures  //����
+);
+
+//ֱ��������ȡ����split-and-merge�����˼򻯣�������յ�ֱ�ߴ������ֱ��
+SG_APISHARED_EXPORT void wd_surfaceLineSegment(
+    std::vector< SVzNL3DPosition>& lineData,
+    int lineIdx,
+    SVzNLRangeD lineLenRange,
+    const SSG_lineSegParam lineSegPara,
+    std::vector<SSG_featureSemiCircle>& lineSegs,
+    std::vector<SSG_featureSemiCircle>& invlaidLineSegs);
+
+#if 0
+//��һ����ı�Ե����������ȡ��
+//���㷨���Ȼ�ȡɨ�����ϸ����Σ�Ȼ��ԶεĶ˵���д������õ���Ե����
+void wd_getSurfaceEdgeFeatures(
+    std::vector< SVzNL3DPosition>& lineData,
+    int lineIdx,
+    const SSG_lineSegParam lineSegPara,
+    std::vector<SWDIndexing3DPoint>& edgeFeatures);
+#endif
+
+/// <summary>
+/// ��ȡ�������ϵ�Z��Jumping����
+/// </summary>
+SG_APISHARED_EXPORT void sg_getLineZJumpFeature_cornerMethod(
+    SVzNL3DPosition* lineData,
+    int dataSize,
+    int lineIdx,
+    const SSG_cornerParam cornerPara, 
+    const bool getTopEdge,
+    std::vector< SSG_basicFeature1D>& jumpFeatures);
+
+/// <summary>
+/// ��ȡ�������ϵ�L��Jumping����
+/// </summary>
+SG_APISHARED_EXPORT void sg_getLineLJumpFeature_cornerMethod(
+    SVzNL3DPosition* lineData,
+    int dataSize,
+    int lineIdx,
+    const SSG_cornerParam cornerPara,
+    const bool getTopEdge,
+    std::vector< SSG_basicFeature1D>& jumpFeatures);
+
+SG_APISHARED_EXPORT void wd_getLineGloveArcs(
+    std::vector<SVzNL3DPosition>& lineData,
+    int lineIdx,
+    const SSG_gloveArcParam arcPara,
+    std::vector<SSG_basicFeature1D>& gloveArcs);
+
+/// ��ȡ�������ϵ�Բ��������
+SG_APISHARED_EXPORT void sg_getLineUpperSemiCircleFeature(
+    SVzNL3DPosition* lineData,
+    int dataSize,
+    int lineIdx,
+    const double sieveDiameter,
+    const SSG_slopeParam slopePara, 
+    std::vector< SSG_featureSemiCircle>& line_features,
+    cv::Mat& holeMask);
+
+/// <summary>
+/// ��ȡ�������ϵļ�ֵ�㣨����ֵ��ͼ�Сֵ�㣩
+/// 
+/// </summary>
+SG_APISHARED_EXPORT void sg_getLineLocalPeaks(
+    SVzNL3DPosition* lineData,
+    int dataSize,
+    int lineIdx,
+    const double scaleWin,
+    std::vector< SSG_basicFeature1D>& localMax,
+    std::vector< SSG_basicFeature1D>& localMin);
+
+SG_APISHARED_EXPORT void sg_getLineLocalPeaks_2(
+    std::vector<SVzNL3DPosition>& lineData,
+    int lineIdx,
+    const double scaleWin,
+    std::vector< SSG_basicFeature1D>& localZMax,
+    std::vector< SSG_basicFeature1D>& localZMin);
+
+/// <summary>
+/// ������ȡ�������ϵļ�ֵ�㣨����ֵ��ͼ�Сֵ�㣩
+/// 
+/// </summary>
+SG_APISHARED_EXPORT void sg_getLineLocalPeaks_perSegment(
+    std::vector<SVzNL3DPosition>& lineData,
+    std::vector<SSG_RUN>& segs,
+    int lineIdx,
+    const double scaleWin,
+    std::vector< SSG_basicFeature1D>& localZMax,
+    std::vector< SSG_basicFeature1D>& localZMin);
+
+SG_APISHARED_EXPORT void sg_getFlatLineLocalPeaks_vector(
+    std::vector<SVzNL3DPosition>& lineData,
+    int lineIdx,
+    const double scaleWin,
+    const double minPkHeighth,
+    const double holeR,
+    std::vector< SSG_basicFeature1D>& localMax);
+
+SG_APISHARED_EXPORT void sg_getLineDownJumps(
+    SVzNL3DPosition* lineData,
+    int dataSize,
+    int lineIdx,
+    const double jumpTh,
+    std::vector< SSG_basicFeature1D>& downJumps);
+
+//��feature��������
+SG_APISHARED_EXPORT void sg_getFeatureGrowingTrees(
+    std::vector<SSG_lineFeature>& lineFeatures,
+    std::vector<SSG_featureTree>& trees,
+    SSG_treeGrowParam growParam);
+
+//��feature��������:���Ƚ�type��ֻ�ж�λ���Ƿ�����
+SG_APISHARED_EXPORT void wd_getFeatureGrowingTrees_noTypeMatch(
+    std::vector<SSG_lineFeature>& lineFeatures,
+    std::vector<SSG_featureTree>& feature_trees,
+    std::vector<SSG_featureTree>& ending_trees,
+    SSG_treeGrowParam growParam);
+
+//��segment feature��������
+SG_APISHARED_EXPORT void wd_getSegFeatureGrowingTrees(
+    std::vector<std::vector<SWD_segFeature>>& all_lineFeatures,
+    std::vector<SWD_segFeatureTree>& feature_trees,
+    SSG_treeGrowParam growParam);
+
+//segment��������, ����seg��Ҫ��֤���ص���
+SG_APISHARED_EXPORT void wd_getSegFeatureGrowingTrees_2(
+    std::vector<std::vector<SWD_segFeature>>& all_lineFeatures,
+    std::vector<SWD_segFeatureTree>& feature_trees,
+    const SSG_treeGrowParam growParam);
+
+//��rodArcfeature��������
+SG_APISHARED_EXPORT void wd_getRodArcFeatureGrowingTrees(
+    std::vector<std::vector<SWD_rodArcFeature>>& all_lineFeatures,
+    std::vector<SWD_rodArcFeatureTree>& feature_trees,
+    const SSG_treeGrowParam growParam);
+
+SG_APISHARED_EXPORT void sg_lineFeaturesGrowing(
+    int lineIdx,
+    bool isLastLine,
+    std::vector<SSG_basicFeature1D>& features,
+    std::vector<SSG_featureTree>& trees,
+    SSG_treeGrowParam growParam);
+
+//corner��������
+SG_APISHARED_EXPORT void sg_cornerFeaturesGrowing(
+    std::vector<std::vector<SSG_basicFeature1D>>& cornerFeatures,
+    std::vector<SSG_featureTree>& trees,
+    SSG_treeGrowParam growParam);
+
+//gap����������leaf����ģʽ��ÿ��Ҷ�ڵ�ȥѰ��ƥ��������
+SG_APISHARED_EXPORT void sg_lineGapsGrowing(
+    int lineIdx,
+    bool isLastLine,
+    std::vector<SSG_basicFeatureGap>& features,
+    std::vector<SSG_gapFeatureTree>& trees,
+    SSG_treeGrowParam growParam);
+
+//gap������tree����ģʽ��ÿ��������ȥѰ��ƥ���µ�leaf
+SG_APISHARED_EXPORT void sg_lineGapsGrowing_treeFirst(
+    int lineIdx,
+    bool isLastLine,
+    std::vector<SSG_basicFeatureGap>& features,
+    std::vector<SSG_gapFeatureTree>& trees,
+    SSG_treeGrowParam growParam);
+
+//SG_APISHARED_EXPORT void sg_getTreeROI(SSG_featureTree* a_tree);
+
+//��ending��������
+SG_APISHARED_EXPORT void sg_getEndingGrowingTrees(
+    std::vector<SSG_2DValueI>& lineEndings,
+    SVzNL3DLaserLine* laser3DPoints,
+    bool isVScan,
+    int featureType,
+    std::vector<SSG_featureTree>& trees,
+    SSG_treeGrowParam growParam);
+
+//��ending������������ֱɨ��ʱֻ����ˮƽ������ˮƽɨ��ʱֻ���д�ֱ����
+SG_APISHARED_EXPORT void sg_getEndingGrowingTrees_angleCheck(
+    std::vector<SSG_2DValueI>& lineEndings,
+    SVzNL3DLaserLine* laser3DPoints,
+    bool isVScan,
+    int featureType,
+    std::vector<SSG_featureTree>& trees,
+    SSG_treeGrowParam growParam,
+    double angleCheckScale);
+
+//��ɨ�����ϵ�
+SG_APISHARED_EXPORT void sg_LVFeatureGrowing(
+    std::vector<SSG_lineFeature>& lineFeatures, 
+    std::vector<SSG_featureTree>& trees, 
+    SSG_bagParam bagParam, 
+    SSG_treeGrowParam growParam, 
+    std::vector<SSG_2DValueI>& edgePts_0,
+    std::vector<SSG_2DValueI>& edgePts_1);
+
+SG_APISHARED_EXPORT void sg_peakFeatureGrowing(
+    std::vector<std::vector< SSG_basicFeature1D>>& lineFeatures,
+    std::vector<SSG_featureTree>& trees,
+    SSG_treeGrowParam growParam);
+
+//semiCircle��������
+SG_APISHARED_EXPORT void sg_getFeatureGrowingTrees_semiCircle(
+    std::vector< SSG_featureSemiCircle>& lineFeatures,
+    const int lineIdx,
+    const int lineSize,
+    std::vector<SSG_semiCircleFeatureTree>& trees,
+    std::vector<SSG_semiCircleFeatureTree>& stopTrees,
+    std::vector<SSG_semiCircleFeatureTree>& invalidTrees, //���Ƴ���������Щ�����ܽ�Ŀ��ֳɶ�������Ӷ����Ƴ���
+    SSG_treeGrowParam growParam);
+
+SSG_meanVar _computeMeanVar(double* data, int size);
+
+///�����ֲ���ߵ㣨z��С�㣩��
+///����������ÿ�β����������ڳ��ȵ�һ�롣�Ծֲ���ߵ���б�ǣ���ֹ���ظ���¼��
+SG_APISHARED_EXPORT void sg_getLocalPeaks(
+    SVzNL3DLaserLine* scanLines, 
+    int lineNum, 
+    std::vector<SSG_2DValueI>& peaks, 
+    SSG_localPkParam searchWin);
+
+/// <summary>
+/// �������������Ծֲ���ߵ���Ϊ�������ӽ�������
+/// ����������һ�������������ͬ�������ӵ�ΪԲ����Բ��ɨ�裬��¼ɨ�赽�ı߽�
+/// </summary>
+//SG_APISHARED_EXPORT void sg_peakPolarScan(cv::Mat& edgeMask, SVzNL2DPoint a_peak, SSG_polarScanParam polarScanParam, std::vector< SSG_2DValueI>& rgnContour);
+//��Peak�����ˮƽ��ֱɨ��õ�����߽�
+SG_APISHARED_EXPORT void sg_peakXYScan(
+    SVzNL3DLaserLine* laser3DPoints, 
+    int lineNum, 
+    cv::Mat& featureEdgeMask, 
+    SSG_2DValueI a_peak, 
+    SSG_treeGrowParam growParam, 
+    SSG_bagParam bagParam,
+    bool rgnPtAsEdge,
+    std::vector< SSG_lineConotours>& topContour,
+    std::vector< SSG_lineConotours>& bottomContour,
+    std::vector< SSG_lineConotours>& leftContour,
+    std::vector< SSG_lineConotours>& rightContour,
+    int* maxEdgeId_top, 
+    int* maxEdgeId_btm, 
+    int* maxEdgeId_left, 
+    int* maxEdgeId_right);
+
+//ȡ�������edgeId��ͬ�ı߽��
+SG_APISHARED_EXPORT void sg_getContourPts(
+    std::vector< SSG_lineConotours>& contour_all,
+    int vldEdgeId,
+    std::vector< SSG_2DValueI>& contourFilter, 
+    int* lowLevelFlag);
+
+//�ӱ߽�����ȡ�������edgeId��ͬ�ı߽��
+SG_APISHARED_EXPORT void sg_getPairingContourPts(
+    std::vector<SSG_conotourPair>& contourPairs,
+    std::vector<SSG_intPair>& idPairs,
+    std::vector< SSG_conotourPair>& contourFilter,
+    SVzNLRangeD range,
+    bool isTBDir,
+    int* lowLevelFlag_0,
+    int* lowLevelFlag_1);
+
+//ȡ����̾���ı߽��
+SG_APISHARED_EXPORT void sg_contourPostProc(
+    std::vector< SSG_contourPtInfo>& contour, 
+    int maxEdgeIdx, 
+    double sameConturDistTh,
+    std::vector< SSG_2DValueI>& contourFilter, 
+    int sideID,  
+    int* blockFlag);
+
+//����任
+//input, output��Ϊfloat��
+SG_APISHARED_EXPORT void sg_distanceTrans(const cv::Mat input, cv::Mat& output, int distType);
+
+/// <summary>
+/// ��5x5��ʽѰ��localPeaks
+/// </summary>
+/// <param name="input"></param>
+/// <param name="peaks"></param>
+SG_APISHARED_EXPORT void sg_getLocalPeaks_distTransform(
+    cv::Mat& input, 
+    std::vector<SSG_2DValueI>& peaks, 
+    SSG_localPkParam searchWin);
+
+/// <summary>
+/// ʹ��ģ�巨��ȡֱ������
+/// ˮƽ����ֱ���������յ����deltaZ��һ����С�ķ�Χ�ڣ��յ��Ҳ�deltaY��һ����С�ķ�Χ��
+/// </summary>
+SG_APISHARED_EXPORT void sg_getLineRigthAngleFeature(
+    SVzNL3DPosition* lineData,
+    int dataSize,
+    int lineIdx,
+    const SSG_lineRightAngleParam templatePara_HF,
+    const SSG_lineRightAngleParam templatePara_FH,
+    const SSG_lineRightAngleParam templatePara_HR,
+    const SSG_lineRightAngleParam templatePara_RH,
+    SSG_lineFeature* line_features);
+
+//����ɨ��ROI
+SG_APISHARED_EXPORT SVzNL3DRangeD sg_getScanDataROI(
+    SVzNL3DLaserLine* laser3DPoints,
+    int lineNum);
+//����ɨ��ROI: vecotr��ʽ
+SG_APISHARED_EXPORT SVzNL3DRangeD sg_getScanDataROI_vector(
+    std::vector< std::vector<SVzNL3DPosition>>& scanLines
+);
+
+//�������ROI: vecotr��ʽ
+SG_APISHARED_EXPORT SVzNL3DRangeD wd_getPointCloudROI(
+    std::vector<SVzNL3DPoint>& scanData);
+
+//������Ƶ�ROI��scale: vecotr��ʽ
+SG_APISHARED_EXPORT SWD_pointCloudPara wd_getPointCloudPara(
+    std::vector< std::vector<SVzNL3DPosition>>& scanLines);
+
+//XYƽ��ֱ�����
+SG_APISHARED_EXPORT void lineFitting(
+    std::vector< SVzNL3DPoint>& inliers,
+    double* _k,
+    double* _b);
+
+//��ϳ�ͨ��ֱ�߷��̣�������ֱ
+SG_APISHARED_EXPORT void lineFitting_abc(
+    std::vector< SVzNL3DPoint>& inliers,
+    double* _a,
+    double* _b,
+    double* _c);
+
+//��ϳ�ͨ��ֱ�߷���ax+by+c=0��������ֱ
+SG_APISHARED_EXPORT void indexingPtLineFitting_abc(
+    std::vector< SWD3DPointPostion>& inliers,
+    double* _a,
+    double* _b,
+    double* _c);
+
+/**
+ * @brief �ռ�ֱ����С�������
+ * @param points �������ά�㼯������2���㣬���������壩
+ * @param center ��������ֱ�ߵ����ģ���׼��P0��
+ * @param direction ��������ֱ�ߵķ�������v����λ����
+ * @return ����Ƿ�ɹ����㼯��Ч����true��
+ */
+SG_APISHARED_EXPORT bool fitLine3DLeastSquares(
+    const std::vector<SVzNL3DPoint>& points, 
+    SVzNL3DPoint& center, 
+    SVzNL3DPoint& direction);
+
+//Բ��С�������
+SG_APISHARED_EXPORT double fitCircleByLeastSquare(
+    const std::vector<SVzNL3DPoint>& pointArray,
+    SVzNL3DPoint& center,
+    double& radius);
+//Բ��С�������
+SG_APISHARED_EXPORT double fitCircleByLeastSquare_2(
+    const std::vector<SVzNL3DPosition>& pointArray,
+    SVzNL3DPoint& center,
+    double& radius);
+//Բ��С�������
+SG_APISHARED_EXPORT double fitCircleByLeastSquare_3(
+    const std::vector<SVzNL2DPointD>& pointArray,
+    SVzNL2DPointD& center,
+    double& radius);
+// ��Ȩ������С����Բ��ϣ�HuberȨ�ػ�TukeyȨ�أ�
+SG_APISHARED_EXPORT double fitCircleRobust(
+    const std::vector<SVzNL3DPosition>& points,
+    SVzNL3DPoint& robustCenter,
+    double& robustRadius,
+    double outlierThreshold = 2.5,  // ��׼���
+    int maxIter = 20,
+    double minPointsRatio = 0.5);
+
+//��������������� y=ax^2 + bx + c
+SG_APISHARED_EXPORT bool leastSquareParabolaFitEigen(
+    const std::vector<cv::Point2d>& points,
+    double& a, double& b, double& c,
+    double& mse, double& max_err);
+
+//����Z��ֵ
+SG_APISHARED_EXPORT double computeMeanZ(std::vector< SVzNL3DPoint>& pts);
+SG_APISHARED_EXPORT double computeROIMeanZ(std::vector<std::vector< SVzNL3DPosition>>& scanLines, SVzNLRect roi);
+SG_APISHARED_EXPORT void computeROIZCutLabel(std::vector<std::vector< SVzNL3DPosition>>& scanLines, SVzNLRect roi, double cutZ, int labelID);
+//����ǶȲ�ֵ����0-180�ȷ�Χ
+SG_APISHARED_EXPORT double computeAngleDiff(double theta1, double theta2);
+
+/**
+ * @brief ���������a������b��**�з�����ת��**����Χ��-�� ~ �У�
+ * @param a Դ����
+ * @param b Ŀ������
+ * @param rotAngle �������ת�ǣ����ȣ�����ʱ��Ϊ����˳ʱ��Ϊ��
+ * @return true������ɹ���false����������ʧ�ܣ�
+ */
+SG_APISHARED_EXPORT bool calcRotateAngle(const SVzNL2DPointD& a, const SVzNL2DPointD& b, double& rotAngle);
+
+//����ֱ�߽���
+SG_APISHARED_EXPORT SVzNL3DPoint computeLineCrossPt_abs(
+    double a1, double b1, double c1,
+    double a2, double b2, double c2);
+
+//�����2���ֱ�߷���
+SG_APISHARED_EXPORT void compute2ptLine(
+    SVzNL3DPoint pt1, 
+    SVzNL3DPoint pt2, 
+    double* _a, double* _b, double* _c);
+
+//�����2���ֱ�߷���,��ʹ�ýṹ��
+SG_APISHARED_EXPORT void compute2ptLine_2(
+    double x1, double y1,
+    double x2, double y2,
+    double* _a, double* _b, double* _c);
+
+//��ת45�Ⱥ��ֱ�߷���
+SG_APISHARED_EXPORT void rotateLine45Deg(
+    double _a, double _b, double _c,
+    double x0, double y0,
+    double* r_a, double* r_b, double* r_c);
+
+//����ֱ�߽Ƕ�
+SG_APISHARED_EXPORT double getLineAngle(const double _a, const double _b, const double _c);
+
+//���������2D����
+SG_APISHARED_EXPORT double compute2DLen(SVzNL3DPoint pt1, SVzNL3DPoint pt2);
+
+//����XYƽ����������ζ���(p0���Ž�)
+SG_APISHARED_EXPORT double computeXOYVertexAngle(SVzNL3DPoint p0, SVzNL3DPoint p1, SVzNL3DPoint p2);
+
+//����㵽ֱ�߾��� 
+SG_APISHARED_EXPORT double computePtDistToLine(double x0, double y0, double a, double b, double c);
+
+//���㴹��㣬ֱ�߷��̣�y = kx + b
+SG_APISHARED_EXPORT SVzNL2DPointD sx_getFootPoint(
+    double x0,
+    double y0,
+    double k,
+    double b);
+
+//���㴹��㣬ֱ�߷��̣�ax+by+c = 0
+SG_APISHARED_EXPORT SVzNL2DPointD sx_getFootPoint_abc(
+    double x0,
+    double y0,
+    double A,
+    double B,
+    double C);
+
+//Bresenham�㷨
+SG_APISHARED_EXPORT void drawLine(
+    int x0, 
+    int y0, 
+    int x1, 
+    int y1, 
+    std::vector<SVzNL2DPoint>& pts);
+
+/// <summary>
+/// ��������ע
+/// </summary>
+/// <param name="bwImg"> Ŀ���Ϊ��1���� �հ׵�Ϊ��0��</param>
+/// <param name="labImg"> ��ע�����ÿ����ΪrgnID, ID��2��ʼ </param>
+/// <param name="labelRgns"></param>
+SG_APISHARED_EXPORT void SG_TwoPassLabel(
+    const cv::Mat& bwImg, 
+    cv::Mat& labImg, 
+    std::vector<SSG_Region>& labelRgns,
+    int connectivity = 4);
+
+//���������: z = Ax + By + C
+//res: [0]=A, [1]= B, [2]=-1.0, [3]=C,
+SG_APISHARED_EXPORT void vzCaculateLaserPlane(
+    std::vector<cv::Point3d>& Points3ds,
+    std::vector<double>& res);
+
+SG_APISHARED_EXPORT Plane robustFitPlane(
+    const std::vector<cv::Point3d>& points,
+    RobustType type = HUBER,
+    double delta = 1.0,   // ��ֵ��>��ֵ��Ϊ��Ⱥ�㣨mm��
+    int maxIter = 20,      // ��������
+    double convergeThresh = 1e-5  // ������ֵ��ƽ��仯�㹻С��ͣ��
+);
+// ==============================================
+// �� ��ǰ��ֹ �� RANSAC ƽ����ϣ���ҵ��ʽ�棩
+// ==============================================
+SG_APISHARED_EXPORT Plane ransacFitPlane(
+    const std::vector<cv::Point3d>& points,
+    std::vector<cv::Point3d>& in_inliers,
+    float dist_thresh = 0.3f,          // �ڵ������ֵ
+    int max_iter = 1000,                // ������
+    int stop_no_improve = 250           // �������ٴ�����������ǰ�˳�
+);
+
+// ���룺3D���� std::vector<Eigen::Vector3d>
+// �����axis �������, centroid ��������
+SG_APISHARED_EXPORT void computeCylinderAxisFromIncompletePCA(
+    const std::vector<SVzNL3DPosition>& points,
+    SVzNL3DPoint& vec_axis,
+    SVzNL3DPoint& vec_centroid);
+
+// ���ܣ��� PCA ����ƽ����Ƶķ�����
+// ���룺ƽ���ϵ� 3D ����
+// �����normal ����������λ������centroid ƽ������
+SG_APISHARED_EXPORT void computePlaneNormalByPCA(
+    const std::vector<SVzNL3DPosition>& src_points,
+    SVzNL3DPoint& vec_normal,
+    SVzNL3DPoint& vec_centroid);
+
+// ��άPCA����ƽ�������Ʒ���
+SG_APISHARED_EXPORT void pca2D(
+    const std::vector<SVzNL2DPointD>& src_pts, 
+    SVzNL2DPointD& axis,
+    SVzNL2DPointD& centroid);
+
+//����һ��ƽ���ƽ������
+//���������п�����һ����ƽ��Ͳο���ƽƽ�棬����ߵ�ƽ����е�ƽ
+//��ת����Ϊ��ƽ����������ƽ�淨�����Ϊ��ֱ�����IJ���
+SG_APISHARED_EXPORT SSG_planeCalibPara sg_getPlaneCalibPara(
+    SVzNL3DLaserLine* laser3DPoints,
+    int lineNum);
+
+SG_APISHARED_EXPORT SSG_planeCalibPara sg_HCameraVScan_getGroundCalibPara(
+    std::vector< std::vector<SVzNL3DPosition>>& scanLines);
+
+//��һ��ƽ�����Ϊˮƽƽ��(zΪ�̶�ֵ����
+SG_APISHARED_EXPORT SSG_planeCalibPara adjustPlaneToXYPlane(
+    double plane_A, double plane_B, double plane_C  //ƽ�淨����
+);
+
+//����һ��ƽ���ƽ������
+//���������п�����һ����ƽ��Ͳο���ƽƽ�棬����ߵ�ƽ����е�ƽ
+//��ת����Ϊ��ƽ����������ƽ�淨�����Ϊ��ֱ�����IJ���
+SG_APISHARED_EXPORT SSG_planeCalibPara sg_getPlaneCalibPara2(
+    std::vector< std::vector<SVzNL3DPosition>>& scanLines);
+
+//��Կװ����һ��ƽ���ƽ��������ȡ�������׵�ɨ���߽���ƽ�����
+SG_APISHARED_EXPORT SSG_planeCalibPara sg_getHolePlaneCalibPara(
+    std::vector< std::vector<SVzNL3DPosition>>& scanLines);
+
+//����һ��ƽ���ƽ������
+//������������ROI���ڵĵ����ƽ����ϣ������ƽ����
+//��ת����Ϊ��ƽ����������ƽ�淨�����Ϊ��ֱ�����IJ���
+SG_APISHARED_EXPORT SSG_planeCalibPara sg_getPlaneCalibPara_ROIs(
+    SVzNL3DLaserLine* laser3DPoints,
+    int lineNum,
+    std::vector<SVzNL3DRangeD>& ROIs);
+
+//����һ��ƽ���ƽ������
+//������������ROI���ڵĵ����ƽ����ϣ������ƽ����
+//��ת����Ϊ��ƽ����������ƽ�淨�����Ϊ��ֱ�����IJ���
+SG_APISHARED_EXPORT SSG_planeCalibPara sg_getPlaneCalibPara2_ROI(
+    std::vector< std::vector<SVzNL3DPosition>>& scanLines,
+    SVzNL3DRangeD roi);
+
+//������������������ת����
+SG_APISHARED_EXPORT SSG_planeCalibPara wd_computeRTMatrix(
+    SVzNL3DPoint& vector1, 
+    SVzNL3DPoint& vector2);
+
+// ����ת�������ŷ���ǣ�Z-Y-X˳��
+SG_APISHARED_EXPORT SSG_EulerAngles rotationMatrixToEulerZYX(const double R[3][3]);
+// ��ŷ���Ǽ�����ת����Z-Y-X˳��
+SG_APISHARED_EXPORT void eulerToRotationMatrixZYX(const SSG_EulerAngles& angles, double R[3][3]);
+
+//�����̬��ƽ����ȥ������
+///camPoseRΪ3x3����
+SG_APISHARED_EXPORT void lineDataRT(
+    SVzNL3DLaserLine* a_line,
+    const double* camPoseR,
+    double groundH);
+SG_APISHARED_EXPORT void lineDataRT_vector(
+    std::vector< SVzNL3DPosition>& a_line,
+    const double* camPoseR, 
+    double groundH);
+SG_APISHARED_EXPORT void HCamera_lineDataRT_vector(
+    std::vector< SVzNL3DPosition>& a_line,
+    const double* camPoseR,
+    double groundH);
+SG_APISHARED_EXPORT void lineDataRT_RGBD(
+    SVzNLXYZRGBDLaserLine* a_line,
+    const double* camPoseR,
+    double groundH);
+
+//�������ڵ�ľ���
+SG_APISHARED_EXPORT void sg_pointClustering(
+    std::vector< SVzNL3DPosition>& pts,
+    double clusterDist,
+    std::vector<std::vector< SVzNL3DPosition>>& objClusters  //result
+);
+//ʹ��SVzNL3DPosition��nPointIdx��ʾ2D��Ϣ����16λLine�� ��16λptIdx��
+//����ʱ���������Լ���
+SG_APISHARED_EXPORT void wd_pointClustering_speedUp(
+    std::vector< SVzNL3DPosition>& pts,
+    int lineNum, int ptSize, int clusterCheckWin, //��������
+    double clusterDist,
+    int distType, //0 - 2d distance; 1- 3d distance 
+    std::vector<std::vector< SVzNL3DPosition>>& objClusters  //result
+);
+
+//��һ�������ľ��ࣨ�Ѿ��е㣩������һ�������о���
+//ʹ��SVzNL3DPosition��nPointIdx��ʾ2D��Ϣ����16λLine�� ��16λptIdx��
+//����ʱ���������Լ���
+SG_APISHARED_EXPORT void wd_clusterGrowing_speedUp(
+    std::vector< SVzNL3DPosition>& pts,
+    std::vector< SVzNL3DPosition >& a_cluster,
+    SVzNL3DRangeD& growingROI,  //���෶Χ�����ڼ���
+    int lineNum, int linePtSize, int clusterCheckWin, //��������
+    double clusterDist,
+    int distType, //0 - 2d distance; 1- 3d distance 
+    std::vector< SVzNL3DPosition >& added_points
+);
+
+//����դ���ϵ�Ĵ����ڵ����ڵ�ľ��࣬����������3D����������
+//ʹ��vector����2ά�ṹ������
+SG_APISHARED_EXPORT void wd_gridPointClustering(
+    std::vector<std::vector<SSG_featureClusteringInfo>>& featureMask,
+    std::vector<std::vector<SVzNL3DPoint>>& feature3DInfo,
+    int clusterCheckWin, //��������
+    SSG_treeGrowParam growParam,//��������
+    int clusterID, //��ǰCluster��ID
+    std::vector< SVzNL2DPoint>& a_cluster,  //result
+    SVzNL3DRangeD& clusterRoi  //roi3D
+);
+
+//��ɨ�����ݵľ���
+SG_APISHARED_EXPORT void wd_gridPointClustering_2(
+    std::vector<std::vector<SVzNL3DPosition>>& gridData,
+    std::vector<std::vector<SSG_intPair>>& pointMaskInfo, //��ֹ����ʱ�ظ�ѡ��
+    int clusterCheckWin, //��������
+    SSG_treeGrowParam growParam,//��������
+    int clusterID, //��ǰCluster��ID
+    std::vector< SVzNL2DPoint>& a_cluster,  //result
+    SVzNL3DRangeD& clusterRoi  //roi3D
+);
+
+//ʹ�þ��෽�����8��ͨ��ͨ�����
+SG_APISHARED_EXPORT void wd_gridPointClustering_labelling(
+    std::vector<std::vector<SSG_featureClusteringInfo>>& featureMask,
+    std::vector<std::vector<SVzNL3DPoint>>& feature3DInfo,
+    int clusterID, //��ǰCluster��ID
+    std::vector< SVzNL2DPoint>& a_cluster,  //result
+    SVzNLRect& clusterRoi  //roi2D
+);
+
+//ʹ�þ��෽�����8��ͨ��ͨ�����:��Ӧ��ͬ�����ݽṹ
+SG_APISHARED_EXPORT void wd_gridPointClustering_labelling_2(
+    std::vector<std::vector<SVzNL3DPoint>>& srcData,
+    std::vector<std::vector<SSG_clusterLabel>>& labelMask,
+    int clusterID, //��ǰCluster��ID
+    std::vector< SVzNL2DPoint>& a_cluster,  //result
+    SVzNL3DRangeD& clusterRoi  //roi3D
+);
+
+//��դ�����ݽ���XYƽ���ϵ�ͶӰ�������������������Ŀհ׵���в�ֵ
+SG_APISHARED_EXPORT void pointClout2DProjection(
+    std::vector< std::vector<SVzNL3DPosition>>& gridScanData,
+    SVzNLRangeD x_range,
+    SVzNLRangeD y_range,
+    double scale,
+    double cuttingGrndZ,
+    int edgeSkip,
+    double inerPolateDistTh,  //��ֵ��ֵ�����ڴ���ֵ�IJ�����������ֵ
+    cv::Mat& projectionData,//ͶӰ�������ݣ���ʼ��Ϊһ������ֵ1e+6
+    cv::Mat& backIndexing  //����������������ڻ���3D����
+);
+
+//��դ�����ݽ���XYƽ���ϵ�ͶӰ������Zֵ�������������������Ŀհ׵���в�ֵ
+SG_APISHARED_EXPORT void pointCloud2DQuantization(
+    std::vector< std::vector<SVzNL3DPosition>>& gridScanData,
+    SVzNLRangeD x_range,
+    SVzNLRangeD y_range,
+    double scale,
+    int edgeSkip,
+    double inerPolateDistTh,  //��ֵ��ֵ�����ڴ���ֵ�IJ�����������ֵ
+    std::vector<std::vector<SVzNL3DPoint>>& quantiData,  //�������ݣ���ʼ��Ϊһ������ֵ1e+6
+    std::vector<std::vector<SVzNL2DPoint>>& backIndexing //����������������ڻ���3D����
+);
+
+//��ˮ���㷨
+SG_APISHARED_EXPORT void watershed(SWD_waterShedImage& img);
+// ������������ӵ���з�ˮ���㷨
+SG_APISHARED_EXPORT void wd_seedWatershed(
+    SWD_waterShedImage& img, 
+    std::vector<SSG_2DValueI>& watershedSeeds, //���ӵ�
+    int maxLevel, //���ˮλ
+    int startMakerID  //��ʼMarker��ID
+);
+
+//�����˲�Ԥ����
+SG_APISHARED_EXPORT void wd_noiseFilter(
+    std::vector< std::vector<SVzNL3DPosition>>& scanLines,
+    const SSG_outlierFilterParam filterParam,
+    int* errCode);
+
+//�������ƽ������
+SG_APISHARED_EXPORT void wd_pointCloudHoleFilling(
+    std::vector< std::vector<SVzNL3DPosition>>& scanLines_src,
+    std::vector< std::vector<SVzNL3DPosition>>& scanLines_dst,
+    const int fillingHoleSize //��״�С
+);
+
+// Eigen��ʵ�֣������pts1��pts2����תƽ�ƾ���
+//��Ҫ
+SG_APISHARED_EXPORT void caculateRT(
+    const std::vector<cv::Point3d>& pts1,
+    const std::vector<cv::Point3d>& pts2,
+    cv::Mat& R, cv::Mat& T,
+    cv::Point3d& C1, cv::Point3d& C2);
+
+//�������תƽ�ƺ��λ��
+SG_APISHARED_EXPORT void pointRT(const cv::Mat& R, const cv::Mat& T,
+    const cv::Point3d& originPt, const cv::Point3d& rtOriginPT,  //RT(��תƽ�ƣ�ǰ�������
+    const cv::Point3d& pt, cv::Point3d& rtPt);  //RTǰ��ĵ�
+
+//�������תƽ�ƺ��λ��
+SG_APISHARED_EXPORT void pointRT_2(const cv::Mat& R, const cv::Mat& T,
+    const cv::Point3d& pt, cv::Point3d& rtPt);  //RTǰ��ĵ�
+
+SG_APISHARED_EXPORT void pointRotate(const cv::Mat& R,
+    const cv::Point3d& pt, cv::Point3d& rtPt); //Rotateǰ��ĵ�
+
+//��ŷ���Ǽ�����ת����
+SG_APISHARED_EXPORT void WD_EulerRpyToRotation(double rpy[3], double matrix3d[9]);
+
+//��ŷ���Ǽ��㷽��ʸ��
+SG_APISHARED_EXPORT void WD_EulerRpyToDirVectors(double rpy[3], std::vector<cv::Point3d>& dirVectors);
+
+//3x3ƽ��
+SG_APISHARED_EXPORT void scanLinesSmooting3x3(
+    std::vector< std::vector<SVzNL3DPosition>>& gridDataInput,
+    std::vector< std::vector<SVzNL3DPosition>>& smoothingData
+);
+
+
+SG_APISHARED_EXPORT void WD_getHoleInfo(
+    std::vector< std::vector<SVzNL3DPosition>>& scanLines,
+    const SSG_lineSegParam lineSegPara,
+    const SSG_outlierFilterParam filterParam,
+    const SSG_treeGrowParam growParam,
+    const double valieCommonNumRatio,
+    std::vector<SWD_segFeatureTree>& segTrees_v,
+    std::vector<SWD_segFeatureTree>& segTrees_h,
+    std::vector<SSG_intPair>& validObjects
+);
+
+/* ֧��դ�����ݣ�Ҫ������դ�����ݣ� */
+//��ȡɨ�����ϵ�V��Valley
+SG_APISHARED_EXPORT void wd_getLineVFlaws(
+    std::vector<SVzNL3DPosition>& a_line,
+    const int lineIdx, 
+    const SWD_valleyParam valleyParam,
+    const EWD_FlawType detectFlawType,
+    std::vector< SSG_basicFeatureGap>& valleys);
diff --git a/AppAlgo/lapWeldDetection/Inc/SG_baseDataType.h b/AppAlgo/lapWeldDetection/Inc/SG_baseDataType.h
index a2c60280..2e07ac18 100644
--- a/AppAlgo/lapWeldDetection/Inc/SG_baseDataType.h
+++ b/AppAlgo/lapWeldDetection/Inc/SG_baseDataType.h
@@ -6,6 +6,14 @@
 
 #define PI 3.14159265358979323846
 
+typedef enum
+{
+	keWD_FlawType_Uknown = 0,
+	keWD_FlawType_Depression,           //����
+	keWD_FlawType_Protrusion,           //͹��
+	keSG_FlawType_Dep_Prot,           //���ݺ�͹����
+} EWD_FlawType;
+
 // ����ŷ���ǽṹ�壨��λ���ȣ�
 typedef struct{
 	double roll;   // ��X����ת�������
@@ -90,6 +98,12 @@ typedef struct
 	int end;
 }SWD_Interval;  //����
 
+typedef struct SWD_IndexedValue
+{
+	int idx;
+	double value;
+}SWD_IndexedValue;
+
 typedef struct
 {
 	bool validFlag;  //ָʾ����Ƿ���Ч
diff --git a/AppAlgo/lapWeldDetection/Windows/x64/Debug/baseAlgorithm.dll b/AppAlgo/lapWeldDetection/Windows/x64/Debug/baseAlgorithm.dll
index 91ed13a5..fa5e4105 100644
Binary files a/AppAlgo/lapWeldDetection/Windows/x64/Debug/baseAlgorithm.dll and b/AppAlgo/lapWeldDetection/Windows/x64/Debug/baseAlgorithm.dll differ
diff --git a/AppAlgo/lapWeldDetection/Windows/x64/Debug/baseAlgorithm.lib b/AppAlgo/lapWeldDetection/Windows/x64/Debug/baseAlgorithm.lib
index 20f42595..cb6b7ae2 100644
Binary files a/AppAlgo/lapWeldDetection/Windows/x64/Debug/baseAlgorithm.lib and b/AppAlgo/lapWeldDetection/Windows/x64/Debug/baseAlgorithm.lib differ
diff --git a/AppAlgo/lapWeldDetection/Windows/x64/Debug/baseAlgorithm.pdb b/AppAlgo/lapWeldDetection/Windows/x64/Debug/baseAlgorithm.pdb
index 2f9c9ce1..0bcf1d71 100644
Binary files a/AppAlgo/lapWeldDetection/Windows/x64/Debug/baseAlgorithm.pdb and b/AppAlgo/lapWeldDetection/Windows/x64/Debug/baseAlgorithm.pdb differ
diff --git a/AppAlgo/lapWeldDetection/Windows/x64/Debug/lapWeldDetection.dll b/AppAlgo/lapWeldDetection/Windows/x64/Debug/lapWeldDetection.dll
index 868a9edf..2c02ad2c 100644
Binary files a/AppAlgo/lapWeldDetection/Windows/x64/Debug/lapWeldDetection.dll and b/AppAlgo/lapWeldDetection/Windows/x64/Debug/lapWeldDetection.dll differ
diff --git a/AppAlgo/lapWeldDetection/Windows/x64/Debug/lapWeldDetection.pdb b/AppAlgo/lapWeldDetection/Windows/x64/Debug/lapWeldDetection.pdb
index 77c69985..379fa769 100644
Binary files a/AppAlgo/lapWeldDetection/Windows/x64/Debug/lapWeldDetection.pdb and b/AppAlgo/lapWeldDetection/Windows/x64/Debug/lapWeldDetection.pdb differ
diff --git a/AppAlgo/lapWeldDetection/Windows/x64/Release/baseAlgorithm.dll b/AppAlgo/lapWeldDetection/Windows/x64/Release/baseAlgorithm.dll
index c7f0dc53..3996da07 100644
Binary files a/AppAlgo/lapWeldDetection/Windows/x64/Release/baseAlgorithm.dll and b/AppAlgo/lapWeldDetection/Windows/x64/Release/baseAlgorithm.dll differ
diff --git a/AppAlgo/lapWeldDetection/Windows/x64/Release/baseAlgorithm.lib b/AppAlgo/lapWeldDetection/Windows/x64/Release/baseAlgorithm.lib
index d8d20a3f..dde44efd 100644
Binary files a/AppAlgo/lapWeldDetection/Windows/x64/Release/baseAlgorithm.lib and b/AppAlgo/lapWeldDetection/Windows/x64/Release/baseAlgorithm.lib differ
diff --git a/AppAlgo/lapWeldDetection/Windows/x64/Release/baseAlgorithm.pdb b/AppAlgo/lapWeldDetection/Windows/x64/Release/baseAlgorithm.pdb
index c3f276d1..e7d7a566 100644
Binary files a/AppAlgo/lapWeldDetection/Windows/x64/Release/baseAlgorithm.pdb and b/AppAlgo/lapWeldDetection/Windows/x64/Release/baseAlgorithm.pdb differ
diff --git a/AppAlgo/lapWeldDetection/Windows/x64/Release/lapWeldDetection.dll b/AppAlgo/lapWeldDetection/Windows/x64/Release/lapWeldDetection.dll
index 44808e6c..ebdf172d 100644
Binary files a/AppAlgo/lapWeldDetection/Windows/x64/Release/lapWeldDetection.dll and b/AppAlgo/lapWeldDetection/Windows/x64/Release/lapWeldDetection.dll differ
diff --git a/AppAlgo/lapWeldDetection/Windows/x64/Release/lapWeldDetection.pdb b/AppAlgo/lapWeldDetection/Windows/x64/Release/lapWeldDetection.pdb
index 4860d47b..0563316c 100644
Binary files a/AppAlgo/lapWeldDetection/Windows/x64/Release/lapWeldDetection.pdb and b/AppAlgo/lapWeldDetection/Windows/x64/Release/lapWeldDetection.pdb differ