修改tcp通信方式,修正特征值处理逻辑

SigerCalculation/RadomForestSAC/RamdomForestCalculate.cpp

@@ -3,6 +3,20 @@
 #include "spdlog/spdlog.h"
 #include <QFileInfo>
 
+int pickPriorityValue(double xpred, double ypred, double zpred)
+{
+    // 四舍五入
+    int x = qRound(xpred);
+    int y = qRound(ypred);
+    int z = qRound(zpred);
+
+    // 优先检查 1 → 2 → 3
+    if (x == 1 || y == 1 || z == 1) return 1;
+    if (x == 2 || y == 2 || z == 2) return 2;
+    if (x == 3 || y == 3 || z == 3) return 3;
+
+    return 0;   // 都没有
+}
 
 void CreatTable()
 {
@@ -122,8 +136,8 @@ RamdomForestCalculate::RamdomForestCalculate(QObject *parent)
     }
 
     //GLS Test
-    StreamInfo info(1,"A$14$1$1$1$202$0","1764237011402-0","0");
-    SendStreamAlarminfo(info);
+//    StreamInfo info(1,"C$14$1$1$1$202$0","1764581206660-0","0");
+//    SendStreamAlarminfo(info);
 
 
     //连接信号和槽函数
@@ -179,49 +193,101 @@ QString RamdomForestCalculate::QueryPowerData(const StreamInfo &alarmInfo)
 
 void RamdomForestCalculate::SendStreamAlarminfo(const StreamInfo &alarmInfo)
 {
-    TcpClient* client = new TcpClient();
-
-    // 统一的清理函数
-    auto cleanup = [client]() {
-        static bool cleaned = false;  // 静态变量确保只清理一次收到 TMS 信号
-        if (!cleaned) {
-            cleaned = true;
-            //qDebug() << "清理客户端资源";
-            client->disconnectFromServer();
-            QTimer::singleShot(0, client, &QObject::deleteLater);  // 延迟删除确保安全
-        }
-    };
-
-    // 连接所有信号到统一的清理函数
-    QObject::connect(client, &TcpClient::connected, [client, alarmInfo, cleanup]() {
-        qDebug() << "=== 连接成功，开始发送报警消息 ===";
-
-        QJsonObject message;
-        message["source"] = STREAM_MESSAGE;
-        message["typealarm"] = alarmInfo.alarmtype;
-        message["target"] = alarmInfo.target;
-        message["startIds"] = alarmInfo.startIds;
-        message["endIds"] = alarmInfo.endIds;
-        //message["power"] = alarmInfo.endIds;
-
-        client->sendMessage(message);
-        SPDLOG_LOGGER_DEBUG(spdlog::get("logger"),"发送给流式告警信息成功");
-
-        // 发送完成后立即开始清理
-        cleanup();
-    });
-
-    QObject::connect(client, &TcpClient::disconnected, cleanup);
-    QObject::connect(client, &TcpClient::messageReceived, cleanup);
-    QObject::connect(client, &TcpClient::errorOccurred, cleanup);
+    QString ip("127.0.0.1");
+    TcpClient tcp_client(ip, 5999);
+    QJsonObject json;
+    json["source"] = STREAM_MESSAGE;
+    json["typealarm"] = QString::number(alarmInfo.alarmtype);
+    json["target"] = alarmInfo.target;
+    json["startIds"] = alarmInfo.startIds;
+    json["endIds"] = alarmInfo.endIds;
+
+    tcp_client.sendData(QString(QJsonDocument(json).toJson(QJsonDocument::Compact)).toStdString().c_str());
+    SPDLOG_LOGGER_DEBUG(spdlog::get("logger"),"发送流式报警信息成功");
+
+    // 创建短连接 TcpClient
+//    TcpClient* client = new TcpClient();
+
+//    // 构造消息
+//    QJsonObject message;
+//    message["source"] = STREAM_MESSAGE;
+//    message["typealarm"] = QString::number(alarmInfo.alarmtype);
+//    message["target"] = alarmInfo.target;
+//    message["startIds"] = alarmInfo.startIds;
+//    message["endIds"] = alarmInfo.endIds;
+
+//    // 连接成功后发送消息
+//    QObject::connect(client, &TcpClient::connected, [client, message]() {
+//        qDebug() << "=== 连接成功，开始发送报警消息 ===";
+
+//        client->sendMessage(message);
+
+//        // 延迟关闭，确保消息发送完成
+//        QTimer::singleShot(200, client, [client]() {
+//            //client->disconnectFromServer();
+//            client->deleteLater();
+//        });
+
+//        SPDLOG_LOGGER_DEBUG(spdlog::get("logger"),
+//                            "发送流式报警信息成功");
+//    });
+
+//    // 连接错误也自动释放
+//    QObject::connect(client, &TcpClient::errorOccurred, [client](const QString &err) {
+//        qWarning() << "TcpClient错误:" << err;
+//        client->deleteLater();
+//    });
+
+//    // 发起连接
+//    client->connectToServer("127.0.0.1", STREAM_PORT);
+}
 
