JSBTDieBondH/View/die-bonder-ui/CameraMaterialGroupWnd/MaterialWindow/Waffle.cpp

#include "Waffle.h"
#include <QPainter>
#include <QPaintEvent>

Waffle::Waffle(int flag, QWidget *parent) : QWidget(parent) 
{ 

}

void Waffle::UpdataGenerateTestData()
{

    // 随机数初始化
    WAFFLE_MATRIX_POINT_STRUCT test;
    test.nPackMatrixId = 1;
    test.nPackRow = 1;
    test.nPackCol = 1;
    test.nDieRow = 1;
    test.nDieCol = 1;
    test.nDieMatrixId = 1;
    test.iDieIndex = 1;
    test.bDisable = false; // 默认为可用
    // 设置坐标，每个点间隔为2
    test.stPosition.x = 0;
    test.stPosition.y = 0;
    int randomStatus = std::rand() % 5; // 随机选取DIE_EXIST, PICK_ING, NO_EXIST, SKIP_DIE
    test.eStatus = static_cast<ns_mat::PICK_DIE_STATUS>(randomStatus);
    maxPoint = QPointF(0, 0);
    minPoint = QPointF(0,0);
    WAFFLE_MATRIX_POINT_STRUCT minMatrixPoint = test;
    WAFFLE_MATRIX_POINT_STRUCT maxMatrixPoint = test;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            for (int m = 0; m < 2; m++) {
                for (int n = 0; n < 2; n++) {
                    ns_mat::WAFFLE_MATRIX_POINT_STRUCT a;
                    a.nPackMatrixId = 1;
                    a.nPackRow = i + 1;
                    a.nPackCol = j + 1;
                    a.nDieRow = m + 1;
                    a.nDieCol = n + 1;
                    a.nDieMatrixId = i * 2 + j + 1;
                    a.iDieIndex = m + n + 1;
                    a.bDisable = false; // 默认为可用
                    // 设置坐标，每个点间隔为2
                    a.stPosition.x = (j * 2 + n) * 2;
                    a.stPosition.y = (i * 2 + m) * 2;
                    int randomStatus = std::rand() % 5; // 随机选取DIE_EXIST, PICK_ING, NO_EXIST, SKIP_DIE
                    a.eStatus = static_cast<ns_mat::PICK_DIE_STATUS>(randomStatus);

                    if (a.stPosition.x > maxPoint.x())
                        maxPoint.setX(a.stPosition.x);
                    if (a.stPosition.x < minPoint.x())
                        minPoint.setX(a.stPosition.x);
                    if (a.stPosition.y > maxPoint.y())
                        maxPoint.setY(a.stPosition.y);
                    if (a.stPosition.y < minPoint.y())
                        minPoint.setY(a.stPosition.y);

                    if (maxMatrixPoint.nDieMatrixId != a.nDieMatrixId) {
                        m_vmaxMatrixPoints.append(maxMatrixPoint);
                        m_vminMatrixPoints.append(minMatrixPoint);
                        maxMatrixPoint = a;
                        minMatrixPoint = a;
                    }
                    else {
                        //遍历找到矩阵最小和最大边界点
                        if (a.stPosition.x > maxMatrixPoint.stPosition.x)
                            maxMatrixPoint = a;
                        if (a.stPosition.y > maxMatrixPoint.stPosition.y)
                            maxMatrixPoint = a;
                        if (a.stPosition.x < minMatrixPoint.stPosition.x)
                            minMatrixPoint = a;
                        if (a.stPosition.y < minMatrixPoint.stPosition.y)
                            minMatrixPoint = a;
                        // 将点添加到waferData容器中
                        
                    }
                    m_vWaffleData.append(a);
                }
            }

        }
    }
    m_vmaxMatrixPoints.append(maxMatrixPoint);
    m_vminMatrixPoints.append(minMatrixPoint);
}

