#include "datafilequix.h"


DataFileQuix::DataFileQuix()
{
    clear();
}

DataFileQuix::DataFileQuix(const QString &fullPathName)
{
    initFile(fullPathName);
    loadFile();
    convertDataToEmbAbs();
}

void DataFileQuix::writeLeftFrontToFileDoubleHead(QString filePath,int left,int front)
{
    QFile rdfile(filePath);
    if(!rdfile.open(QIODevice::ReadOnly))
    {
        return;
    }

    QByteArray fileData = rdfile.readAll();
    rdfile.close();

    if(fileData.size() <= 0)
    {
        return;
    }

    QuixFileHead * head = (QuixFileHead *)(fileData.data());//头文件的结构体
    head->left = left;
    head->front = front;

    QFile wfile(filePath);
    if(!wfile.open(QIODevice::WriteOnly | QIODevice::Truncate))
    {
        return;
    }

    wfile.write(fileData);
    wfile.close();

#ifdef Q_OS_LINUX
    system("sync");
#endif
}

void DataFileQuix::convertDataToEmbAbs(s16 flag)
{
    m_absData.clear();
    getQuixMinMax();

    QuixFileHead head;

    // 图形数据
    u32 i, datasize, idx;
    unsigned char ctrl, tmpls;

    u8 c1, c2, c3, c4;
    u32 lsdata;
    double deltx1, delty1, deltx2, delty2;
    double threex[4], threey[4];
    s16 nmstep;

    double factorx, factory, unitmuti;
    memcpy(&head, m_fileData.data(), sizeof(QuixFileHead));
    unitmuti = getMutiUnit(0);

    double scanx = head.scanX * unitmuti;   // 宽度
    double scany = head.scanY * unitmuti;   // 长度

    if (scanx < 1)
    {
        scanx = 1;
    }
    if (scany < 1)
    {
        scany = 1;
    }

    // 计算缩放系数
    factorx = (double)((m_maxX-m_minX) / (scanx));
    factory = (double)((m_maxY-m_minY) / (scany));

    if(factorx == 0){factorx = 1;}
    if(factory == 0){factory = 1;}
    //    factorx = 1;
    //    factory = 1;

    if(flag != 1)
    {
        factorx = 1;
        factory = 1;
    }

    nmstep = head.normalStep * unitmuti;
    if(nmstep == 0)
    {
        nmstep = 200;    //单位0.01mm（2mm）
    }

    i = sizeof(QuixFileHead);
    datasize = m_fileData.size();

    DsAbsItem absItem;
    memset(&absItem,0,sizeof(DsAbsItem));

    //将第一个点加进来
//    absItem.ctrl = m_firstPoint.ctrl;
//    absItem.ax = m_firstPoint.x / factorx;
//    absItem.ay = m_firstPoint.y / factory;
//    m_absData.append((char*)&absItem,sizeof(DsAbsItem));

    while(i < datasize)
    {
        // 功能控制字
        if (i >= datasize){break;}
        ctrl = m_fileData.at(i++);

        // 图元类型
        if (i >= datasize){break;}
        tmpls = m_fileData.at(i++);

        // 附加控制字
        if (i >= datasize){break;}
        m_fileData.at(i++);
        if (i >= datasize){break;}
        m_fileData.at(i++);

        if(ctrl == 0x00)		// 结束
        {
            break;
        }

        switch(tmpls)
        {
        case QUI_TYPE_LINE: // 直线
        case QUI_TYPE_STEP: // 跨步
        case QUI_TYPE_HSTEP: // 翻头跨步
        {
            //增加剪线
            if(tmpls == QUI_TYPE_STEP || tmpls == QUI_TYPE_HSTEP)
            {
                if((u32)m_absData.size() >= sizeof(DsAbsItem))
                {
                    memcpy((char*)&absItem,m_absData.data()+m_absData.size()-sizeof(DsAbsItem),sizeof(DsAbsItem));
                    absItem.ctrl = DATA_CUTTRD;
                    m_absData.append((char*)&absItem,sizeof(DsAbsItem));
                }
            }

            // 点个数
            if (i >= datasize){break;}
            c1 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c2 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c3 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c4 = m_fileData.at(i++);
            lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);

            if (lsdata > 1)
            {
                // 第一个点
                //点x
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                double x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                deltx2 = x/factorx;

                //点y
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                double y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                delty2 = y/factory;

                for(idx = 1; idx < lsdata; idx++)	// 其余的点
                {
                    deltx1 = deltx2;
                    delty1 = delty2;

                    //点x
                    if (i >= datasize){break;}
                    c1 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c2 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c3 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c4 = m_fileData.at(i++);
                    x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                    deltx2 = x/factorx;

                    //点y
                    if (i >= datasize){break;}
                    c1 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c2 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c3 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c4 = m_fileData.at(i++);
                    y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                    delty2 = y/factory;

                    // 处理直线
                    calcLine(deltx1, delty1, deltx2, delty2, nmstep, m_absData, tmpls);
                }

                if (idx != lsdata)
                {
                    break;
                }
            }
            break;
        }
        case QUI_TYPE_ARC: // 三点圆弧
        {
            // 点个数
            if (i >= datasize){break;}
            c1 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c2 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c3 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c4 = m_fileData.at(i++);
            lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
            if(lsdata != 3)
            {
                break;
            }

            for (idx = 0; idx < lsdata; idx++)
            {
                //点x
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                double x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                threex[idx] = x/factorx;

                //点y
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                double y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                threey[idx] = y/factory;
            }

            calcCurve(threex, threey, nmstep, m_absData);

            if (idx != 3)
            {
                break;
            }
            break;
        }
        case QUI_TYPE_BES: // 贝塞尔曲线
        {
            // 点个数
            if (i >= datasize){break;}
            c1 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c2 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c3 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c4 = m_fileData.at(i++);
            lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
            if(lsdata != 4)
            {
                break;
            }

            for (idx = 0; idx < lsdata; idx++)
            {
                //点x
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                double x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                threex[idx] = x/factorx;

                //点y
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                double y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                threey[idx] = y/factory;
            }

            // 处理贝塞尔曲线
            QList<QPointF> splineListXY;//拟合后的点
            splineListXY.clear();
            getBezierPointList(threex, threey, nmstep,splineListXY);

            QList<QPointF> splitListXY;//均分后的点
            splitListXY.clear();
            if(splineListXY.size() > 0)
            {
                getCurvePointFillLine(splineListXY,nmstep,splitListXY,0,OBJECT_STITCHLEN_NEW_SAMALL);
            }

            //添加贝塞尔曲线数据点
            for(int i = 0; i < splitListXY.size(); i++)
            {
                memset(&absItem,0,sizeof(DsAbsItem));

                deltx1 = splitListXY[i].x();
                delty1 = splitListXY[i].y();

                absItem.ctrl = DATA_SEWING;
                absItem.ax = deltx1;
                absItem.ay = delty1;
                m_absData.append((char*)&absItem,sizeof(DsAbsItem));
            }
            //calcBezier(threex, threey, nmstep, m_absData);

            if (idx != 4)
            {
                break;
            }
            break;
        }
        case QUI_TYPE_SPLINE: // 样条
        {
            QList<QPointF> quiListPoint;//样条拟合前的点集合
            quiListPoint.clear();

            // 点个数
            if (i >= datasize){break;}
            unsigned char c1 = m_fileData.at(i++);
            if (i >= datasize){break;}
            unsigned char c2 = m_fileData.at(i++);
            if (i >= datasize){break;}
            unsigned char c3 = m_fileData.at(i++);
            if (i >= datasize){break;}
            unsigned char c4 = m_fileData.at(i++);
            lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);

            for(idx = 0; idx < lsdata; idx++)	// 点
            {
                //点x
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                double x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                deltx1 = x/factorx;

                //点y
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                double y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                delty1 = y/factory;

                QPointF point(deltx1,delty1);
                quiListPoint.append(point);
            }

            QList<QPointF> splineListXY;//拟合后的点
            splineListXY.clear();
            if(quiListPoint.size() <= 0)
            {
                break;
            }
            getSplineNew(quiListPoint,splineListXY);

            // 均分
            QList<QPointF> splitListXY;//均分后的点
            splitListXY.clear();
            if(splineListXY.size() > 0)
            {
                getCurvePointFillLine(splineListXY,nmstep,splitListXY,0,OBJECT_STITCHLEN_NEW_SAMALL);
            }

            //添加样条曲线数据点
            for(int i = 0; i < splitListXY.size(); i++)
            {
                memset(&absItem,0,sizeof(DsAbsItem));

                deltx1 = splitListXY[i].x();
                delty1 = splitListXY[i].y();

                absItem.ctrl = DATA_SEWING;
                absItem.ax = deltx1;
                absItem.ay = delty1;
                m_absData.append((char*)&absItem,sizeof(DsAbsItem));
            }

            if(idx != lsdata)
            {
                break;
            }
            break;
        }
        default:
            break;
        }
    }

    //生成绝对坐标数据的文件头
    creatAbsHeadAndAr();
}