-    // 设置连接超时（5秒）
-    QTimer::singleShot(5000, client, cleanup);
 
-    // 连接到服务器
-    qDebug() << "正在连接到服务器...";
-    client->connectToServer("127.0.0.1", STREAM_PORT);
-}
+//void RamdomForestCalculate::SendStreamAlarminfo(const StreamInfo &alarmInfo)
+//{
+//    TcpClient* client = new TcpClient();
+
+//    // 统一的清理函数
+//    auto cleanup = [client]() {
+//        static bool cleaned = false;  // 静态变量确保只清理一次收到 TMS 信号
+//        if (!cleaned) {
+//            cleaned = true;
+//            //qDebug() << "清理客户端资源";
+//            client->disconnectFromServer();
+//            QTimer::singleShot(0, client, &QObject::deleteLater);  // 延迟删除确保安全
+//        }
+//    };
+
+//    // 连接所有信号到统一的清理函数
+//    QObject::connect(client, &TcpClient::connected, [client, alarmInfo, cleanup]() {
+//        qDebug() << "=== 连接成功，开始发送报警消息 ===";
+
+//        QJsonObject message;
+//        message["source"] = STREAM_MESSAGE;
+//        message["typealarm"] = QString::number(alarmInfo.alarmtype);
+//        message["target"] = alarmInfo.target;
+//        message["startIds"] = alarmInfo.startIds;
+//        message["endIds"] = alarmInfo.endIds;
+//        //message["power"] = alarmInfo.endIds;
+
+//        client->sendMessage(message);
+//        SPDLOG_LOGGER_DEBUG(spdlog::get("logger"),"发送给流式告警信息成功");
+
+//        // 发送完成后立即开始清理
+//        cleanup();
+//    });
+
+//    QObject::connect(client, &TcpClient::disconnected, cleanup);
+//    QObject::connect(client, &TcpClient::messageReceived, cleanup);
+//    QObject::connect(client, &TcpClient::errorOccurred, cleanup);
+
+//    // 设置连接超时（5秒）
+//    QTimer::singleShot(5000, client, cleanup);
+
+//    // 连接到服务器
+//    qDebug() << "正在连接到服务器...";
+//    client->connectToServer("127.0.0.1", STREAM_PORT);
+//}
 
 QList<SACRecord> RamdomForestCalculate::queryRecordsByLabel(const QString &dbFileName, int targetLabel)
 {
@@ -310,9 +376,18 @@ int RamdomForestCalculate::Save_SACDATA(const Dc_SacData &sacdata)
     for (int i=0; i<3; ++i)
     {
         fea[i].print();
-        fea[i].fill(x);
-        fea[i].fill(y);
-        fea[i].fill(z);
+        if(i == 0)
+        {
+            fea[i].fill(x);
+        }
+        else if(i == 1)
+        {
+            fea[i].fill(y);
+        }
+        else if(i == 2)
+        {
+            fea[i].fill(z);
+        }
     }
     //step2: 预测报警
     //std::string data;
@@ -320,26 +395,70 @@ int RamdomForestCalculate::Save_SACDATA(const Dc_SacData &sacdata)
 
     if(IfHaveModel)
     {
-        std::vector<float> test_sample(10,0);
+        //X轴预测
+        std::vector<float> xtest_sample;
         //用逗号分割
-        QStringList list = x.split(',');
+        QStringList xlist = x.split(',');
+
+        SPDLOG_LOGGER_DEBUG(spdlog::get("logger"),"xlist: {}",xlist.size());
 
         //转成 float 并存到 vector
-        for (const QString &s : list) {
+        for (const QString &s : xlist) {
             bool ok = false;
             float f = s.toFloat(&ok);
             if (ok) {
-                test_sample.push_back(f);
+                xtest_sample.push_back(f);
             } else {
                 std::cerr << "转换失败: " << s.toStdString() << std::endl;
             }
         }
-        double pred = Classifier->predict(test_sample);
+
+        double xpred = Classifier->predict(xtest_sample);
         //cout << "测试样本预测类别: " << pred << endl;
+        SPDLOG_LOGGER_DEBUG(spdlog::get("logger"),"x轴测试样本预测类别: {}",xpred);
+
+        //Y轴预测
+        std::vector<float> ytest_sample;
+        //用逗号分割
+        QStringList ylist = y.split(',');
+
+        //转成 float 并存到 vector
+        for (const QString &s : ylist) {
+            bool ok = false;
+            float f = s.toFloat(&ok);
+            if (ok) {
+                ytest_sample.push_back(f);
+            } else {
+                std::cerr << "转换失败: " << s.toStdString() << std::endl;
+            }
+        }
+        double ypred = Classifier->predict(ytest_sample);
+        //cout << "测试样本预测类别: " << pred << endl;
+        SPDLOG_LOGGER_DEBUG(spdlog::get("logger"),"y轴测试样本预测类别: {}",ypred);
+
+        //Z轴预测
+        std::vector<float> ztest_sample;
+        //用逗号分割
+        QStringList zlist = z.split(',');
+
+        //转成 float 并存到 vector
+        for (const QString &s : zlist) {
+            bool ok = false;
+            float f = s.toFloat(&ok);
+            if (ok) {
+                ztest_sample.push_back(f);
+            } else {
+                std::cerr << "转换失败: " << s.toStdString() << std::endl;
+            }
+        }
+        double zpred = Classifier->predict(ztest_sample);
+        //cout << "测试样本预测类别: " << pred << endl;
+        SPDLOG_LOGGER_DEBUG(spdlog::get("logger"),"z轴测试样本预测类别: {}",zpred);
+
+        int predRes  = pickPriorityValue(xpred,ypred,zpred);
 
-        SPDLOG_LOGGER_DEBUG(spdlog::get("logger"),"测试样本预测类别: {}",pred);
 
-        StreamInfo info(pred,sacdata.target,sacdata.startIds,sacdata.endIds);
+        StreamInfo info(predRes,sacdata.target,sacdata.startIds,sacdata.endIds);
         SendStreamAlarminfo(info);
     }
 

SigerCalculation/RadomForestSAC/RandomForestClassifier.cpp

@@ -2,6 +2,7 @@
 #include <algorithm>
 #include <random>
 #include "common.h"
+#include "spdlog/spdlog.h"
 
 std::vector<sample_type> RandomForestClassifier::convert_to_dlib_format(const std::vector<std::vector<float>>& X)
 {
@@ -294,6 +295,9 @@ double RandomForestClassifier::predict(const std::vector<float>& sample)
     if (sample.size() != static_cast<size_t>(feature_dim))
     {
         printf("invalid param: sample_size=%ld feature_dim=%d\n", sample.size(), feature_dim);
+
+        SPDLOG_LOGGER_DEBUG(spdlog::get("logger"),"invalid param: sample_size-------sample.size:{}--------feature_dim{}",sample.size(),feature_dim);
+
         return -1;
     }
 
@@ -306,6 +310,9 @@ double RandomForestClassifier::predict(const std::vector<float>& sample)
         }
         catch (const std::exception& e) {
             DEBUG_PRINT("load model failure: %s\n", e.what());
+
+            SPDLOG_LOGGER_DEBUG(spdlog::get("logger"),"load model failure:--------------");
+
             return -1;
         }
     }

SigerCalculation/tcp/TcpClient.cpp

 #include "TcpClient.h"
-#include <QHostAddress>
-#include <QDebug>
 
-TcpClient::TcpClient(QObject *parent)
+TcpClient::TcpClient(const QString& ip, qint16 port, QObject* parent)
     : QObject(parent)
-    , m_socket(new QTcpSocket(this))
+    , m_ip(ip)
+    , m_port(port)
 {
-    // 连接信号槽
-    connect(m_socket, &QTcpSocket::connected, this, &TcpClient::onConnected);
-    connect(m_socket, &QTcpSocket::disconnected, this, &TcpClient::onDisconnected);
-    connect(m_socket, &QTcpSocket::readyRead, this, &TcpClient::onReadyRead);
-    connect(m_socket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::error),
-                this, &TcpClient::onErrorOccurred);
+    m_socket = new QTcpSocket();
+    m_socket->connectToHost(ip, port);
 }
 
 TcpClient::~TcpClient()
 {
-    disconnectFromServer();
+    releaseSocket();
 }
 