void Waffle::UpdataVal(const std::vector<ns_mat::WAFFLE_MATRIX_POINT_STRUCT>& veWaffle)
{

    m_vWaffleData.clear();
    maxPoint = QPointF(veWaffle[0].stPosition.x, veWaffle[0].stPosition.y);
    minPoint = QPointF(veWaffle[0].stPosition.x, veWaffle[0].stPosition.y);
    WAFFLE_MATRIX_POINT_STRUCT minMatrixPoint = veWaffle[0];
    WAFFLE_MATRIX_POINT_STRUCT maxMatrixPoint = veWaffle[0];
    for (const auto a: veWaffle)
    {
        m_vWaffleData.append(a);
        //遍历找到最小和最大边界点
        if (a.stPosition.x > maxPoint.x())
            maxPoint.setX(a.stPosition.x);
        if (a.stPosition.x < minPoint.x())
            minPoint.setX(a.stPosition.x);
        if (a.stPosition.y > maxPoint.y())
            maxPoint.setY(a.stPosition.y);
        if (a.stPosition.y < minPoint.y())
            minPoint.setY(a.stPosition.y);

        if (maxMatrixPoint.nDieMatrixId != a.nDieMatrixId) {
            m_vmaxMatrixPoints.append(maxMatrixPoint);
            m_vminMatrixPoints.append(minMatrixPoint);
            maxMatrixPoint = a;
            minMatrixPoint = a;
        }
        else {
            //遍历找到矩阵最小和最大边界点
            if (a.stPosition.x > maxMatrixPoint.stPosition.x)
                maxMatrixPoint = a;
            if (a.stPosition.y > maxMatrixPoint.stPosition.y)
                maxMatrixPoint = a;
            if (a.stPosition.x < minMatrixPoint.stPosition.x)
                minMatrixPoint = a;
            if (a.stPosition.y < minMatrixPoint.stPosition.y)
                minMatrixPoint = a;
        }
        
        qDebug() << maxMatrixPoint.stPosition.x<<","<< maxMatrixPoint.stPosition.y << "  " << minMatrixPoint.stPosition.x << "," << minMatrixPoint.stPosition.y;
        qDebug() << a.stPosition.x << "  " << a.stPosition.y;

    }
   
    m_vmaxMatrixPoints.append(maxMatrixPoint);
    m_vminMatrixPoints.append(minMatrixPoint);
    

}





void Waffle::paintInitFrom(QWidget *parent) {
    /*
    // 获取当前窗口的宽高
    int width = parent->width();
    int height = parent->height();

    // 根据行列数计算每个晶圆点的大小，选择小的边来决定
    int cellSize = qMin(width, height) / qMax(rows, cols); // 固定大小为正方形，按最小边计算

    // 计算左上角偏移量，居中显示
    int offsetX = (width - cellSize * cols) / 2;
    int offsetY = (height - cellSize * rows) / 2;

    // 创建一个 QPixmap 对象用于保存绘制的图像
    globalPixmap = QPixmap(width, height);
    globalPixmap.fill(Qt::white);  // 填充背景色为白色

    // 创建 QPainter 以绘制到 QPixmap 上
    QPainter painter(&globalPixmap);
    painter.setRenderHint(QPainter::Antialiasing); // 启用抗锯齿

    // 设置画笔为无边框
    painter.setPen(Qt::NoPen);

    // 绘制每个晶圆点
    for (int i = 0; i < m_vWaffleData.size(); ++i) {
        int x = offsetX + m_vWaffleData[i].nDieCol * cellSize;
        int y = offsetY + m_vWaffleData[i].nDieRow * cellSize;

        // 根据点的状态设置颜色
        painter.setBrush(getColorByStatus(m_vWaffleData[i].eStatus));

        // 绘制晶圆点（每个点是一个矩形）
        painter.drawRect(x, y, cellSize, cellSize);
    }


    // painter.setBrush(Qt::black);
    // painter.drawEllipse(centerX - 3, centerY - 3, 6, 6);
    painter.end(); // 结束绘制
    */
}