void DataFileQuix::creatAbsHeadAndAr()
{
    DataDs16FileHead dhead;
    memset(&dhead, 0, sizeof(DataDs16FileHead));

    int stepSize = m_absData.size()/sizeof(DsAbsItem);
    if(stepSize <= 0)
    {
        return;
    }

    DsAbsItem * absDataPtr = (DsAbsItem *)(m_absData.data());

    double minX, maxX, minY, maxY;
    minX = S32_MAX;
    maxX = S32_MIN;
    minY = S32_MAX;
    maxY = S32_MIN;

    double curx,cury,dx,dy,ar;
    curx = cury = dx = dy = ar = 0;

    //取反并求最大最小值
    for (int i = 0; i < stepSize; i++)
    {
        absDataPtr->ax *= QUIX_DATADIRX;
        absDataPtr->ay *= QUIX_DATADIRY;

        curx = absDataPtr->ax;
        cury = absDataPtr->ay;

        if(curx > maxX)
        {
            maxX = curx;
        }
        if(curx < minX)
        {
            minX = curx;
        }

        if(cury > maxY)
        {
            maxY = cury;
        }
        if(cury < minY)
        {
            minY = cury;
        }

        absDataPtr++;
    }

    absDataPtr = (DsAbsItem *)(m_absData.data());
    double begX = absDataPtr->ax;//起始点
    double begY = absDataPtr->ay;
    int begR = 0;

    m_firstPoint.x = begX;
    m_firstPoint.y = begY;
    m_firstPoint.ctrl = absDataPtr->ctrl;

    //增加结束码
    if((u32)m_absData.size() >= sizeof(DsAbsItem))
    {
        DsAbsItem absItem;
        memset(&absItem,0,sizeof(DsAbsItem));
        memcpy((char*)&absItem,m_absData.data()+m_absData.size()-sizeof(DsAbsItem),sizeof(DsAbsItem));
        absItem.ctrl = DATA_END;
        m_absData.append((char*)&absItem,sizeof(DsAbsItem));
        stepSize++;
    }

    m_maxX = maxX;
    m_minX = minX;
    m_maxY = maxY;
    m_minY = minY;

    //生成文件头
    dhead.maxX = maxX;
    dhead.maxY = maxY;
    dhead.minX = minX;
    dhead.minY = minY;
    dhead.beginX = begX;
    dhead.beginY = begY;
    dhead.beginR = begR;
    dhead.anchorX = 0;
    dhead.anchorY = 0;
    dhead.itemNums = stepSize;
    dhead.dataSize = stepSize*sizeof(DsAbsItem);    // 数据字节数
    dhead.bytesPerItem = sizeof(DsAbsItem);           // 每项占的字节数
    dhead.dataChecksum = calcCheckSum32((u8 *)(m_absData.data()) , dhead.dataSize);;	// 数据累加校验和
    dhead.checkCrc = calcCrc16((u8 *)(&dhead), HEAD_FIX_INFO_LEN); // 前面6个字段的CRC校验，（6个字段分别为：文件名称，字节数，项个数，每项字节数，每块字节数，数据累加和的CRC校验值）
    dhead.fileid = dhead.checkCrc;
    m_absData.insert(0,(char*)&dhead,sizeof(DataDs16FileHead));
}

void DataFileQuix::getQuixMinMax()
{
    QuixFileHead head;
    memcpy(&head, m_fileData.data(), sizeof(QuixFileHead));

    u32 i, idx, datasize;
    unsigned char ctrl, tmpls;
    u8 c1, c2, c3, c4;
    u32 lsdata;
    double deltx, delty;
    double threex[4], threey[4];

    int first = 0;
    double minx, maxx, miny, maxy;

    minx = S32_MAX;
    maxx = S32_MIN;
    miny = S32_MAX;
    maxy = S32_MIN;

    i = sizeof(QuixFileHead);
    datasize = m_fileData.size();
    while(i < datasize)
    {
        // 功能控制字
        if (i >= datasize){break;}
        ctrl = m_fileData.at(i++);

        // 图元类型
        if (i >= datasize){break;}
        tmpls = m_fileData.at(i++);

        // 附加控制字1和2
        if (i >= datasize){break;}
        m_fileData.at(i++);
        if (i >= datasize){break;}
        m_fileData.at(i++);

        if(ctrl == 0x00)		// 结束
        {
            break;
        }

        switch(tmpls)
        {
        case QUI_TYPE_LINE: // 直线(折线)
        case QUI_TYPE_STEP: // 跨步
        case QUI_TYPE_HSTEP: // 翻头跨步
        {
            // 点个数
            if (i >= datasize){break;}
            c1 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c2 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c3 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c4 = m_fileData.at(i++);
            lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);

            if (lsdata > 1)
            {
                for(idx = 0; idx < lsdata; idx++)	// 点
                {
                    //点x
                    if (i >= datasize){break;}
                    c1 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c2 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c3 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c4 = m_fileData.at(i++);
                    deltx = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);

                    //点y
                    if (i >= datasize){break;}
                    c1 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c2 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c3 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c4 = m_fileData.at(i++);
                    delty = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);

                    if (first == 0)
                    {
                        m_firstPoint.x = deltx;
                        m_firstPoint.y = delty;
                        m_firstPoint.ctrl = ctrl;
                        first = 1;
                    }

                    if(deltx > maxx)
                    {
                        maxx = deltx;
                    }
                    if(deltx < minx)
                    {
                        minx = deltx;
                    }

                    if(delty > maxy)
                    {
                        maxy = delty;
                    }
                    if(delty < miny)
                    {
                        miny = delty;
                    }
                }

                if (idx != lsdata)
                {
                    break;
                }
            }
        }
            break;
        case QUI_TYPE_ARC: // 三点圆弧
        {
            // 点个数
            if (i >= datasize){break;}
            c1 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c2 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c3 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c4 = m_fileData.at(i++);
            lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);

            if(lsdata != 3)
            {
                break;
            }

            for (idx = 0; idx < lsdata; idx++)
            {
                //点x
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                threex[idx] = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);

                //点y
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                threey[idx] = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);

                if (first == 0)
                {
                    m_firstPoint.x = threex[0];
                    m_firstPoint.y = threey[0];
                    m_firstPoint.ctrl = ctrl;
                    first = 1;
                }
            }
            if (idx != 3)
            {
                break;
            }
        }
            break;
        case QUI_TYPE_BES: // 贝塞尔曲线
        {
            // 点个数
            if (i >= datasize){break;}
            c1 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c2 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c3 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c4 = m_fileData.at(i++);
            lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);

            if(lsdata != 4)
            {
                break;
            }

            for (idx = 0; idx < lsdata; idx++)
            {
                //点x
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                threex[idx] = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);

                //点y
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                threey[idx] = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);

                if (first == 0)
                {
                    m_firstPoint.x = threex[0];
                    m_firstPoint.y = threey[0];
                    m_firstPoint.ctrl = ctrl;
                    first = 1;
                }
            }
            if (idx != 4)
            {
                break;
            }

            getBezierMinMax(threex, threey, &minx, &maxx, &miny, &maxy);
        }
            break;
        case QUI_TYPE_SPLINE: // 样条
        {
            QList<QPointF> quiListPoint;//样条拟合前的点集合
            quiListPoint.clear();

            // 点个数
            if (i >= datasize){break;}
            unsigned char c1 = m_fileData.at(i++);
            if (i >= datasize){break;}
            unsigned char c2 = m_fileData.at(i++);
            if (i >= datasize){break;}
            unsigned char c3 = m_fileData.at(i++);
            if (i >= datasize){break;}
            unsigned char c4 = m_fileData.at(i++);
            lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);

            for(idx = 0; idx < lsdata; idx++)	// 点
            {
                //点x
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                deltx = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);

                //点y
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                delty = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);

                QPointF point(deltx,delty);
                quiListPoint.append(point);

                if (first == 0)
                {
                    m_firstPoint.x = deltx;
                    m_firstPoint.y = delty;
                    m_firstPoint.ctrl = ctrl;
                    first = 1;
                }
            }
            getSplineMinMax(quiListPoint, &minx, &maxx, &miny, &maxy);
        }
            break;
        }
    }

    if (first == 0)
    {
        minx = 0;
        maxx = 0;
        miny = 0;
        maxy = 0;

        m_firstPoint.x = 0;
        m_firstPoint.y = 0;
        m_firstPoint.ctrl = 0;
    }

    m_minX = minx;
    m_maxX = maxx;
    m_minY = miny;
    m_maxY = maxy;

    return;
}

