ACO 拜占庭问题

class DatasetConverter {
public:
    static Graph convertMNISTToGraph(const std::vector<ImageData>& dataset, 
                                    int numByzantineNodes, 
                                    double corruptionRate) {
        // 将MNIST数据集转换为图结构
        Graph graph;
        // 1. 创建节点
        for (int i = 0; i < dataset.size(); ++i) {
            Node node;
            node.id = i;
            node.status = (i < numByzantineNodes) ? Traitor : Loyal;
            node.data = dataset[i].label;
            graph.addNode(node);
        }
        // 2. 构建边（这里简化为全连接）
        for (int i = 0; i < dataset.size(); ++i) {
            for (int j = 0; j < dataset.size(); ++j) {
                if (i != j) {
                    double weight = calculateSimilarity(dataset[i], dataset[j]);
                    graph.addEdge(i, j, weight);
                }
            }
        }
        // 3. 注入拜占庭错误
        injectByzantineErrors(graph, corruptionRate);
        return graph;
    }
    
private:
    static double calculateSimilarity(const ImageData& a, const ImageData& b) {
        // 计算图像相似度，作为边权重
        double diff = 0.0;
        for (int i = 0; i < a.pixels.size(); ++i) {
            diff += std::abs(a.pixels[i] - b.pixels[i]);
        }
        return 1.0 / (1.0 + diff); // 归一化到[0,1]范围
    }
    
    static void injectByzantineErrors(Graph& graph, double corruptionRate) {
        // 注入拜占庭错误
        std::random_device rd;
        std::mt19937 gen(rd());
        std::bernoulli_distribution dist(corruptionRate);
        
        for (auto& node : graph.getNodes()) {
            if (node.status == NodeStatus::Traitor && dist(gen)) {
                // 翻转标签
                node.data = (node.data + 5) % 10;
            }
        }
    }
};

void createDashboard() {
    ImGui::Begin("ACO for Byzantine Problem Dashboard", &showDashboard);
    
    // 1. 参数显示
    ImGui::Text("Algorithm Parameters:");
    ImGui::Text("  Ants: %d", numAnts);
    ImGui::Text("  Alpha: %.2f", alpha);
    ImGui::Text("  Beta: %.2f", beta);
    ImGui::Text("  Evaporation Rate: %.2f", evaporationRate);
    
    // 2. 性能指标
    ImGui::Text("Performance Metrics:");
    ImGui::Text("  Current Iteration: %d/%d", currentIteration, maxIterations);
    ImGui::Text("  Best Solution: %.2f", bestSolution);
    ImGui::Text("  Convergence: %.1f%%", convergenceRate);
    
    // 3. 实时图表
    if (ImPlot::BeginPlot("Convergence Curve", ImVec2(400, 200))) {
        ImPlot::PlotLine("Best Solution", convergenceData.data(), convergenceData.size());
        ImPlot::EndPlot();
    }
    
    // 4. 控制按钮
    if (ImGui::Button("Start Algorithm")) {
        startAlgorithm();
    }
    ImGui::SameLine();
    if (ImGui::Button("Pause")) {
        pauseAlgorithm();
    }
    ImGui::SameLine();
    if (ImGui::Button("Reset")) {
        resetAlgorithm();
    }
    
    // 5. 节点状态统计
    ImGui::Text("Node Status:");
    ImGui::Text("  Loyal: %d", loyalNodeCount);
    ImGui::Text("  Traitor: %d", traitorNodeCount);
    ImGui::Text("  Unknown: %d", unknownNodeCount);
    
    ImGui::End();
}

// 集成可视化功能的完整代码
#include <SFML/Graphics.hpp>
#include <vector>
#include <random>

// 节点类
class Node {
public:
    sf::CircleShape shape;
    NodeStatus status;
    int id;
    
    Node(int x, int y, int radius, int id) : id(id) {
        shape.setPosition(x - radius, y - radius);
        shape.setRadius(radius);
        shape.setOrigin(radius, radius);
        setStatus(NodeStatus::Unknown);
    }
    
    void setStatus(NodeStatus status) {
        this->status = status;
        switch (status) {
            case NodeStatus::Loyal:
                shape.setFillColor(sf::Color::Green);
                break;
            case NodeStatus::Traitor:
                shape.setFillColor(sf::Color::Red);
                break;
            case NodeStatus::Unknown:
                shape.setFillColor(sf::Color::Gray);
                break;
        }
    }
};

// 边类
class Edge {
public:
    Node* from;
    Node* to;
    sf::RectangleShape line;
    double weight;
    
    Edge(Node* from, Node* to, double weight) : from(from), to(to), weight(weight) {
        updateLine();
    }
    
    void updateLine() {
        sf::Vector2f start = from->shape.getPosition();
        sf::Vector2f end = to->shape.getPosition();
        sf::Vector2f direction = end - start;
        float length = std::sqrt(direction.x * direction.x + direction.y * direction.y);
        
        line.setPosition(start);
        line.setSize(sf::Vector2f(length, 2));
        line.setRotation(std::atan2(direction.y, direction.x) * 180 / 3.14159f);
        
        // 根据权重设置颜色
        sf::Color color = sf::Color::White;
        if (weight > 0.5) {
            color.r = static_cast<sf::Uint8>(255 * (weight - 0.5) * 2);
        } else {
            color.b = static_cast<sf::Uint8>(255 * weight * 2);
        }
        line.setFillColor(color);
    }
};