-void TcpClient::connectToServer(const QString &host, quint16 port)
+void TcpClient::releaseSocket()
 {
-    qDebug() << "正在连接到服务器:" << host << ":" << port;
-    m_socket->connectToHost(host, port);
+    if (m_socket) {
+        m_socket->close();
+        delete m_socket;
+        m_socket = nullptr;
+    }
 }
 
-void TcpClient::sendMessage(const QJsonObject &message)
+bool TcpClient::sendData(const char* data)
 {
-    if (m_socket->state() != QAbstractSocket::ConnectedState) {
-        qWarning() << "未连接到服务器，无法发送消息";
-        return;
+    if (!m_socket->isOpen()) {
+        m_socket->connectToHost(m_ip, m_port);
+        if (!m_socket->isOpen()) {
+            return false;
+        }
     }
-
-    // 将JSON对象转换为字符串
-    QJsonDocument doc(message);
-    QString jsonString = doc.toJson(QJsonDocument::Compact);
-
-    // 添加换行符作为消息结束标记（根据你的服务端实现）
-    jsonString += "\n";
-
-    // 发送消息
-    qint64 bytesWritten = m_socket->write(jsonString.toUtf8());
-    if (bytesWritten == -1) {
-        qWarning() << "发送消息失败";
-    } else {
-        qDebug() << "消息发送成功，字节数:" << bytesWritten;
-        qDebug() << "发送的内容:" << jsonString.trimmed();
+    qint64 sendRe = m_socket->write(data, strlen(data));
+    if (-1 == sendRe) {
+        qDebug() << Q_FUNC_INFO << " error : sendRe is -1, data :" << data;
+        return false;
     }
-}
-
-void TcpClient::disconnectFromServer()
-{
-    if (m_socket->state() == QAbstractSocket::ConnectedState) {
-        m_socket->disconnectFromHost();
+    if (sendRe != qint64(strlen(data))) {
+        qDebug() << Q_FUNC_INFO << " error : sendRe != strlen(data), data :" << data;
+        return false;
     }
-}
-
-void TcpClient::onConnected()
-{
-    qDebug() << "成功连接到服务器";
-    emit connected();
-}
-
-void TcpClient::onDisconnected()
-{
-    qDebug() << "与服务器断开连接";
-    emit disconnected();
-}
-
-void TcpClient::onReadyRead()
-{
-    QByteArray data = m_socket->readAll();
-    m_buffer.append(data);
-
-    qDebug() << "接收到服务器响应:" << data;
-
-    // 简单的消息分割（根据你的服务端实现调整）
-    while (m_buffer.contains('\n')) {
-        int endIndex = m_buffer.indexOf('\n');
-        QByteArray messageData = m_buffer.left(endIndex).trimmed();
-        m_buffer = m_buffer.mid(endIndex + 1);
-
-        // 解析JSON响应
-        QJsonParseError parseError;
-        QJsonDocument doc = QJsonDocument::fromJson(messageData, &parseError);
-
-        if (parseError.error == QJsonParseError::NoError && doc.isObject()) {
-            QJsonObject jsonObj = doc.object();
-            emit messageReceived(jsonObj);
-            qDebug() << "解析服务器响应成功:" << jsonObj;
-        } else {
-            // 如果不是JSON，直接作为字符串处理
-            QString response = QString::fromUtf8(messageData);
-            qDebug() << "服务器响应:" << response;
-        }
+    if (!m_socket->waitForBytesWritten()) {
+        qDebug() << Q_FUNC_INFO << " error : sendRe waitForBytesWritten false , data :" << data << m_socket->errorString();
+        return false;
     }
+    qDebug() << Q_FUNC_INFO << " is : " << data;
+    return true;
 }
 
-void TcpClient::onErrorOccurred(QAbstractSocket::SocketError error)
+bool TcpClient::isConnect()
 {
-    QString errorString = m_socket->errorString();
-    qWarning() << "Socket错误:" << errorString;
-    emit errorOccurred(errorString);
+    return m_socket->isWritable();
 }

SigerCalculation/tcp/TcpClient.h

@@ -9,33 +9,20 @@
 #define STREAM_MESSAGE "random_alarm"
 #define STREAM_PORT  5999
 
-class TcpClient : public QObject
-{
+class TcpClient : public QObject {
     Q_OBJECT
-
 public:
-    explicit TcpClient(QObject *parent = nullptr);
+    explicit TcpClient(const QString& ip, qint16 port, QObject* parent = nullptr);
     ~TcpClient();
-
-    void connectToServer(const QString &host = "127.0.0.1", quint16 port = 8888);
-    void sendMessage(const QJsonObject &message);
-    void disconnectFromServer();
-
+    void releaseSocket();
+    bool sendData(const char* data);
+    bool isConnect();
 signals:
-    void connected();
-    void disconnected();
-    void messageReceived(const QJsonObject &message);
-    void errorOccurred(const QString &error);
-
-private slots:
-    void onConnected();
-    void onDisconnected();
-    void onReadyRead();
-    void onErrorOccurred(QAbstractSocket::SocketError error);
 
 private:
-    QTcpSocket *m_socket;
-    QByteArray m_buffer;
+    QTcpSocket* m_socket = nullptr;
+    const QString m_ip;
+    qint16 m_port;
 };
 
 #endif // TCPCLIENT_H