const QPoint DataFileQuix::getFirstPoint()
{
    QPoint p(m_firstPoint.x,m_firstPoint.y);
    return p;
}

int DataFileQuix::checkFileHead()
{
    if (m_fileData.size() >= (int)sizeof(QuixFileHead))
    {
        QuixFileHead * pHead;
        pHead = (QuixFileHead *)(m_fileData.data());

        if (pHead->normalStep < 1)
        {
            pHead->normalStep = 40;
        }

        if (pHead->scanX < 1)
        {
            pHead->scanX = m_maxX - m_minX;
        }

        if (pHead->scanY < 1)
        {
            pHead->scanY = m_maxY - m_minY;
        }

        QFile wrfile(m_fileFullPathName);
        if(!wrfile.open(QIODevice::WriteOnly | QIODevice::Truncate))
        {
            return -1;
        }
        else
        {
            wrfile.write(m_fileData);
            wrfile.close();
        }
    }

    return 0;
}

double DataFileQuix::getMutiUnit(int unit)
{
    double unitmuti;
    if (unit == 0x00) // 0x00: 0.1mm;
    {
        unitmuti = 10;
    }
    else if (unit == 0x01) // 0x01: 1/1000inch;
    {
        unitmuti = 2.54;
    }
    else if (unit == 0x02) // 0x02: 0.04mm
    {
        unitmuti = 10;
    }
    else
    {
        unitmuti = 1;
    }
    return unitmuti;
}

void DataFileQuix::initFile(const QString &fullPathName)
{
    clear();
    QFileInfo file(fullPathName);
    if (file.exists() && file.isFile())
    {
        m_fileFullPathName = fullPathName;
    }
    else
    {
        qDebug() << "Init file failed path =" << m_fileFullPathName;
    }
    loadFile();
}

void DataFileQuix::clear()
{
    m_firstPoint.x = 0;
    m_firstPoint.y = 0;
    m_firstPoint.ctrl = 0;

    m_firstPointLeft.x = 0;
    m_firstPointLeft.y = 0;
    m_firstPointLeft.ctrl = 0;

    m_firstPointRight.x = 0;
    m_firstPointRight.y = 0;
    m_firstPointRight.ctrl = 0;

    m_minX = INT32_MAX;
    m_maxX = INT32_MIN;
    m_minY = INT32_MAX;
    m_maxY = INT32_MIN;

    m_fileFullPathName.clear(); // 文件路径
    m_fileData.clear();         // 文件数据内容
    m_absData.clear();       // 转换后的数据
}

void DataFileQuix::loadFile()
{
    QFile rdfile(m_fileFullPathName);
    if(!rdfile.open(QIODevice::ReadOnly))
    {
        qDebug() << "open file fail when read, path =" << m_fileFullPathName;
        return;
    }

    m_fileData = rdfile.readAll();
    rdfile.close();
}

int DataFileQuix::createPreviewImage(QImage *pImg, int saveflag, int penwidth, int reDraw)
{
#if(1)
    s16 existFlag = 1;

    if(reDraw == 0)//图片存在则不重画
    {
        existFlag = 0;
        // 图片是否存在，存在则返回
        QString previewPath = getFileFullPathName() + ".preview.png";
        QFile imageFile(previewPath);
        if (imageFile.exists())
        {
            return 1;
        }
    }
#endif

    int newimgflag = 0;
    QImage * pImage;
    int width, height;
    if (pImg == NULL)
    {
        width = QUIX_PREVIEW_WIDTH;
        height = QUIX_PREVIEW_HEIGHT;
        pImage = new QImage(width, height, IMAGE_TYPE);
        newimgflag = 1;
    }
    else
    {
        pImage = pImg;
    }

    width = pImage->width();
    height = pImage->height();
    if (width <= QUIX_PREVIEW_SIDE*2 || height <= QUIX_PREVIEW_SIDE*2)
    {
        if (pImage != NULL && newimgflag == 1)
        {
            delete pImage;
        }
        qDebug("preview img too small");
        return -1;
    }

    memset(pImage->bits(), 0x00, pImage->byteCount());

    QPainter painter(pImage);
    QColor backcolor(255, 255, 255, 0);         // 透明背景
    // 背景
    QPen pen;
    pen.setWidth(penwidth);
    pen.setColor(backcolor);
    painter.setPen(pen);
    painter.setBrush(backcolor);
    painter.drawRect(0, 0, width, height);

    // 图形
    //qDebug()<<"convertDataToAbs defore";
    convertDataToEmbAbs(existFlag);     // 转换为绝对坐标数据
    //qDebug()<<"convertDataToAbs end";

    // absdat数据
    int size = m_absData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("2 data less then head size");
        return -1;
    }
    DataDs16FileHead * pAbsHead = (DataDs16FileHead *)(m_absData.data());
    int datasize = size - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        qDebug("absdat dataBegin err");
        return -1;
    }
    int stepsize = datasize/sizeof(DsAbsItem);
    if (stepsize <= 0)
    {
        qDebug("absdat data size err");
        return -1;
    }
    DsAbsItem * pData = (DsAbsItem *)(m_absData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;
    //--------

    // 图形显示区域
    int dpminx = QUIX_PREVIEW_SIDE;
    int dpmaxx = width - QUIX_PREVIEW_SIDE;
    int dpminy = QUIX_PREVIEW_SIDE;
    int dpmaxy = height - QUIX_PREVIEW_SIDE;

    // 计算缩放系数
    double factor, temp;
    if ((dpmaxx - dpminx) <= 0 || (dpmaxy - dpminy) <= 0)
    {
        return -1;
    }

    factor = (double)(fabs(m_maxX - m_minX)) / (dpmaxx - dpminx);      // 按x计算的缩放系数
    temp =   (double)(fabs(m_maxY - m_minY)) / (dpmaxy - dpminy);      // 按x计算的缩放系数

    if (temp >= factor)     // 使用较大的缩放系数
    {
        factor = temp;
    }

    // 计算显示参数，按照图形的实际位置显示（数据坐标零点对应图形中心）
    double dpx = (double)((dpminx+dpmaxx)/2 - ((m_maxX+m_minX)/factor)/2);
    double dpy = (double)((dpminy+dpmaxy)/2 - ((m_maxY+m_minY)/factor)/2);

    // 显示花样图形
    u8 ctrlByte;
    double dx;
    double dy;

    double datposx, datposy;
    datposx = datposy = 0.;
    double curx, cury, prex, prey;
    curx = cury = prex = prey = 0;

    datposx = pAbsHead->beginX;
    datposy = pAbsHead->beginY;

    curx = (datposx) / factor + dpx;
    cury = (datposy) / factor + dpy;

    if (QUIX_SHOWDIRX == -1)
    {
        curx = (width)-curx;
    }
    if (QUIX_SHOWDIRY == -1)
    {
        cury = (height)-cury;
    }

    absDataPtr = pData;

    QColor color = QColor(Qt::green);
    pen.setColor(color);
    painter.setPen(pen);

    for (int i = 0; i < stepsize; i++)
    {
        // 读入一个针步数据
        ctrlByte = absDataPtr->ctrl;

        prex = curx;
        prey = cury;

        dx = absDataPtr->ax;
        dy = absDataPtr->ay;

        datposx = dx;
        datposy = dy;

        curx = (datposx) / factor + dpx;
        cury = (datposy) / factor + dpy;

        if (QUIX_SHOWDIRX == -1)
        {
            curx = (width)-curx;
        }
        if (QUIX_SHOWDIRY == -1)
        {
            cury = (height)-cury;
        }

        if(i == 0)
        {
            absDataPtr++;
            continue;
        }

        if (ctrlByte == DATA_SEWING)
        {
            QPointF p1(prex, prey);
            QPointF p2(curx, cury);
            painter.drawLine(p1, p2);
        }
        else
        {
            //painter.drawLine(prex, prey, curx, cury);
            //qDebug("other type=0x%x", ctrlByte);
        }

        absDataPtr++;
    }

    // 保存成文件
    QString preview = getFileFullPathName();
    if (saveflag != 0 && preview.isEmpty() == false)
    {
#if (1)
        preview += ".preview.png";
        pImage->save(preview, "png");
#endif
    }

    if (pImage != NULL && newimgflag == 1)
    {
        delete pImage;
    }

    return 0;
}