void Waffle::initFrom(QWidget *parent) 
{
    if (m_pCViewInterface == nullptr)
    {
        return;
    }

    scene = new QGraphicsScene(parent);
    view = new WaffleGraphicsView(scene);
    view->setCViewInterface(m_pCViewInterface);

    int width = parent->width();
    int height = parent->height();
    double maxWidth = maxPoint.x() - minPoint.x();
    double maxHeight = maxPoint.y() - minPoint.y();
    double ratio = 0;

    if (maxHeight > maxWidth) 
    {
        ratio = maxHeight / (width - 100);
    }
    else 
    {
        ratio = maxWidth / (width - 100);
    }

    //目前没提供固晶点大小，以下用测试大小，后续可替换(实际大小，接口替换处)
    double dieWidth = 50;
    double dieHeight = 50;
    m_pCViewInterface->GetViewMatrix()->GetWaffleDieSize(m_vWaffleData[0].nPackMatrixId, dieWidth, dieHeight);
    //转换大小
    double dieWidthr = dieWidth / ratio;
    double dieHeightr = dieHeight / ratio;
    double penSize = 1;
    if (dieWidthr < 1 || dieHeightr < 1) 
    {
        penSize = 0.1;
    }

    for (int i = 0; i < m_vWaffleData.size(); ++i)
    {

        // 绘制固晶点
        double diex, diey;
        diex = (m_vWaffleData[i].stPosition.x - minPoint.x() + dieWidth) / ratio;
        diey = (m_vWaffleData[i].stPosition.y - minPoint.y() + dieHeight) / ratio;


        // 计算固晶点位置
        QRectF dieRect(
            diex,
            diey,
            dieWidthr,
            dieHeightr
        );
       // qDebug() << diex << "" << diey << dieWidthr << "   " << dieHeightr;
        if (i % 2 == 0) 
        {
            m_vWaffleData[i].eStatus = ns_mat::PICK_DIE_STATUS::DIE_EXIST;
        }
        else 
        {
            m_vWaffleData[i].eStatus = ns_mat::PICK_DIE_STATUS::EDGE_DIE;
        }
        WaffleItem* dieItem = new WaffleItem(m_vWaffleData[i], penSize);
        dieItem->setRect(dieRect);
        dieItem->setZValue(1.0);
        scene->addItem(dieItem);
    }

    QPen ptpen(Qt::blue, penSize);
    QFont matrixFont;
    double matrixFontSize = qMin(dieWidth / ratio, dieHeight / ratio) * 0.1;
    matrixFont.setPointSizeF(matrixFontSize);  // 使用浮点大小

    WAFFLE_MATRIX_POINT_STRUCT minPackMatrixPoint = m_vmaxMatrixPoints[0];
    WAFFLE_MATRIX_POINT_STRUCT maxPackMatrixPoint = m_vmaxMatrixPoints[0];
    for (int i = 0;i < m_vmaxMatrixPoints.size();i++) {
        int ptmatx, ptmaty, ptmatWidth, ptmatHeight;


        if (maxPackMatrixPoint.nPackMatrixId != m_vmaxMatrixPoints[i].nPackMatrixId) {
            m_vmaxPackMatrixPoints.append(maxPackMatrixPoint);
            m_vminPackMatrixPoints.append(minPackMatrixPoint);
            maxPackMatrixPoint = m_vmaxMatrixPoints[i];
            minPackMatrixPoint = m_vminMatrixPoints[i];
        }
        else {
            //遍历找到矩阵最小和最大边界点
            if (m_vmaxMatrixPoints[i].stPosition.x > maxPackMatrixPoint.stPosition.x)
                maxPackMatrixPoint = m_vmaxMatrixPoints[i];
            if (m_vminMatrixPoints[i].stPosition.y > maxPackMatrixPoint.stPosition.y)
                maxPackMatrixPoint = m_vmaxMatrixPoints[i];
            if (m_vmaxMatrixPoints[i].stPosition.x < minPackMatrixPoint.stPosition.x)
                minPackMatrixPoint = m_vminMatrixPoints[i];
            if (m_vminMatrixPoints[i].stPosition.y < minPackMatrixPoint.stPosition.y)
                minPackMatrixPoint = m_vminMatrixPoints[i];
        }

        

        ptmatx = (m_vminMatrixPoints[i].stPosition.x - minPoint.x() + 0.7 * dieWidth) / ratio;
        ptmaty = (m_vminMatrixPoints[i].stPosition.y - minPoint.y() + 0.7 * dieHeight) / ratio;
        ptmatWidth = (m_vmaxMatrixPoints[i].stPosition.x - m_vminMatrixPoints[i].stPosition.x + dieWidth * 1.6) / ratio;
        ptmatHeight = (m_vmaxMatrixPoints[i].stPosition.y - m_vminMatrixPoints[i].stPosition.y + dieHeight * 1.6) / ratio;

        QRectF ptRect(
            ptmatx,
            ptmaty,
            ptmatWidth,
            ptmatHeight
        );

        // 绘制die矩阵背景
        QGraphicsRectItem* ptItem = new QGraphicsRectItem(ptRect);
        ptItem->setPen(ptpen);
        //ptItem->setBrush(QColor("#d5e4f8"));
        scene->addItem(ptItem);
        // 添加die矩阵标签
        QRectF ptTextRect(
            ptmatx,
            ptmaty,
            dieWidth / ratio * 0.6,
            dieHeight / ratio * 0.2
        );
        QGraphicsRectItem* ptTextItem = new QGraphicsRectItem(ptTextRect);
        ptTextItem->setPen(Qt::NoPen);
        ptTextItem->setPen(QPen(Qt::yellow, 0.01));
        scene->addItem(ptTextItem);

        QGraphicsTextItem* ptText = new QGraphicsTextItem(ptTextItem);
        ptText->setPlainText(QString(tr("DieMat%1")).arg(m_vminMatrixPoints[i].nDieMatrixId));
        ptText->setFont(matrixFont);
        setTextSacle(ptTextRect, ptText);
        

    }
    m_vmaxPackMatrixPoints.append(maxPackMatrixPoint);
    m_vminPackMatrixPoints.append(minPackMatrixPoint);

    for (int i = 0;i < m_vmaxPackMatrixPoints.size();i++) {
        int packmatx, packmaty, packmatWidth, packmatHeight;
        packmatx = (m_vminPackMatrixPoints[i].stPosition.x - minPoint.x() + 0.4 * dieWidth) / ratio;
        packmaty = (m_vminPackMatrixPoints[i].stPosition.y - minPoint.y() + 0.4 * dieHeight) / ratio;
        packmatWidth = (m_vmaxPackMatrixPoints[i].stPosition.x - m_vminPackMatrixPoints[i].stPosition.x + dieWidth * 2.2) / ratio;
        packmatHeight = (m_vmaxPackMatrixPoints[i].stPosition.y - m_vminPackMatrixPoints[i].stPosition.y + dieHeight * 2.2) / ratio;

        QRectF packRect(
            packmatx,
            packmaty,
            packmatWidth,
            packmatHeight
        );

        // 绘制pack矩阵背景
        QGraphicsRectItem* packItem = new QGraphicsRectItem(packRect);
        packItem->setPen(ptpen);
        //ptItem->setBrush(QColor("#d5e4f8"));
        scene->addItem(packItem);
        // 添加pack矩阵标签
        QRectF packTextRect(
            packmatx,
            packmaty,
            dieWidth / ratio * 0.6,
            dieHeight / ratio * 0.2
        );
        QGraphicsRectItem* packTextItem = new QGraphicsRectItem(packTextRect);
        packTextItem->setPen(Qt::NoPen);
        //scene->addItem(packTextItem);

        QGraphicsTextItem* packText = new QGraphicsTextItem(packTextItem);
        packText->setPlainText(QString(tr("PackMat%1")).arg(m_vmaxPackMatrixPoints[i].nPackMatrixId));
        packText->setFont(matrixFont);
        setTextSacle(packTextRect, packText);

    }
    view->setScene(scene);
    view->resize(width, height);

    // 创建一个 QPixmap 对象用于保存绘制的图像
    globalPixmap = QPixmap(width, height);
    globalPixmap.fill(Qt::white);  // 填充背景色为白色
    QPixmap originalPixmap = QPixmap::grabWidget(view);
    // 设置目标尺寸（例如：宽度 200，高度 150）
    QSize targetSize(width, height);

    // 不保持比例，直接拉伸到指定尺寸
    QPixmap scaledPixmap = originalPixmap.scaled(
        targetSize,
        Qt::IgnoreAspectRatio,
        Qt::SmoothTransformation
    );
    globalPixmap = scaledPixmap;

  
}
QPixmap Waffle::getGlobalPixmap() const {
    return globalPixmap;
}

void Waffle::setTextSacle(QRectF textRect, QGraphicsTextItem* textItem) {
    // 获取文本实际绘制区域
    QRectF textBoundingRect = textItem->boundingRect();

    // 计算缩放比例，使文本适配到 ptTextRect 内部
    qreal scaleX = textRect.width() / textBoundingRect.width();
    qreal scaleY = textRect.height() / textBoundingRect.height();
    qreal scale = qMin(scaleX, scaleY) * 0.9; // 留一点边距

    // 缩放文本
    textItem->setScale(scale);

    // 将文本居中于 textRect
    QPointF center = textRect.center();
    // 使用 QTransform 缩放矩形
    QTransform transform;
    transform.scale(scale, scale);
    QRectF scaledRect = transform.mapRect(textBoundingRect);

    textItem->setPos(center.x() - scaledRect.width() / 2,
        center.y() - scaledRect.height() / 2);
}