// 可视化管理器
class VisualizationManager {
public:
    VisualizationManager(int width, int height) : window(sf::VideoMode(width, height), "ACO for Byzantine Problem") {
        window.setFramerateLimit(60);
    }
    
    void addNode(int x, int y, NodeStatus status, int id) {
        nodes.emplace_back(x, y, 15, id);
        nodes.back().setStatus(status);
    }
    
    void createEdges() {
        for (int i = 0; i < nodes.size(); ++i) {
            for (int j = i + 1; j < nodes.size(); ++j) {
                double distance = std::sqrt(
                    std::pow(nodes[i].shape.getPosition().x - nodes[j].shape.getPosition().x, 2) +
                    std::pow(nodes[i].shape.getPosition().y - nodes[j].shape.getPosition().y, 2)
                ) / 100;
                edges.emplace_back(&nodes[i], &nodes[j], distance);
            }
        }
    }
    
    void addAnt(int startNodeIndex) {
        sf::CircleShape ant(8);
        ant.setFillColor(sf::Color::Blue);
        if (startNodeIndex >= 0 && startNodeIndex < nodes.size()) {
            ant.setPosition(nodes[startNodeIndex].shape.getPosition());
        }
        ants.push_back(ant);
    }
    
    void updateAntPosition(int antIndex, int nodeIndex) {
        if (antIndex >= 0 && antIndex < ants.size() && nodeIndex >= 0 && nodeIndex < nodes.size()) {
            ants[antIndex].setPosition(nodes[nodeIndex].shape.getPosition());
        }
    }
    
    void updateEdgeWeight(int fromNode, int toNode, double newWeight) {
        for (auto& edge : edges) {
            if ((edge.from->id == fromNode && edge.to->id == toNode) || 
                (edge.from->id == toNode && edge.to->id == fromNode)) {
                edge.weight = newWeight;
                edge.updateLine();
                break;
            }
        }
    }
    
    void setNodeStatus(int nodeIndex, NodeStatus status) {
        if (nodeIndex >= 0 && nodeIndex < nodes.size()) {
            nodes[nodeIndex].setStatus(status);
        }
    }
    
    bool isOpen() const {
        return window.isOpen();
    }
    
    void handleEvents() {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed)
                window.close();
        }
    }
    
    void render() {
        window.clear(sf::Color(30, 30, 46));
        
        // 绘制边
        for (auto& edge : edges) {
            edge.updateLine();
            window.draw(edge.line);
        }
        
        // 绘制节点
        for (auto& node : nodes) {
            window.draw(node.shape);
        }
        
        // 绘制蚂蚁
        for (auto& ant : ants) {
            window.draw(ant);
        }
        
        window.display();
    }
    
private:
    sf::RenderWindow window;
    std::vector<Node> nodes;
    std::vector<Edge> edges;
    std::vector<sf::CircleShape> ants;
};

// 主函数集成示例
int main() {
    // 创建可视化管理器
    VisualizationManager visManager(800, 600);
    
    // 添加节点（10个节点，2个叛徒）
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> xDist(50, 750);
    std::uniform_int_distribution<> yDist(50, 550);
    
    for (int i = 0; i < 10; ++i) {
        NodeStatus status = NodeStatus::Loyal;
        if (i == 2 || i == 4) { // 设置2个叛徒节点
            status = NodeStatus::Traitor;
        }
        visManager.addNode(xDist(gen), yDist(gen), status, i);
    }
    
    // 创建边
    visManager.createEdges();
    
    // 添加蚂蚁（15只）
    for (int i = 0; i < 15; ++i) {
        visManager.addAnt(i % 10);
    }
    
    // 初始化蚁群算法
    int numNodes = 10;
    int numAnts = 15;
    double alpha = 1.0;
    double beta = 5.0;
    double rho = 0.5;
    
    AntColonyOptimization aco(numNodes, numAnts, alpha, beta, rho);
    
    // 创建距离矩阵
    std::vector<std::vector<double>> distanceMatrix(numNodes, std::vector<double>(numNodes, 0.0));
    std::uniform_real_distribution<> dist(1.0, 10.0);
    
    for (int i = 0; i < numNodes; ++i) {
        for (int j = i + 1; j < numNodes; ++j) {
            double distance = dist(gen);
            distanceMatrix[i][j] = distance;
            distanceMatrix[j][i] = distance;
        }
    }
    
    // 运行算法并实时可视化
    int maxIterations = 100;
    for (int iter = 0; iter < maxIterations && visManager.isOpen(); ++iter) {
        auto ants = aco.generateAnts();
        
        // 更新可视化中的蚂蚁位置
        for (int i = 0; i < ants.size(); ++i) {
            visManager.updateAntPosition(i, ants[i].currentNode);
        }
        
        // 处理事件并渲染
        visManager.handleEvents();
        visManager.render();
        
        // 蚂蚁构建路径
        for (auto& ant : ants) {
            while (ant.path.size() < numNodes) {
                // 路径选择逻辑...
                // 省略部分代码...
                
                // 更新可视化中的蚂蚁移动
                visManager.updateAntPosition(&ant - &ants[0], ant.currentNode);
                visManager.handleEvents();
                visManager.render();
            }
        }
        
        // 更新信息素并可视化边权重变化
        aco.updatePheromone(ants, distanceMatrix);
        // 更新边权重可视化...
        
        spdlog::info("Iteration {} completed", iter + 1);
    }
    
    return 0;
}