QuixFileHead *DataFileQuix::getQuixHead()
{
    if(m_fileData.size() <= 0)
    {
        loadFile();
    }

    QuixFileHead *head = NULL;

    int size = m_fileData.size();
    if (size <= (int)(sizeof(QuixFileHead)))
    {
        head = new QuixFileHead;
        memset(head,0,sizeof(QuixFileHead));
        return head;
    }

    head = (QuixFileHead *)(m_fileData.data());
    return head;
}

void DataFileQuix::writePatternParaToFile(QuixFileHead *head)
{
    if(m_fileData.size() <= 0)
    {
        return;
    }

    memcpy(m_fileData.data(),(char*)head,sizeof(QuixFileHead));

    QFile wfile(m_fileFullPathName);
    if(!wfile.open(QIODevice::WriteOnly | QIODevice::Truncate))
    {
        qDebug() << "open file fail when read, path =" << m_fileFullPathName;
        return;
    }

    wfile.write(m_fileData);
    wfile.close();
}

void DataFileQuix::moveDataBeginPonit(s32 left, s32 front)
{
    if((u32)m_absData.size() > sizeof(DataDs16FileHead))
    {
        DataDs16FileHead *dhead = (DataDs16FileHead *)( m_absData.data());
        dhead->beginX += left;
        dhead->beginY += front;
        dhead->maxX += left;
        dhead->minX += left;
        dhead->maxY += front;
        dhead->minY += front;
    }
}

int DataFileQuix::doubleHeadCreatePreviewImage(QImage *pImg, int saveflag, int penwidth, int reDraw)
{
#if(1)
    if(reDraw == 0)//图片存在则不重画
    {
        // 图片是否存在，存在则返回
        QString previewPath = getFileFullPathName() + ".preview.png";
        QFile imageFile(previewPath);
        if (imageFile.exists())
        {
            return 1;
        }
    }
#endif

    int newimgflag = 0;
    QImage * pImage;
    double width, height;
    if (pImg == NULL)
    {
        width = QUIX_PREVIEW_WIDTH;
        height = QUIX_PREVIEW_HEIGHT;
        pImage = new QImage(width, height, IMAGE_TYPE);
        newimgflag = 1;
    }
    else
    {
        pImage = pImg;
    }

    width = pImage->width();
    height = pImage->height();
    if (width <= QUIX_PREVIEW_SIDE*2 || height <= QUIX_PREVIEW_SIDE*2)
    {
        if (pImage != NULL && newimgflag == 1)
        {
            delete pImage;
        }
        qDebug("preview img too small");
        return -1;
    }

    memset(pImage->bits(), 0x00, pImage->byteCount());

    QPainter painter(pImage);
    QColor backcolor(255, 255, 255, 0);         // 透明背景
    // 背景
    QPen pen;
    pen.setWidth(penwidth);
    pen.setColor(backcolor);
    painter.setPen(pen);
    painter.setBrush(backcolor);
    painter.drawRect(0, 0, width, height);

    // 图形
    //qDebug()<<"convertDataToAbs defore";
    doubleHeadConvertDataToEmbAbs(0);     // 转换为绝对坐标数据
    //qDebug()<<"convertDataToAbs end";

    // absdat数据
    int size = m_absData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("2 data less then head size");
        return -1;
    }
    //DataDs16FileHead * pAbsHead = (DataDs16FileHead *)(m_absData.data());
    int datasize = size - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        qDebug("absdat dataBegin err");
        return -1;
    }
    int stepsize = datasize/sizeof(DsAbsItem);
    if (stepsize <= 0)
    {
        qDebug("absdat data size err");
        return -1;
    }
    DsAbsItem * pData = (DsAbsItem *)(m_absData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;
    //--------

    // 图形显示区域
    int dpminx = QUIX_PREVIEW_SIDE;
    int dpmaxx = width - QUIX_PREVIEW_SIDE;
    int dpminy = QUIX_PREVIEW_SIDE;
    int dpmaxy = height - QUIX_PREVIEW_SIDE;

    // 计算缩放系数
    double factor, temp;
    if ((dpmaxx - dpminx) <= 0 || (dpmaxy - dpminy) <= 0)
    {
        return -1;
    }

    factor = (double)(fabs(m_maxX - m_minX)) / (dpmaxx - dpminx);      // 按x计算的缩放系数
    temp =   (double)(fabs(m_maxY - m_minY)) / (dpmaxy - dpminy);      // 按x计算的缩放系数

    if (temp >= factor)     // 使用较大的缩放系数
    {
        factor = temp;
    }

    // 计算显示参数，按照图形的实际位置显示（数据坐标零点对应图形中心）
    double dpx = (double)((dpminx+dpmaxx)/2 - ((m_maxX+m_minX)/factor)/2);
    double dpy = (double)((dpminy+dpmaxy)/2 - ((m_maxY+m_minY)/factor)/2);

    // 显示花样图形
    u8 ctrlByte;
    double dx;
    double dy;

    double firOftX = m_firstPointLeft.x - m_firstAbsPoint.x();
    double firOftY = 0 - (m_firstPointLeft.y - m_firstAbsPoint.y());

    double secOftX = m_firstPointRight.x - m_firstPointLeft.x;
    double secOftY = 0 - (m_firstPointRight.y - m_firstPointLeft.y);//因为中间数据y向取反了，所以这里用0减

    double datposx1, datposy1, datposx2, datposy2;
    datposx1 = datposy1 = datposx2 = datposy2 = 0.;
    double curx1, cury1, prex1, prey1;
    curx1 = cury1 = prex1 = prey1 = 0;
    double curx2, cury2, prex2, prey2;
    curx2 = cury2 = prex2 = prey2 = 0;

    //判断数据是否为第二机头开始
    if(absDataPtr->ctrl == DATA_OFFSET_SEC || absDataPtr->ctrl == DATA_SEWING_R)
    {
        datposx2 = 0;
        datposy2 = 0;

        datposx1 = 0 - secOftX;
        datposy1 = 0 - secOftY;
    }
    else
    {
        datposx1 = 0;
        datposy1 = 0;

        datposx2 = secOftX;
        datposy2 = secOftY;
    }

    curx1 = (datposx1) / factor + dpx;
    cury1 = (datposy1) / factor + dpy;

    int showDirX = QUIX_SHOWDIRX;
    int showDirY = QUIX_SHOWDIRY;

    if (showDirX == -1)
    {
        curx1 = (width)-curx1;
    }
    if (showDirY == -1)
    {
        cury1 = (height)-cury1;
    }

    curx2 = (datposx2) / factor + dpx;
    cury2 = (datposy2) / factor + dpy;

    if (showDirX == -1)
    {
        curx2 = (width)-curx2;
    }
    if (showDirY == -1)
    {
        cury2 = (height)-cury2;
    }

    absDataPtr = pData;

    QColor color = QColor(Qt::green);
    pen.setColor(color);
    painter.setPen(pen);

    for (int i = 0; i < stepsize; i++)
    {
        // 读入一个针步数据
        ctrlByte = absDataPtr->ctrl;

        if(ctrlByte == QUIX_OFFSET)
        {
            firOftX = absDataPtr->ax;
            firOftY = absDataPtr->ay;
        }

        if(ctrlByte == QUIX_OFFSET_SEC)
        {
            secOftX = absDataPtr->ax - firOftX;
            secOftY = absDataPtr->ay - firOftY;
        }

        if(ctrlByte == QUIX_SEWING || ctrlByte == QUIX_OFFSET ||
                ctrlByte == QUIX_SYNC_OFFSET || ctrlByte == QUIX_MIRROR_SEC ||
                ctrlByte == QUIX_MIRROR_OFT_SEC || ctrlByte == QUIX_SYNC_SEWING)//左机头
        {
            //左机头
            prex1 = curx1;
            prey1 = cury1;

            dx = absDataPtr->ax;
            dy = absDataPtr->ay;

            datposx1 = dx;
            datposy1 = dy;

            curx1 = (datposx1) / factor + dpx;
            cury1 = (datposy1) / factor + dpy;

            if (showDirX == -1)
            {
                curx1 = (width)-curx1;
            }
            if (showDirY == -1)
            {
                cury1 = (height)-cury1;
            }

            if (ctrlByte == QUIX_OFFSET || ctrlByte == QUIX_SYNC_OFFSET || ctrlByte == QUIX_MIRROR_OFT_SEC || ctrlByte == DATA_NULL)
            {
                //偏移数据和j结束不绘制
                //painter.drawLine(QLineF(prex1, prey1, curx1, cury1));
            }
            else
            {
                painter.drawLine(QLineF(prex1, prey1, curx1, cury1));
                //qDebug()<<"1"<<i<<prex1<<curx1<<" "<<prey1<<cury1;
            }
        }

        if(ctrlByte == QUIX_SEWING_SEC || ctrlByte == QUIX_OFFSET_SEC ||
                ctrlByte == QUIX_SYNC_OFFSET || ctrlByte == QUIX_MIRROR_SEC ||
                ctrlByte == QUIX_MIRROR_OFT_SEC || ctrlByte == QUIX_SYNC_SEWING)//右机头
        {
            //右机头
            prex2 = curx2;
            prey2 = cury2;

            if(ctrlByte == QUIX_OFFSET_SEC || ctrlByte == QUIX_SEWING_SEC)
            {
                dx = absDataPtr->ax;
                dy = absDataPtr->ay;
            }
            else
            {
                dx = absDataPtr->ax + secOftX;
                dy = absDataPtr->ay + secOftY;
            }

            if(ctrlByte == QUIX_MIRROR_SEC || ctrlByte == QUIX_MIRROR_OFT_SEC)
            {
                dx = secOftX + (firOftX - absDataPtr->ax) + firOftX;
            }

            datposx2 = dx;
            datposy2 = dy;

            curx2 = (datposx2) / factor + dpx;
            cury2 = (datposy2) / factor + dpy;

            if (showDirX == -1)
            {
                curx2 = (width)-curx2;
            }
            if (showDirY == -1)
            {
                cury2 = (height)-cury2;
            }

            if (ctrlByte == QUIX_OFFSET_SEC || ctrlByte == QUIX_SYNC_OFFSET || ctrlByte == QUIX_MIRROR_OFT_SEC || ctrlByte == DATA_NULL)
            {
                //偏移数据和j结束不绘制
                //painter.drawLine(QLineF(prex2, prey2, curx2, cury2));
            }
            else
            {
                painter.drawLine(prex2, prey2, curx2, cury2);
                //qDebug()<<"2"<<i<<prex2<<curx2<<" "<<prey2<<cury2;
            }
        }

        if(i == 0)
        {
            absDataPtr++;
            continue;
        }

        absDataPtr++;
    }

    // 保存成文件
    QString preview = getFileFullPathName();
    if (saveflag != 0 && preview.isEmpty() == false)
    {
#if (1)
        preview += ".preview.png";
        pImage->save(preview, "png");
#endif
    }

    if (pImage != NULL && newimgflag == 1)
    {
        delete pImage;
    }

    return 0;
}

void DataFileQuix::doubleHeadConvertDataToEmbAbs(s16 flag)
{
    if(flag == 0){}//去掉编译警告
    m_absData.clear();

    // 图形数据
    u32 i, datasize, idx;
    unsigned char ctrl, tmpls;

    u8 c1, c2, c3, c4;
    u32 lsdata;
    double deltx, delty, deltx1, delty1, deltx2, delty2;
    double threex[4], threey[4];
    s16 nmstep;

    double factorx, factory, unitmuti;
    factorx = factory = unitmuti = 1;
    QuixFileHead * head = (QuixFileHead *)(m_fileData.data());//头文件的结构体

    nmstep = head->normalStep * 10;
    if(nmstep == 0)
    {
        nmstep = 200;    //单位0.01mm（2mm）
    }

    i = sizeof(QuixFileHead);
    datasize = m_fileData.size();

    DsAbsItem absItem;
    memset(&absItem,0,sizeof(DsAbsItem));

    int firstLeftOft = 0;//左机头第一个偏移点，要记作左机头的起始点，双头组合机型
    int firstRightOft = 0;//右机头第一个偏移点，要记作右机头的起始点，双头组合机型

    while(i < datasize)
    {
#if(0)
        int stepSize = m_absData.size()/sizeof(DsAbsItem);
        if(stepSize >= 2700)
        {
            int a = 0;
            a = 1;
        }
#endif
        // 功能控制字
        if (i >= datasize){break;}
        ctrl = m_fileData.at(i++);

        // 图元类型
        if (i >= datasize){break;}
        tmpls = m_fileData.at(i++);

        // 附加控制字
        if (i >= datasize){break;}
        m_fileData.at(i++);
        if (i >= datasize){break;}
        m_fileData.at(i++);

        if(ctrl == 0x00)		// 结束
        {
            break;
        }

        //如果为剪线，直接向后加12（点个数1和xy坐标值，共12字节），且将剪线码添加到m_absData中，坐标与前一坐标值相同
        if(ctrl == QUIX_CUTTER || ctrl == QUIX_SYNC_CUTTER || ctrl == QUIX_CUTTER_SEC)
        {
            i += 12;
            if (i >= datasize){break;}
            memcpy((char*)&absItem,m_absData.data()+m_absData.size()-sizeof(DsAbsItem),sizeof(DsAbsItem));
            if(ctrl == QUIX_CUTTER)
            {
                ctrl = DATA_CUTTRD;
            }
            else if(ctrl == QUIX_CUTTER_SEC)
            {
                ctrl = DATA_CUTTER_SEC;
            }
            else if(ctrl == QUIX_SYNC_CUTTER)
            {
                ctrl = DATA_SYNC_CUTTER;
            }
            absItem.ctrl = ctrl;
            m_absData.append((char*)&absItem,sizeof(DsAbsItem));
            continue;
        }

        switch(tmpls)
        {
        case QUI_TYPE_LINE: // 直线
        case QUI_TYPE_STEP: // 跨步
        case QUI_TYPE_HSTEP: // 翻头跨步
        {
            //增加剪线
            if(tmpls == QUI_TYPE_STEP || tmpls == QUI_TYPE_HSTEP)
            {
                if((u32)m_absData.size() >= sizeof(DsAbsItem))
                {
                    memcpy((char*)&absItem,m_absData.data()+m_absData.size()-sizeof(DsAbsItem),sizeof(DsAbsItem));
                    absItem.ctrl = DATA_CUTTRD;
                    m_absData.append((char*)&absItem,sizeof(DsAbsItem));
                }
            }

            // 点个数
            if (i >= datasize){break;}
            c1 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c2 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c3 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c4 = m_fileData.at(i++);
            lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);

            if(lsdata == 1)
            {
                //点x
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                double x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                deltx = x/factorx;

                //点y
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                double y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                delty = y/factory;

                //非起始点偏移，加到m_absData中
                memset(&absItem,0,sizeof(DsAbsItem));
                absItem.ax = deltx;
                absItem.ay = delty;
                //if((firstLeftOft == 1 && ctrl == QUIX_OFFSET) || (firstRightOft == 1 && ctrl == QUIX_OFFSET_SEC))
                //if(ctrl == QUIX_OFFSET || ctrl == QUIX_OFFSET_SEC)
                {
                    absItem.ctrl = ctrl;
                    m_absData.append((char*)&absItem,sizeof(DsAbsItem));
                }
            }
            else if (lsdata > 1)
            {
                // 第一个点
                //点x
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                double x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                deltx2 = x/factorx;

                //点y
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                double y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                delty2 = y/factory;

                for(idx = 1; idx < lsdata; idx++)	// 其余的点
                {
                    deltx1 = deltx2;
                    delty1 = delty2;

                    //点x
                    if (i >= datasize){break;}
                    c1 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c2 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c3 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c4 = m_fileData.at(i++);
                    x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                    deltx2 = x/factorx;

                    //点y
                    if (i >= datasize){break;}
                    c1 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c2 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c3 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c4 = m_fileData.at(i++);
                    y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                    delty2 = y/factory;

                    // 处理直线
                    calcLine(deltx1, delty1, deltx2, delty2, nmstep, m_absData, tmpls, ctrl);
                }

                if (idx != lsdata)
                {
                    break;
                }
            }

            //双头组合机型每个图元起始都会有一个偏移点
            if(firstLeftOft == 0 && lsdata == 1 && ctrl == QUIX_OFFSET)
            {
                firstLeftOft = 1;
                m_firstPointLeft.x = deltx;
                m_firstPointLeft.y = delty;
                m_firstPointLeft.ctrl = ctrl;
            }
            if(firstRightOft == 0 && lsdata == 1 && ctrl == QUIX_OFFSET_SEC)
            {
                firstRightOft = 1;
                m_firstPointRight.x = deltx;
                m_firstPointRight.y = delty;
                m_firstPointRight.ctrl = ctrl;
            }

            break;
        }
        case QUI_TYPE_ARC: // 三点圆弧
        {
            // 点个数
            if (i >= datasize){break;}
            c1 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c2 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c3 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c4 = m_fileData.at(i++);
            lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);

            if(lsdata == 1)
            {
                //点x
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                double x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                deltx = x/factorx;

                //点y
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                double y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                delty = y/factory;

                //非起始点偏移，加到m_absData中
                memset(&absItem,0,sizeof(DsAbsItem));
                absItem.ax = deltx;
                absItem.ay = delty;
                //if((firstLeftOft == 1 && ctrl == QUIX_OFFSET) || (firstRightOft == 1 && ctrl == QUIX_OFFSET_SEC))
                //if(ctrl == QUIX_OFFSET || ctrl == QUIX_OFFSET_SEC)
                {
                    absItem.ctrl = ctrl;
                    m_absData.append((char*)&absItem,sizeof(DsAbsItem));
                }
            }
            else
            {
                if(lsdata != 3)
                {
                    break;
                }

                for (idx = 0; idx < lsdata; idx++)
                {
                    //点x
                    if (i >= datasize){break;}
                    c1 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c2 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c3 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c4 = m_fileData.at(i++);
                    double x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                    threex[idx] = x/factorx;

                    //点y
                    if (i >= datasize){break;}
                    c1 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c2 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c3 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c4 = m_fileData.at(i++);
                    double y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                    threey[idx] = y/factory;
                }

                //添加圆弧第一个点
                memset(&absItem,0,sizeof(DsAbsItem));
                absItem.ax = threex[0];
                absItem.ay = threey[0];
                absItem.ctrl = ctrl;
                m_absData.append((char*)&absItem,sizeof(DsAbsItem));
                calcCurve(threex, threey, nmstep, m_absData, ctrl);

                if (idx != 3)
                {
                    break;
                }
            }

            //双头组合机型每个图元起始都会有一个偏移点
            if(firstLeftOft == 0 && lsdata == 1 && ctrl == QUIX_OFFSET)
            {
                firstLeftOft = 1;
                m_firstPointLeft.x = deltx;
                m_firstPointLeft.y = delty;
                m_firstPointLeft.ctrl = ctrl;
            }
            if(firstRightOft == 0 && lsdata == 1 && ctrl == QUIX_OFFSET_SEC)
            {
                firstRightOft = 1;
                m_firstPointRight.x = deltx;
                m_firstPointRight.y = delty;
                m_firstPointRight.ctrl = ctrl;
            }
            break;
        }
        case QUI_TYPE_BES: // 贝塞尔曲线
        {
            // 点个数
            if (i >= datasize){break;}
            c1 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c2 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c3 = m_fileData.at(i++);
            if (i >= datasize){break;}
            c4 = m_fileData.at(i++);
            lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
            if(lsdata == 1)
            {
                //点x
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                double x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                deltx = x/factorx;

                //点y
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                double y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                delty = y/factory;

                //非起始点偏移，加到m_absData中
                memset(&absItem,0,sizeof(DsAbsItem));
                absItem.ax = deltx;
                absItem.ay = delty;
                //if((firstLeftOft == 1 && ctrl == QUIX_OFFSET) || (firstRightOft == 1 && ctrl == QUIX_OFFSET_SEC))
                //if(ctrl == QUIX_OFFSET || ctrl == QUIX_OFFSET_SEC)
                {
                    absItem.ctrl = ctrl;
                    m_absData.append((char*)&absItem,sizeof(DsAbsItem));
                }
            }
            else
            {
                if(lsdata != 4)
                {
                    break;
                }

                for (idx = 0; idx < lsdata; idx++)
                {
                    //点x
                    if (i >= datasize){break;}
                    c1 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c2 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c3 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c4 = m_fileData.at(i++);
                    double x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                    threex[idx] = x/factorx;

                    //点y
                    if (i >= datasize){break;}
                    c1 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c2 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c3 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c4 = m_fileData.at(i++);
                    double y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                    threey[idx] = y/factory;
                }

                // 处理贝塞尔曲线
                QList<QPointF> splineListXY;//拟合后的点
                splineListXY.clear();
                getBezierPointList(threex, threey, nmstep,splineListXY);

                QList<QPointF> splitListXY;//均分后的点
                splitListXY.clear();
                if(splineListXY.size() > 0)
                {
                    getCurvePointFillLine(splineListXY,nmstep,splitListXY,0,OBJECT_STITCHLEN_NEW_SAMALL);
                }

                //添加贝塞尔曲线数据点
                for(int i = 0; i < splitListXY.size(); i++)
                {
                    memset(&absItem,0,sizeof(DsAbsItem));

                    deltx1 = splitListXY[i].x();
                    delty1 = splitListXY[i].y();

                    absItem.ctrl = ctrl;
                    absItem.ax = deltx1;
                    absItem.ay = delty1;
                    m_absData.append((char*)&absItem,sizeof(DsAbsItem));
                }
                //calcBezier(threex, threey, nmstep, m_absData);
                if (idx != 4)
                {
                    break;
                }
            }

            //双头组合机型每个图元起始都会有一个偏移点
            if(firstLeftOft == 0 && lsdata == 1 && ctrl == QUIX_OFFSET)
            {
                firstLeftOft = 1;
                m_firstPointLeft.x = deltx;
                m_firstPointLeft.y = delty;
                m_firstPointLeft.ctrl = ctrl;
            }
            if(firstRightOft == 0 && lsdata == 1 && ctrl == QUIX_OFFSET_SEC)
            {
                firstRightOft = 1;
                m_firstPointRight.x = deltx;
                m_firstPointRight.y = delty;
                m_firstPointRight.ctrl = ctrl;
            }

            break;
        }
        case QUI_TYPE_SPLINE: // 样条
        {
            QList<QPointF> quiListPoint;//样条拟合前的点集合
            quiListPoint.clear();

            // 点个数
            if (i >= datasize){break;}
            unsigned char c1 = m_fileData.at(i++);
            if (i >= datasize){break;}
            unsigned char c2 = m_fileData.at(i++);
            if (i >= datasize){break;}
            unsigned char c3 = m_fileData.at(i++);
            if (i >= datasize){break;}
            unsigned char c4 = m_fileData.at(i++);
            lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);

            if(lsdata == 1)
            {
                //点x
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                double x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                deltx = x/factorx;

                //点y
                if (i >= datasize){break;}
                c1 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c2 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c3 = m_fileData.at(i++);
                if (i >= datasize){break;}
                c4 = m_fileData.at(i++);
                double y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                delty = y/factory;

                //非起始点偏移，加到m_absData中
                memset(&absItem,0,sizeof(DsAbsItem));
                absItem.ax = deltx;
                absItem.ay = delty;
                //if((firstLeftOft == 1 && ctrl == QUIX_OFFSET) || (firstRightOft == 1 && ctrl == QUIX_OFFSET_SEC))
                //if(ctrl == QUIX_OFFSET || ctrl == QUIX_OFFSET_SEC)
                {
                    absItem.ctrl = ctrl;
                    m_absData.append((char*)&absItem,sizeof(DsAbsItem));
                }
            }
            else
            {
                for(idx = 0; idx < lsdata; idx++)	// 点
                {
                    //点x
                    if (i >= datasize){break;}
                    c1 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c2 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c3 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c4 = m_fileData.at(i++);
                    double x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                    deltx1 = x/factorx;

                    //点y
                    if (i >= datasize){break;}
                    c1 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c2 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c3 = m_fileData.at(i++);
                    if (i >= datasize){break;}
                    c4 = m_fileData.at(i++);
                    double y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
                    delty1 = y/factory;

                    QPointF point(deltx1,delty1);
                    quiListPoint.append(point);
                }

                QList<QPointF> splineListXY;//拟合后的点
                splineListXY.clear();
                if(quiListPoint.size() <= 0)
                {
                    break;
                }
                getSplineNew(quiListPoint,splineListXY);

                // 均分
                QList<QPointF> splitListXY;//均分后的点
                splitListXY.clear();
                if(splineListXY.size() > 0)
                {
                    getCurvePointFillLine(splineListXY,nmstep,splitListXY,0,OBJECT_STITCHLEN_NEW_SAMALL);
                }

                //添加样条曲线数据点
                for(int i = 0; i < splitListXY.size(); i++)
                {
                    memset(&absItem,0,sizeof(DsAbsItem));

                    deltx1 = splitListXY[i].x();
                    delty1 = splitListXY[i].y();

                    absItem.ctrl = ctrl;
                    absItem.ax = deltx1;
                    absItem.ay = delty1;
                    m_absData.append((char*)&absItem,sizeof(DsAbsItem));
                }

                if(idx != lsdata)
                {
                    break;
                }
            }

            //双头组合机型每个图元起始都会有一个偏移点
            if(firstLeftOft == 0 && lsdata == 1 && ctrl == QUIX_OFFSET)
            {
                firstLeftOft = 1;
                m_firstPointLeft.x = deltx;
                m_firstPointLeft.y = delty;
                m_firstPointLeft.ctrl = ctrl;
            }
            if(firstRightOft == 0 && lsdata == 1 && ctrl == QUIX_OFFSET_SEC)
            {
                firstRightOft = 1;
                m_firstPointRight.x = deltx;
                m_firstPointRight.y = delty;
                m_firstPointRight.ctrl = ctrl;
            }
            break;
        }
        default:
            break;
        }
    }

    //生成绝对坐标数据的文件头
    DataDs16FileHead dhead;
    memset(&dhead, 0, sizeof(DataDs16FileHead));

    int stepSize = m_absData.size()/sizeof(DsAbsItem);
    if(stepSize <= 0)
    {
        return;
    }

    DsAbsItem * absDataPtr = (DsAbsItem *)(m_absData.data());
    double firstX = absDataPtr->ax;
    double firstY = absDataPtr->ay;
    m_firstAbsPoint.setX(firstX);
    m_firstAbsPoint.setY(firstY);

    double minX, maxX, minY, maxY;
    minX = S32_MAX;
    maxX = S32_MIN;
    minY = S32_MAX;
    maxY = S32_MIN;

    int dataDirY = QUIX_DATADIRY*-1;

    double prex,prey,curx,cury,dx,dy,ar;
    prex = prey = curx = cury = dx = dy = ar = 0;
    double curx2,cury2;
    curx2 = cury2 = 0;

    double firOftX = 0;
    double firOftY = 0;

    double secOftX = m_firstPointRight.x - m_firstPointLeft.x;
    double secOftY = m_firstPointRight.y - m_firstPointLeft.y;

    //将absDataPtr的每个点都减去起始点，并求最大最小值（包括左机头和右机头），将起点看作零
    for (int i = 0; i < stepSize; i++)
    {
        ctrl = absDataPtr->ctrl;

#if(0)
        if(ctrl == DATA_CUTTRD || ctrl == DATA_CUTTER_SEC || ctrl == DATA_SYNC_CUTTER || i >= 25)
        {
            int a = 0;
            a = 1;
        }
#endif

        absDataPtr->ax -= firstX;
        absDataPtr->ay -= firstY;

        absDataPtr->ax *= QUIX_DATADIRX;
        absDataPtr->ay *= dataDirY;

        if(ctrl == QUIX_OFFSET)
        {
            firOftX = absDataPtr->ax;
            firOftY = absDataPtr->ay;
        }

        if(ctrl == QUIX_OFFSET_SEC)
        {
            secOftX = absDataPtr->ax - firOftX;
            secOftY = absDataPtr->ay - firOftY;
        }

        curx = absDataPtr->ax;
        cury = absDataPtr->ay;

        if(ctrl == QUIX_OFFSET_SEC || ctrl == QUIX_SEWING_SEC)
        {
            curx2 = absDataPtr->ax;
            cury2 = absDataPtr->ay;
        }
        else
        {
            if(ctrl != QUIX_OFFSET && ctrl != QUIX_SEWING)
            {
                curx2 = curx + secOftX;
                cury2 = cury - secOftY;//因为y方向取反了，所以这里用减法，如果不取反，应该用加法
            }
        }

        if(ctrl == QUIX_MIRROR_SEC)
        {
            curx2 = secOftX + (firOftX - curx) + firOftX;
        }

        if(curx > maxX)
        {
            maxX = curx;
        }
        if(curx < minX)
        {
            minX = curx;
        }

        if(cury > maxY)
        {
            maxY = cury;
        }
        if(cury < minY)
        {
            minY = cury;
        }

        if(curx2 > maxX)
        {
            maxX = curx2;
        }
        if(curx2 < minX)
        {
            minX = curx2;
        }

        if(cury2 > maxY)
        {
            maxY = cury2;
        }
        if(cury2 < minY)
        {
            minY = cury2;
        }

        absDataPtr++;
    }

    absDataPtr = (DsAbsItem *)(m_absData.data());
    double btar = atan2(m_firstPointLeft.y,m_firstPointLeft.x);
    double begR = (btar*10000+0.5*(btar>0?1:-1));

    btar = atan2(m_firstPointRight.y,m_firstPointRight.x);
    double begR2 = (btar*10000+0.5*(btar>0?1:-1));

    prex = 0;//等于起始点，这里以左机头计算角度，因为左右机头轨迹相同
    prey = 0;

    //缩放并求dr
    m_maxX = maxX;
    m_minX = minX;
    m_maxY = maxY;
    m_minY = minY;

    unitmuti = getMutiUnit(0);
    unitmuti = 1;

    double scanx = head->scanX * unitmuti;   // 宽度
    double scany = head->scanY * unitmuti;   // 长度

    if (scanx < 1)
    {
        scanx = m_maxX-m_minX;
    }
    if (scany < 1)
    {
        scany = m_maxY-m_minY;
    }

    // 计算缩放系数
    factorx = (double)((m_maxX-m_minX) / (scanx));
    factory = (double)((m_maxY-m_minY) / (scany));

    if(factorx == 0){factorx = 1;}
    if(factory == 0){factory = 1;}

    //    if(flag == 1)//双头组合机型注释掉
    //    {
    //        factorx = 1;
    //        factory = 1;
    //    }

    for (int i = 0; i < stepSize; i++)
    {
        absDataPtr->ax /= factorx;
        absDataPtr->ay /= factory;

        curx = absDataPtr->ax;
        cury = absDataPtr->ay;

        dx = curx - prex;
        dy = cury - prey;

        double tar = atan2(dy,dx);
        ar = (tar*10000+0.5*(tar>0?1:-1));
        absDataPtr->ar = ar;

        prex = curx;
        prey = cury;

        absDataPtr++;
    }

    //增加结束码
    if((u32)m_absData.size() >= sizeof(DsAbsItem))
    {
        DsAbsItem absItem;
        memset(&absItem,0,sizeof(DsAbsItem));
        memcpy((char*)&absItem,m_absData.data()+m_absData.size()-sizeof(DsAbsItem),sizeof(DsAbsItem));
        absItem.ctrl = DATA_END;
        m_absData.append((char*)&absItem,sizeof(DsAbsItem));
        stepSize++;
    }

    maxX /= factorx;
    maxY /= factory;
    minX /= factorx;
    minY /= factory;

    m_maxX = maxX;
    m_minX = minX;
    m_maxY = maxY;
    m_minY = minY;

    m_firstPointLeft.x /= factorx;
    m_firstPointLeft.y /= factory;
    m_firstPointRight.x /= factorx;
    m_firstPointRight.y /= factory;

    //生成文件头
    dhead.maxX = maxX;
    dhead.maxY = maxY;
    dhead.minX = minX;
    dhead.minY = minY;
    dhead.beginX = m_firstPointLeft.x;
    dhead.beginY = m_firstPointLeft.y;
    dhead.beginR = begR;
    dhead.beginX2 = m_firstPointRight.x;
    dhead.beginY2 = m_firstPointRight.y;
    dhead.beginR2 = begR2;
    dhead.anchorX = 0;
    dhead.anchorY = 0;
    dhead.itemNums = stepSize;
    dhead.dataSize = stepSize*sizeof(DsAbsItem);    // 数据字节数
    dhead.bytesPerItem = sizeof(DsAbsItem);           // 每项占的字节数
    dhead.dataChecksum = calcCheckSum32((u8 *)(m_absData.data()) , dhead.dataSize);;	// 数据累加校验和
    dhead.checkCrc = calcCrc16((u8 *)(&dhead), HEAD_FIX_INFO_LEN); // 前面6个字段的CRC校验，（6个字段分别为：文件名称，字节数，项个数，每项字节数，每块字节数，数据累加和的CRC校验值）
    dhead.fileid = dhead.checkCrc;
    m_absData.insert(0,(char*)&dhead,sizeof(DataDs16FileHead));
}

void DataFileQuix::writeFileLL(int left, int front, int startX, int startY)
{
    QuixFileHead *pQuixHead = getQuixHead();

    if(left < 0)
    {
        left = 0;
    }
    if(front < 0)
    {
        front = 0;
    }

    pQuixHead->left = left;
    pQuixHead->front = front;

    pQuixHead->startX = startX;
    pQuixHead->startY = startY;

    QFile wfile(m_fileFullPathName);
    if(!wfile.open(QIODevice::WriteOnly | QIODevice::Truncate))
    {
        qDebug() << "open file fail when read, path =" << m_fileFullPathName;
        return;
    }

    wfile.write(m_fileData);
    wfile.close();

#ifdef Q_OS_LINUX
    system("sync");
#endif
}

int DataFileQuix::getStitchNums()
{
    if(m_absData.size() <= 0)
    {
        return 0;
    }

    DataDs16FileHead * pHead = (DataDs16FileHead *)((m_absData.data()));
    return pHead->itemNums;
}

int DataFileQuix::getDatWidth()
{
    if(m_absData.size() <= 0)
    {
        return 0;
    }

    DataDs16FileHead * pHead = (DataDs16FileHead *)((m_absData.data()));
    return (pHead->maxX - pHead->minX);
}

int DataFileQuix::getDatHeight()
{
    if(m_absData.size() <= 0)
    {
        return 0;
    }

    DataDs16FileHead * pHead = (DataDs16FileHead *)((m_absData.data()));
    return (pHead->maxY - pHead->minY);
}

int DataFileQuix::getMaxX()
{
    if(m_absData.size() <= 0)
    {
        return 0;
    }

    DataDs16FileHead * pHead = (DataDs16FileHead *)((m_absData.data()));
    return pHead->maxX;
}

int DataFileQuix::getMinX()
{
    if(m_absData.size() <= 0)
    {
        return 0;
    }

    DataDs16FileHead * pHead = (DataDs16FileHead *)((m_absData.data()));
    return pHead->minX;
}

int DataFileQuix::getMaxY()
{
    if(m_absData.size() <= 0)
    {
        return 0;
    }

    DataDs16FileHead * pHead = (DataDs16FileHead *)((m_absData.data()));
    return pHead->maxY;
}

int DataFileQuix::getMinY()
{
    if(m_absData.size() <= 0)
    {
        return 0;
    }

    DataDs16FileHead * pHead = (DataDs16FileHead *)((m_absData.data()));
    return pHead->minY;
}