#include "embdata.h"
#include "main.h"
#include "sharedviews/setcontrolstyle.h"
#include <QList>
#include <bitset>

static int emb_showDirX = (1);// X向显示坐标和数据坐标的差异
static int emb_showDirY = (1);// Y向显示坐标和数据坐标的差异

const int headNum = 5; // 机头数

EmbData::EmbData()
{
    m_pEmbDs16Head = new DataDs16FileHead();
    m_penHeadPix.resize(5);
    m_penPoint.resize(5);
    clear();
}

EmbData::~EmbData()
{
    clear();
    if(m_pEmbDs16Head != NULL)
    {
        delete m_pEmbDs16Head;
    }
}

void EmbData::clear()
{
    m_maxX = 0;
    m_minX = 0;
    m_maxY = 0;
    m_minY = 0;
    m_fileid = 0;

    m_spaceX = 0;
    m_spaceY = 0;

    m_penX = 0;
    m_penY = 0;

    m_embDs16Data.clear();

    m_editedflag = 0;
    m_filePath.clear();
    m_factor = 0;

    m_dispDatFront.clear();//飞梭机前排数据
    m_dispDatMiddle.clear();//飞梭机中排数据
    m_dispDatBehind.clear();//飞梭机后排数据

    m_dispMinX = S32_MAX;
    m_dispMaxX = S32_MIN;
    m_dispMinY = S32_MAX;
    m_dispMaxY = S32_MIN;
    m_oftNeedleSize = 0;
    m_ritStepSize = 0;

    memset(m_pEmbDs16Head,0,sizeof(DataDs16FileHead));
}

QByteArray & EmbData::getDsDat()
{
    //qDebug()<<"m_editedflag"<<m_editedflag;
    if(m_editedflag != 0)
    {
        createEmbDs16FromAbs();
    }
    return m_embDs16Data;
}

//检查起针和末针的x坐标是否一致，如果有相差是不能绣作的，需要提示
bool EmbData::checkFirstEndNeedle(QByteArray ary)
{
    int size = ary.size();
    int datasize = size - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        qDebug("dat dataBegin err: datasize is non-positive!");
        return false;
    }

    int stepsize = datasize / sizeof(DsAbsItem);
    if (stepsize <= 0)
    {
        qDebug("ds16 data size err: stepsize is non-positive!");
        return false;
    }

    int firstX = 0;
    int endX = 0;
    DsAbsItem * ds16DataPtr = (DsAbsItem *)(ary.data() + sizeof(DataDs16FileHead));

    for(int i = 0; i < stepsize; i++)
    {
        // 确保指针不越界
        if (reinterpret_cast<char*>(ds16DataPtr) + sizeof(DsAbsItem) > ary.data() + size) {
            qDebug("Array access out of bounds at step %d", i);
            return false;
        }

        if(
                ds16DataPtr->ctrl == DATA_SEWING ||
                ds16DataPtr->ctrl == DATA_JUMP ||
                ds16DataPtr->ctrl == DATA_OFFSET)
        {
            if(i == 0)
            {
                firstX = ds16DataPtr->ax;
            }
            endX = ds16DataPtr->ax;
        }
        ds16DataPtr++;
    }

    if(abs(endX - firstX) != 0) // 不等于0mm
    {
        qDebug() << "firstX:" << firstX << "endX:" << endX;
        return false;
    }

    return true;
}

//按照标志位置来设置文件数据-旋转角度调整
QByteArray EmbData::rotationAngleAdjustment(int flag)
{
    // 检查数据大小是否足够
    if (m_embDs16Data.size() < static_cast<int>(sizeof(DataDs16FileHead)))
    {
        qDebug("dat dataBegin err: not enough data for header!");
        return QByteArray();
    }

    DataDs16FileHead *dataDs16FileHead = reinterpret_cast<DataDs16FileHead*>(m_embDs16Data.data());
    int size = m_embDs16Data.size();
    int datasize = size - static_cast<int>(sizeof(DataDs16FileHead));

    if (datasize <= 0)
    {
        qDebug("dat dataBegin err: datasize is non-positive!");
        return QByteArray();
    }

    int stepsize = datasize / static_cast<int>(sizeof(Ds16Item));
    if (stepsize <= 0)
    {
        qDebug("ds16 data size err: stepsize is non-positive!");
        return QByteArray();
    }

    Ds16Item *ds16DataPtr = reinterpret_cast<Ds16Item*>(m_embDs16Data.data() + sizeof(DataDs16FileHead));
    Ds16Item *ds16DataPtr_tmp = reinterpret_cast<Ds16Item*>(m_embDs16Data.data() + sizeof(DataDs16FileHead));
    QList<short> drList;
    for(int i = 0; i < stepsize; ++i)
    {
        drList.append(ds16DataPtr_tmp->dr);
        ds16DataPtr_tmp++;
    }

    switch (flag)
    {
    case 1:
    {
        dataDs16FileHead->beginR += ds16DataPtr->dr;
        for (int i = 0; i < stepsize - 1; ++i)
        {
            // 确保指针不越界
            if (reinterpret_cast<char*>(ds16DataPtr) + sizeof(Ds16Item) > m_embDs16Data.data() + size)
            {
                qDebug("Array access out of bounds at step %d", i);
                return  QByteArray();
            }
            ds16DataPtr->dr = drList.at(i+1);
            if (i == stepsize - 2)
            {
                (ds16DataPtr + 1)->dr = 0;
            }
            ds16DataPtr++;
        }
    }
        break;
    case -1:
    {
        for (int i = 0; i < stepsize - 1; ++i)
        {
            // 确保指针不越界
            if (reinterpret_cast<char*>(ds16DataPtr) + sizeof(Ds16Item) > m_embDs16Data.data() + size)
            {
                qDebug("Array access out of bounds at step %d", i);
                return QByteArray();
            }
            if (i == 0)
            {
                (ds16DataPtr + 1)->dr = drList.at(i);
                ds16DataPtr->dr = 0;
                continue;
            }
            (ds16DataPtr + 1)->dr = drList.at(i);
            ds16DataPtr++;
        }
    }
        break;
    case 0:
        return m_embDs16Data;
        break;
    default:
        qDebug()<<"The Flag is no meet the requirements!";
        return QByteArray();
    }

    return QByteArray();
}

QByteArray EmbData::getDispDat(double showWidth,double showHeight)
{
    QByteArray dispDat;

    ViewItem dispItem;
    dispDat.clear();//显示绘图用的数据（需要转换）

    // ds16数据
    int size = m_embDs16Data.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        return dispDat;
    }
    DataDs16FileHead * pDsHead = (DataDs16FileHead *)(m_embDs16Data.data());
    int datasize = size - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        return dispDat;
    }
    int stepsize = datasize/sizeof(Ds16Item);
    if (stepsize <= 0)
    {
        return dispDat;
    }

    double width = showWidth;
    double height = showHeight;

    Ds16Item * ds16DataPtr;
    Ds16Item * pData = (Ds16Item *)(m_embDs16Data.data() + sizeof(DataDs16FileHead));
    ds16DataPtr = pData;

    // 显示花样图形
    u8 ctrlByte;
    u8 attrByte;
    int dx;
    int dy;
    int dr;

    double datposx, datposy, datposr, firstx, firsty;
    double curx, cury, curr, prex, prey;
    curx = cury = curr = prex = prey = 0;

    double unit = 100.0;//因为ds16的数据是0.01毫米

    // 计算显示参数，按照图形的实际位置显示（数据坐标零点对应图形中心）
//    int dpx = (showWidth)/2.0 - ((m_maxX+m_minX)/unit)/2.0;
//    int dpy = (showHeight)/2.0 - ((m_maxY+m_minY)/unit)/2.0;

    int dpx = (showWidth)/2.0;
    int dpy = (showHeight)/2.0;

    datposx = pDsHead->beginX;
    datposy = pDsHead->beginY;
    datposr = pDsHead->beginR;

    firstx = pDsHead->beginX;
    firsty = pDsHead->beginY;

    curx = (datposx - firstx)/unit + dpx;
    cury = (datposy - firsty)/unit + dpy;

    if(isFlipDispYMac())
    {
        emb_showDirY = -1;
    }

    if(isFlipDispXMac())
    {
        emb_showDirX = -1;
    }

    if (emb_showDirX == -1)
    {
        curx = width - curx;
    }
    if (emb_showDirY == -1)
    {
        cury = height - cury;
    }

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

    for (int i = 0; i < stepsize; i++)
    {
        prex = curx;
        prey = cury;

        // 读入一个针步数据
        ctrlByte = ds16DataPtr->ctrl;
        attrByte = ds16DataPtr->attr;
        dx = ds16DataPtr->dx;
        dy = ds16DataPtr->dy;
        dr = ds16DataPtr->dr;

        datposx += dx;
        datposy += dy;
        datposr += dr;

        curx = (datposx - firstx)/unit + dpx;
        cury = (datposy - firsty)/unit + dpy;

        if (emb_showDirX == -1)
        {
            curx = width - curx;
        }
        if (emb_showDirY == -1)
        {
            cury = height - cury;
        }

        while(datposr >= PI10000)
        {
            datposr -= (PI20000-1);
        }
        while(datposr <= -PI10000)
        {
            datposr += (PI20000-1);
        }

        dispItem.ctrl = ctrlByte;
        dispItem.attr = attrByte;
        dispItem.bx = prex;
        dispItem.by = prey;
        dispItem.ex = curx;
        dispItem.ey = cury;
        dispItem.ar = curr;

        memcpy(&dispItem.action,ds16DataPtr->action,sizeof(dispItem.action));

        dispDat.append((char*)(&dispItem), sizeof(ViewItem));

        ds16DataPtr++;
    }

    return dispDat;
}

//设置数据区文件头的fileid，计算完以后的fileid再设置进来
void EmbData::setDsDatHeadFileID(u32 fileid)
{
    if(m_pEmbDs16Head != NULL)
    {
        m_pEmbDs16Head->fileid = fileid;
        if((u32)m_embDs16Data.size() > sizeof(DataDs16FileHead))
        {
            memcpy(m_embDs16Data.data(),(char*)m_pEmbDs16Head, sizeof(DataDs16FileHead));
        }
    }
}

//得到绝对坐标的maxXY和minXY
void EmbData::getAbsDatRangeXY()
{
    m_minX = S32_MAX;
    m_maxX = S32_MIN;
    m_minY = S32_MAX;
    m_maxY = S32_MIN;

    double ax, ay;
    int minx, miny, maxx, maxy;

    const QByteArray & ary = m_embAbsData;
    int size = ary.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
    }

    int datasize = size - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        qDebug("absdat dataBegin err");
        return;
    }
    int stepsize = datasize/sizeof(DsAbsItem);
    if (stepsize <= 0)
    {
        qDebug("absdat data size err");
        return;
    }
    DsAbsItem * pData = (DsAbsItem *)(ary.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;
    //-----
    minx = S32_MAX;
    maxx = S32_MIN;
    miny = S32_MAX;
    maxy = S32_MIN;

    // 数据区
    for (int j = 0; j < stepsize; j++)
    {
        ax = absDataPtr->ax;
        ay = absDataPtr->ay;

        if (minx > ax) { minx = ax; }
        if (maxx < ax) { maxx = ax; }
        if (miny > ay) { miny = ay; }
        if (maxy < ay) { maxy = ay; }

        absDataPtr++;
    }

    if (m_minX > minx) { m_minX = minx; }
    if (m_minX > maxx) { m_minX = maxx; }
    if (m_maxX < minx) { m_maxX = minx; }
    if (m_maxX < maxx) { m_maxX = maxx; }
    if (m_minY > miny) { m_minY = miny; }
    if (m_minY > maxy) { m_minY = maxy; }
    if (m_maxY < miny) { m_maxY = miny; }
    if (m_maxY < maxy) { m_maxY = maxy; }

    qDebug() << "==========================m_minX" << m_minX;
    qDebug() << "==========================m_minY" << m_minY;
    qDebug() << "==========================m_maxY" << m_maxY;
    qDebug() << "==========================m_maxX" << m_maxX;
}

// 添加锁针针步
///
/// \brief EmbData::addLockStitchs
/// \param mode
/// \param lockNeedles//锁针针数
/// \param lockNum//锁针次数
/// \return
///
int EmbData::addLockStitchs(u8 mode, u8 lockNeedles, u8 lockNum)
{
    if (lockNeedles <= 0)
    {
        return -1;
    }

    int size = m_embAbsData.size();
    if (size <= 0)
    {
        return -1;
    }

    u8 clockNeedles = lockNeedles;

    // 文件头
    int stepsize = (size - sizeof(DataDs16FileHead))/sizeof(DsAbsItem);
    if (stepsize <= 0)
    {
        qDebug("dat size err");
        return -1;
    }

    DataDs16FileHead * pHead =  (DataDs16FileHead *)(m_embAbsData.data());
    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;

    QByteArray tgtdsdat;    // 添加后的绝对坐标数据
    tgtdsdat.clear();
    tgtdsdat.append((char*)pHead, sizeof(DataDs16FileHead));

    //    if(mode == MODE_LOCK) //锁针  来回加固
    //    {
    //        QByteArray data = lockReinforce(lockNeedles, lockNum, absDataPtr, stepsize);
    //        tgtdsdat.append(data);
    //    }
    //    else if(mode == MODE_THICKEN) //密针  分割大针步
    //    {
    //        QByteArray data = thickenReinforce(lockNeedles, lockNum, absDataPtr, stepsize);
    //        tgtdsdat.append(data);
    //    }

    //DsAbsItem * test = (pData + stepsize - 1);//最后一针
    //DsAbsItem * test1 = pData;//第一针

    int runflag = 0;

    for (int j = 0; j < stepsize; j++)
    {
        if (absDataPtr->ctrl == DATA_SEWING || absDataPtr->ctrl == DATA_SEWING_R ||
                absDataPtr->ctrl == DATA_SYNCSEW || absDataPtr->ctrl == DATA_MIRROR_SEC)//包括起针和剪线后加锁针
        {
            if ((runflag == 0 || runflag > 3))
            {
                // 添加锁针
                if(mode == MODE_LOCK)//锁针方式
                {
                    int nst = 0;
                    if(lockNum%2 == 0)//偶数
                    {
                        nst = 0;
                    }
                    else//奇数
                    {
                        nst = lockNeedles;
                    }

                    if(j == 0 && lockNeedles == 1)
                    {
                        nst = lockNeedles;
                    }

                    do
                    {
                        if(j + nst < stepsize)
                        {
                            DsAbsItem * nextPtr = absDataPtr+nst;     // 要加锁针的点
                            if (nextPtr->ctrl == DATA_SEWING || nextPtr->ctrl == DATA_SEWING_R ||
                                    nextPtr->ctrl == DATA_SYNCSEW || nextPtr->ctrl == DATA_MIRROR_SEC)
                            {
                                if(lockNum%2 == 0)//偶数锁针
                                {
                                    nextPtr--;
                                    for (int kNum = 0; kNum < lockNum; kNum++)
                                    {
                                        if(kNum%2 == 0)
                                        {
                                            for (int s = 0; s < lockNeedles; s++)
                                            {
                                                nextPtr++;
                                                if(nextPtr >= pData && nextPtr < (pData + stepsize))
                                                {
                                                    DsAbsItem nitem;
                                                    memset(&nitem,0,sizeof(DsAbsItem));
                                                    nitem.ctrl  = absDataPtr->ctrl;
                                                    nitem.attr  = (absDataPtr->attr | ATTR_RESEW);
                                                    nitem.ax    = nextPtr->ax;
                                                    nitem.ay    = nextPtr->ay;
                                                    nitem.ar    = absDataPtr->ar;
                                                    tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
                                                }
                                            }
                                        }
                                        nextPtr++;//之前没有这一行，刘威添加
                                        if(kNum > 0 && kNum%2 != 0)
                                        {
                                            for (int s = lockNeedles; s > 0; s--)
                                            {
                                                nextPtr--;
                                                if(kNum == lockNum-1 && s == 1)
                                                {
                                                    continue;//最后一次锁针的最后一步不添加
                                                }
                                                if((nextPtr >= pData && nextPtr < (pData + stepsize)) || j == 0)
                                                {
                                                    DsAbsItem nitem;
                                                    memset(&nitem,0,sizeof(DsAbsItem));
                                                    nitem.ctrl = absDataPtr->ctrl;
                                                    nitem.attr = (absDataPtr->attr | ATTR_RESEW);
                                                    nitem.ax = nextPtr->ax;
                                                    nitem.ay = nextPtr->ay;
                                                    nitem.ar = absDataPtr->ar;
                                                    tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
                                                }
                                            }
                                        }
                                    }
                                }
                                else//奇数锁针
                                {
                                    {
                                        nextPtr--;
                                        if(nextPtr >= pData && nextPtr < (pData + stepsize))
                                        {
                                            DsAbsItem nitem;
                                            memset(&nitem,0,sizeof(DsAbsItem));
                                            nitem.ctrl = DATA_OFFSET;//第一针步转换为跨步
                                            nitem.attr = absDataPtr->attr;
                                            nitem.ax = nextPtr->ax;
                                            nitem.ay = nextPtr->ay;
                                            nitem.ar = absDataPtr->ar;
                                            tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
                                        }
                                        nextPtr++;//之前这一行为nextPtr--，刘威修改
                                    }

                                    for (int k = 0; k < lockNum; k++)
                                    {
                                        if(k%2 == 0)//偶数
                                        {
                                            for (int s = lockNeedles; s > 0; s--)
                                            {
                                                if (nextPtr >= pData && nextPtr < (pData + stepsize))
                                                {
                                                    DsAbsItem nitem;
                                                    memset(&nitem,0,sizeof(DsAbsItem));
                                                    nitem.ctrl = absDataPtr->ctrl;
                                                    nitem.attr = (absDataPtr->attr | ATTR_RESEW);
                                                    nitem.ax =  nextPtr->ax;
                                                    nitem.ay =  nextPtr->ay;
                                                    nitem.ar = absDataPtr->ar;
                                                    tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
                                                }
                                                nextPtr--;
                                            }
                                            nextPtr++;
                                        }

                                        if(k > 0 && k%2 != 0)//奇数
                                        {
                                            for (int s = 0; s < lockNeedles; s++)
                                            {
                                                nextPtr++;
                                                if(nextPtr >= pData && nextPtr < (pData + stepsize))
                                                {
                                                    DsAbsItem nitem;
                                                    memset(&nitem,0,sizeof(DsAbsItem));
                                                    nitem.ctrl  = absDataPtr->ctrl;
                                                    nitem.attr  = absDataPtr->attr | ATTR_RESEW;
                                                    nitem.ax    = nextPtr->ax;
                                                    nitem.ay    = nextPtr->ay;
                                                    nitem.ar    = absDataPtr->ar;
                                                    tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
                                                }
                                            }
                                            nextPtr--;
                                        }
                                    }
                                }
                                break;
                            }
                            else
                            {
                                break;
                            }
                        }
                        else
                        {
                            break;
                        }
                    }while(1);
                }
                else if(mode == MODE_THICKEN)//密针方式
                {
                    tgtdsdat.append((char*)absDataPtr, sizeof(DsAbsItem));

                    s16 nNum = 0;
                    if(lockNum == 0)//如果锁针次数为0时，第一针锁针次数就是锁针针数
                    {
                        nNum = lockNeedles+1;
                    }
                    else
                    {
                        nNum = lockNum+1;
                    }

                    do
                    {
                        if(j < stepsize)
                        {
                            DsAbsItem * nextPtr = absDataPtr;     // 下一个点
                            if (nextPtr->ctrl == DATA_SEWING || nextPtr->ctrl == DATA_SEWING_R || nextPtr->ctrl == DATA_SYNCSEW || nextPtr->ctrl == DATA_MIRROR_SEC)
                            {
                                DsAbsItem nitem;
                                memset(&nitem,0,sizeof(DsAbsItem));
                                DsAbsItem * prePtr = absDataPtr;

                                for (int s = 0; s < clockNeedles; s++)
                                {
                                    double dx = nextPtr->ax - prePtr->ax;
                                    double dy = nextPtr->ay - prePtr->ay;
                                    double len = sqrt(dx*dx + dy*dy);
                                    if (len <= 0)
                                    {
                                        prePtr = nextPtr;
                                        nextPtr++;
                                        clockNeedles++;
                                        if(nextPtr >= (pData + stepsize))
                                        {
                                            break;
                                        }
                                        continue;
                                    }

                                    if(prePtr >= pData && prePtr < (pData + stepsize))
                                    {
                                        double dLen = len / nNum;
                                        double axbase = prePtr->ax;
                                        double aybase = prePtr->ay;

                                        for (int k = 0; k < nNum; k++)
                                        {
                                            double nax = dx * dLen / len + axbase;
                                            double nay = dy * dLen / len + aybase;

                                            nitem.ctrl = absDataPtr->ctrl;
                                            nitem.attr = (absDataPtr->attr | ATTR_RESEW);
                                            nitem.ax = nax;
                                            nitem.ay = nay;
                                            nitem.ar = absDataPtr->ar;
                                            tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));

                                            axbase = nax;
                                            aybase = nay;
                                        }
                                        if(lockNum == 0)
                                        {
                                            nNum--;
                                        }
                                    }
                                    prePtr = nextPtr;
                                    nextPtr++;
                                }
                                clockNeedles = lockNeedles;
                                break;
                            }
                            else
                            {
                                break;
                            }
                        }
                        else
                        {
                            break;
                        }
                    }while(1);

                    for (int s = 0; s < lockNeedles; s++)//跳到不加锁针的那一针
                    {
                        absDataPtr++;
                        j++;
                    }
                }
                runflag = 1;
            }
        }
        else if (absDataPtr->ctrl == DATA_CUTTRD || absDataPtr->ctrl == DATA_CUTTER_SEC || absDataPtr->ctrl == DATA_SYNC_CUTTER)
        {
            runflag = 10;
        }
        else
        {
            runflag = 0;
        }

        DsAbsItem * prePtrstep = absDataPtr-1;     // 上一个点
        //加锁针
        if (absDataPtr->ctrl == DATA_END
                || absDataPtr->ctrl == DATA_NULL
                || j == stepsize - 1

                //当前点不为缝纫，上一个点为缝纫
                //适用于双头或四头绗缝机++++++
                || ((prePtrstep->ctrl == DATA_SEWING) &&
                (absDataPtr->ctrl != DATA_SEWING && absDataPtr->ctrl != DATA_SYNCSEW && absDataPtr->ctrl != DATA_MIRROR_SEC) && prePtrstep > pData)
                || ((prePtrstep->ctrl == DATA_SEWING_R) &&
                (absDataPtr->ctrl != DATA_SEWING_R && absDataPtr->ctrl != DATA_SYNCSEW && absDataPtr->ctrl != DATA_MIRROR_SEC) && prePtrstep > pData)
                || ((prePtrstep->ctrl == DATA_MIRROR_SEC) &&
                (absDataPtr->ctrl != DATA_SEWING && absDataPtr->ctrl != DATA_SEWING_R && absDataPtr->ctrl != DATA_SYNCSEW && absDataPtr->ctrl != DATA_MIRROR_SEC) && prePtrstep > pData)
                || ((prePtrstep->ctrl == DATA_SYNCSEW) &&
                (absDataPtr->ctrl != DATA_SEWING && absDataPtr->ctrl != DATA_SEWING_R && absDataPtr->ctrl != DATA_SYNCSEW && absDataPtr->ctrl != DATA_MIRROR_SEC) && prePtrstep > pData)
                //适用于双头或四头绗缝机++++++

                || absDataPtr->ctrl == DATA_CUTTRD
                || absDataPtr->ctrl == DATA_CUTTER_SEC
                || absDataPtr->ctrl == DATA_SYNC_CUTTER)
        {
            int m = 1;
            //结束前或剪线前加锁针
            DsAbsItem * prePtr = absDataPtr-1;     // 上一个点
            u8 ctl = prePtr->ctrl;

            //如果结束前为剪线则不加锁针了，因为剪线前已经加了锁针
            if((ctl == DATA_CUTTRD || ctl == DATA_CUTTER_SEC || ctl == DATA_SYNC_CUTTER) &&
                    (absDataPtr->ctrl == DATA_NULL || absDataPtr->ctrl == DATA_END))
            {
                tgtdsdat.append((char*)absDataPtr, sizeof(DsAbsItem));
                absDataPtr++;
                continue;
            }

            //如果第二机头剪线前为第一机头剪线，则不加锁针，因为第一机头剪线前已经加了锁针
            if(ctl == DATA_CUTTRD && absDataPtr->ctrl == DATA_CUTTER_SEC)
            {
                tgtdsdat.append((char*)absDataPtr, sizeof(DsAbsItem));
                absDataPtr++;
                continue;
            }

            //如果同步剪线前为第一机头剪线或第二机头剪线，则不加锁针，因为之前已经加了锁针
            if(ctl == DATA_SYNC_CUTTER && (absDataPtr->ctrl == DATA_CUTTRD || absDataPtr->ctrl == DATA_CUTTER_SEC))
            {
                tgtdsdat.append((char*)absDataPtr, sizeof(DsAbsItem));
                absDataPtr++;
                continue;
            }

            //为缝纫或双机头同步缝纫或双机头镜像缝纫（双头组合机型是有后两种）
            while(ctl != DATA_SEWING && ctl != DATA_SEWING_R && ctl != DATA_SYNCSEW && ctl != DATA_MIRROR_SEC && ctl != DATA_DRAWING)
            {
                prePtr--;
                if(prePtr < pData)//越界起始地址       2025.4.22 ls
                {
                    return -1;
                }
                m++;
                ctl = prePtr->ctrl;
            }

            // 添加锁针
            int nst = 1;
            int addIdx = m+1;

            if(mode == MODE_LOCK)//锁针方式
            {
                do
                {
                    if(j-m-nst > 0)
                    {
                        DsAbsItem * lockPtr = prePtr;     // 要加锁针的点
                        if (lockPtr->ctrl == DATA_SEWING || lockPtr->ctrl == DATA_SEWING_R || lockPtr->ctrl == DATA_SYNCSEW || lockPtr->ctrl == DATA_MIRROR_SEC)
                        {
                            for (int k = 0; k < lockNum; k++)
                            {
                                if(k%2 == 0)
                                {
                                    for (int s = lockNeedles; s > 0; s--)
                                    {
                                        lockPtr--;
                                        if(lockPtr >= pData && lockPtr < (pData + stepsize))//越界起始地址       2025.4.22 ls
                                        {
                                            DsAbsItem nitem;
                                            memset(&nitem,0,sizeof(DsAbsItem));
                                            nitem.ctrl  = prePtr->ctrl;
                                            nitem.attr  = (absDataPtr->attr | ATTR_RESEW);
                                            nitem.ax    = lockPtr->ax;
                                            nitem.ay    = lockPtr->ay;
                                            nitem.ar    = prePtr->ar;
//                                            if((int)(tgtdsdat.size()-addIdx*sizeof(DsAbsItem)) < tgtdsdat.size())
//                                            {
//                                                tgtdsdat.insert((tgtdsdat.size()-addIdx*sizeof(DsAbsItem)),(char*)(&nitem), sizeof(DsAbsItem));
//                                                addIdx++;
//                                            }
                                            tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
                                        }
                                    }
                                }

                                if(k > 0 && k%2 != 0)
                                {
                                    for (int s = 0; s < lockNeedles; s++)
                                    {
                                        lockPtr++;
                                        if(lockPtr >= pData && lockPtr < (pData + stepsize))
                                        {
                                            DsAbsItem nitem;
                                            memset(&nitem,0,sizeof(DsAbsItem));
                                            nitem.ctrl  = prePtr->ctrl;
                                            nitem.attr  = (absDataPtr->attr | ATTR_RESEW);
                                            nitem.ax    = lockPtr->ax;
                                            nitem.ay    = lockPtr->ay;
                                            nitem.ar    = prePtr->ar;
//                                            if((int)(tgtdsdat.size()-addIdx*sizeof(DsAbsItem)) < tgtdsdat.size())
//                                            {
//                                                tgtdsdat.insert((tgtdsdat.size()-addIdx*sizeof(DsAbsItem)),(char*)(&nitem), sizeof(DsAbsItem));
//                                                addIdx++;
//                                            }
                                            tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
                                        }
                                    }
                                }
                            }
                            break;
                        }
                        else
                        {
                            break;
                        }
                    }
                    else
                    {
                        break;
                    }
                }while(1);
            }
            else if(mode == MODE_THICKEN)//密针方式
            {
                addIdx += 1;
                nst = lockNeedles;

                DsAbsItem * ptr = prePtr-lockNeedles;     // 加锁针点
                while(ptr->ctrl != DATA_SEWING && ptr->ctrl != DATA_SEWING_R && ptr->ctrl != DATA_SYNCSEW && ptr->ctrl != DATA_MIRROR_SEC)
                {
                    ptr++;
                    lockNeedles--;
                    addIdx--;
                    if(ptr >= (pData + stepsize) || lockNeedles <= 0)
                    {
                        break;
                    }
                }

                //去除要加密针的已添加的针步
                tgtdsdat.remove(tgtdsdat.size() - lockNeedles*sizeof(DsAbsItem),lockNeedles*sizeof(DsAbsItem));

                s16 nNum = 0;
                if(lockNum == 0)//如果锁针次数为0时，第一针锁针次数就是锁针针数
                {
                    nNum = lockNeedles+1;
                }
                else
                {
                    nNum = lockNum+1;
                }

                do
                {
                    if(j-m-nst > 0)
                    {
                        DsAbsItem * lockPtr = prePtr-lockNeedles;     // 加锁针点
                        addIdx -= lockNeedles;
                        if(lockPtr < pData)//越界起始地址
                        {
                            return -1;
                        }
                        //为缝纫或双机头同步缝纫或双机头镜像缝纫（双头组合机型是有后两种）
                        if (lockPtr->ctrl == DATA_SEWING || lockPtr->ctrl == DATA_SEWING_R || lockPtr->ctrl == DATA_SYNCSEW || lockPtr->ctrl == DATA_MIRROR_SEC)
                        {
                            for (int s = 0; s < lockNeedles; s++)
                            {
                                DsAbsItem * nextPtr = lockPtr+1;
                                if(nextPtr > (pData + (stepsize-1)))
                                {
                                    return -1;
                                }
                                double dx = nextPtr->ax - lockPtr->ax;
                                double dy = nextPtr->ay - lockPtr->ay;
                                double len = sqrt(dx*dx + dy*dy);
                                if (len <= 0)
                                {
                                    if(lockNum == 0)
                                    {
                                        nNum--;
                                    }

                                    lockPtr++;
                                    addIdx++;
                                    if(lockPtr > (pData + (stepsize-1)))
                                    {
                                        return -1;
                                    }
                                    if (lockPtr->ctrl != DATA_SEWING && lockPtr->ctrl != DATA_SEWING_R && lockPtr->ctrl != DATA_SYNCSEW && lockPtr->ctrl != DATA_MIRROR_SEC)
                                    {
                                        break;
                                    }
                                    continue;
                                }
                                double dLen = len / nNum;
                                double axbase = lockPtr->ax;
                                double aybase = lockPtr->ay;

                                for (int k = 0; k < nNum; k++)
                                {
                                    double nax = dx * dLen / len + axbase;
                                    double nay = dy * dLen / len + aybase;
                                    DsAbsItem nitem;
                                    memset(&nitem,0,sizeof(DsAbsItem));
                                    nitem.ctrl = prePtr->ctrl;
                                    nitem.attr = absDataPtr->attr | ATTR_RESEW;
                                    nitem.ax = nax;
                                    nitem.ay = nay;
                                    nitem.ar = prePtr->ar;
                                    tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));

                                    axbase = nax;
                                    aybase = nay;
                                }
                                if(lockNum == 0)
                                {
                                    nNum--;
                                }
                                lockPtr++;
                                if (lockPtr->ctrl != DATA_SEWING && lockPtr->ctrl != DATA_SEWING_R && lockPtr->ctrl != DATA_SYNCSEW && lockPtr->ctrl != DATA_MIRROR_SEC)
                                {
                                    break;
                                }
                            }
                            break;
                        }
                        else
                        {
                            lockPtr++;
                            lockNeedles -= 1;
                            if(lockNeedles <= 0 || lockPtr >= (pData + stepsize))
                            {
                                break;
                            }
                        }
                    }
                    else
                    {
                        break;
                    }
                }while(1);
            }
        }

        tgtdsdat.append((char*)absDataPtr, sizeof(DsAbsItem));

        absDataPtr++;
    }

    m_embAbsData.clear();
    m_embAbsData = tgtdsdat;

    m_editedflag = 1;
    return 0;
}

//锁针加固方式
///
/// \brief EmbData::lockReinforce
/// \param needles  针数
/// \param num  次数
/// \param absDataPtr
/// \param stepSize
/// \return
///
QByteArray EmbData::lockReinforce(u8 needles, u8 num, DsAbsItem *absDataPtr, int stepSize)
{
    QByteArray result;
    for(int i = 0; i < stepSize-1; i++)
    {
        bool isNeedOriginPoint = true;
        do
        {
            if(needles == 0 || num == 0)
            {
                break;
            }

            //加固条件，此针为缝纫并且 第一针或者上一针不是缝纫
            if(absDataPtr->ctrl == DATA_SEWING)
            {
                //第一针
                if(i==0)
                {
                    if(num%2 == 0)//偶数次  从起始点开始
                    {
                        evenNumberAddLock(result, absDataPtr, needles, num);
                    }
                    else //奇数次
                    {
                        oddNumberAddLock(result, absDataPtr, needles, num);
                    }

                }
                //上一针不是缝纫针步 线断起始加固
                else if((absDataPtr-1)->ctrl != DATA_SEWING)
                {
                    if(num%2 == 0)//偶数次  从起始点开始
                    {
                        evenNumberAddLock(result, absDataPtr - 1, needles, num);
                        addResew(result, absDataPtr - 1, DATA_SEWING);
                        isNeedOriginPoint = false;
                    }
                    else //奇数次  从中间点点开始
                    {
                        //把上一针删了
                        result.remove(result.size() - sizeof(DsAbsItem), sizeof(DsAbsItem));
                        oddNumberAddLock(result, absDataPtr - 1, needles, num);
                        addResew(result, absDataPtr - 1, DATA_SEWING);
                        isNeedOriginPoint = false;
                    }
                }
                //下一针不为缝纫  结尾加固
                else if(i < stepSize-1 && (absDataPtr+1)->ctrl != DATA_SEWING)
                {

                }
                else
                {
                    break;
                }
            }
            break;
        }
        while(0);

        if(isNeedOriginPoint)
            addResew(result, absDataPtr, absDataPtr->ctrl, false);
        absDataPtr++;
    }
    return result;
}

//密针加固方式
QByteArray EmbData::thickenReinforce(u8 needles, u8 num, DsAbsItem *absDataPtr, int stepSize)
{
    if(needles == 0 && num == 0){}//为了去掉编译警告
    QByteArray result;
    for(int i = 0; i < stepSize; i++)
    {

        absDataPtr++;
    }

    return result;
}

//加回针或者锁针
void EmbData::addResew(QByteArray &data, DsAbsItem *ptr, u8 ctrl ,bool resewFlag)
{
    DsAbsItem item;
    memset(&item,0,sizeof(DsAbsItem));
    item.ctrl  = ctrl;
    item.ax    = ptr->ax;
    item.ay    = ptr->ay;
    item.ar    = ptr->ar;
    if(resewFlag)
        item.attr  = ptr->attr | ATTR_RESEW;
    else
        item.attr  = ptr->attr;
    data.append((char*)(&item), sizeof(DsAbsItem));
}

void EmbData::evenNumberAddLock(QByteArray &data, DsAbsItem *absDataPtr,int lockNeedles, int num)
{
    if(num < 0 || num % 2 !=0)
    {
        return;
    }
    QList<DsAbsItem *> listPoint;
    //添加原点
    DsAbsItem * dataPtr = absDataPtr;
    if(DATA_SEWING == absDataPtr->ctrl) //第一针
    {
        addResew(data, dataPtr, dataPtr->ctrl);
    }
    //记录要添加的点
    for(int j = 0; j < lockNeedles; j++)
    {
        dataPtr++;
        listPoint.append(dataPtr);
    }

    //循环添加
    for(int count = num/2; count > 0; count--)
    {
        //正向添加
        for(DsAbsItem * ptr : listPoint)
        {
            addResew(data, ptr, DATA_SEWING);
        }
        //反向加回
        for(int k = listPoint.size(); k > 0; k--)
        {
            //端点不加 因为正向的时候加过了
            if(k == listPoint.size())
                continue;
            DsAbsItem * ptr = listPoint.at(k-1);
            addResew(data, ptr, DATA_SEWING);
        }

        if(count > 1)
            addResew(data, absDataPtr, DATA_SEWING);
    }
}

void EmbData::oddNumberAddLock(QByteArray &data, DsAbsItem *absDataPtr, int lockNeedles, int num)
{
    QList<DsAbsItem *> listPoint;
    DsAbsItem * dataPtr = absDataPtr;

    if(absDataPtr->ctrl != DATA_SEWING)
    {
        dataPtr --;
    }

    //记录要添加的点
    for(int j = 0; j < lockNeedles; j++)
    {
        dataPtr++;
        listPoint.append(dataPtr);
    }

    if(absDataPtr->ctrl != DATA_SEWING)
    {
        addResew(data, dataPtr++, absDataPtr->ctrl, true);
        absDataPtr--;
    }
    //反向加回
    for(int k = listPoint.size(); k > 0; k--)
    {
        DsAbsItem * ptr = listPoint.at(k-1);
        addResew(data, ptr, DATA_SEWING, true);
    }

    //此时可以当作偶数处理
    int tempNum = num - 1;
    evenNumberAddLock(data, absDataPtr, lockNeedles, tempNum);
}

//角度修正
int EmbData::angleCorrection(s16 oft)
{
    if (oft == 0)
    {
        return 0;
    }

    double dx, dy, dr;
    double ax, ay, ar;
    double bdx, bdy;
    bdx = bdy = 0;

    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    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_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步

    DsAbsItem * secondPtr = NULL;//第二个点坐标指针

    double addx,addy;
    addx = addy = 0;
    double s = 0;

    int firstY = 0;//花样第一点坐标

    // 数据区
    for (int j = 0; j < stepsize; j++)
    {
        if (j == 0)//第一针
        {
            dx = absDataPtr->ax;
            dy = absDataPtr->ay;
            dr = absDataPtr->ar;
            firstY = absDataPtr->ay;
        }
        else
        {
            dx = absDataPtr->ax - ax;
            dy = absDataPtr->ay - ay;
            dr = absDataPtr->ar - ar;
        }

        if (j == 1)//第二针
        {
            secondPtr = absDataPtr;
        }

        //判断夹角是否大于60度
        if(dr >= ANGLECORR || dr <= -ANGLECORR || j == stepsize - 1)
        {
            s = sqrt(bdx*bdx + bdy*bdy);
            if(s == 0)
            {
                addx = 0;
                addy = 0;
            }
            else
            {
                addx = bdx*oft/s;
                addy = bdy*oft/s;
                m_endPosX = addx;
                m_endPosY = addy;
            }

            absDataPtr--;
            if(absDataPtr->ctrl == DATA_SEWING)
            {
                absDataPtr->ax += addx;
                absDataPtr->ay += addy;
            }
            absDataPtr++;
        }

        ax = absDataPtr->ax;
        ay = absDataPtr->ay;
        ar = absDataPtr->ar;

        bdx = dx;
        bdy = dy;

        absDataPtr++;
    }

    DsAbsItem *datItem = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead)+sizeof(DsAbsItem)*(stepsize-1));

    DsAbsItem insertItem;
    memcpy(&insertItem,datItem,sizeof(DsAbsItem));

    int mdy = secondPtr->ay - firstY;
    double modY = datItem->ay + mdy;

    insertItem.ctrl = DATA_SEWING;
    double tar = atan2((modY-datItem->ay),(secondPtr->ax-datItem->ax));
    insertItem.ar = (tar * 10000+0.5*(tar>0?1:-1));
    insertItem.ax = secondPtr->ax;
    insertItem.ay = modY;
    m_embAbsData.insert(sizeof(DataDs16FileHead)+sizeof(DsAbsItem)*(stepsize-1),(char*)(&insertItem),sizeof(DsAbsItem));//插入回针
    m_embAbsData.remove(sizeof(DataDs16FileHead),sizeof(DsAbsItem));//去掉第一针

    //重新计算角度
    size = m_embAbsData.size();
    datasize = size - sizeof(DataDs16FileHead);
    stepsize = datasize/sizeof(DsAbsItem);
    DsAbsItem * ptr = (DsAbsItem *)(m_embAbsData.data()+sizeof(DataDs16FileHead));
    double prex = 0;
    double prey = 0;
    double curx = 0;
    double cury = 0;
    double ddx = 0;
    double ddy = 0;
    for(int i = 0; i < stepsize; i++)
    {
        curx = ptr->ax;
        cury = ptr->ay;
        ddx = curx - prex;
        ddy = cury - prey;
        double tar = atan2(ddy,ddx);
        ptr->ar = (tar * 10000+0.5*(tar>0?1:-1));
        prex = curx;
        prey = cury;
        ptr++;
    }

    return 1;
}

int EmbData::angleCorrectionXY(s32 px, s32 nx, s32 py, s32 ny)
{
    if(px == 0 && nx == 0 && py == 0 && ny == 0)
    {
        return -1;
    }
    double dx, dy, dr;
    double ax, ay, ar;

    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    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;
    }

    QByteArray ary;
    ary.clear();
    DataDs16FileHead *head = (DataDs16FileHead *)m_embAbsData.data();
    ary.append((char*)head,sizeof(DataDs16FileHead));

    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步

    //记录第一个点的绝对坐标值
    DsAbsItem firstAbsDataPtr;
    memcpy(&firstAbsDataPtr,(char*)pData,sizeof(DsAbsItem));

    //记录第二个点的绝对坐标值
    DsAbsItem secAbsDataPtr;

    // 过滤掉坐标值及属性相同的针步，只留一个，避免空针（不拟合针步时空针会使补偿异常）
    DsAbsItem * lstAbsDataPtr = absDataPtr;
    for (int j = 0; j < stepsize; j++)
    {
        if(j == 0)
        {
            //注释掉这行代码，为了去掉第一针，为了结束时加补偿，再缝下一个图元时能直接回到第二个点，而不是第一个点，只有缝制第一个图元时会少一针，其他地方正常，没有影响
            //ary.append((char*)absDataPtr,sizeof(DsAbsItem));
        }
        else
        {
            if(lstAbsDataPtr->ax == absDataPtr->ax && lstAbsDataPtr->ay == absDataPtr->ay &&
               lstAbsDataPtr->ctrl == absDataPtr->ctrl && lstAbsDataPtr->attr == absDataPtr->attr &&
                lstAbsDataPtr->action == absDataPtr->action)
            {
            }
            else
            {
                ary.append((char*)absDataPtr,sizeof(DsAbsItem));
            }
        }

        if(j == 1)
        {
            secAbsDataPtr.ax = absDataPtr->ax;
            secAbsDataPtr.ay = absDataPtr->ay;
        }
        lstAbsDataPtr = absDataPtr;
        absDataPtr++;
    }

    m_embAbsData.clear();
    m_embAbsData.append(ary);
    size = m_embAbsData.size();
    datasize = size - sizeof(DataDs16FileHead);
    stepsize = datasize/sizeof(DsAbsItem);
    pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    absDataPtr = pData;  //中间数据针步

    ary.clear();
    head = (DataDs16FileHead *)(m_embAbsData.data());
    ary.append((char*)head,sizeof(DataDs16FileHead));

    double addx,addy;
    addx = addy = 0;

    int maxX = S32_MIN;
    int maxY = S32_MIN;
    int minY = S32_MAX;
    int minX = S32_MAX;

    // 数据区
    for (int j = 0; j < stepsize; j++)
    {
        if (j == 0)//第一针
        {
            dx = absDataPtr->ax;
            dy = absDataPtr->ay;
            dr = absDataPtr->ar;
        }
        else
        {
            dx = absDataPtr->ax - ax;
            dy = absDataPtr->ay - ay;
            dr = absDataPtr->ar - ar;
        }

        if (absDataPtr->ax > maxX)
        {
            maxX = absDataPtr->ax;
        }
        if (absDataPtr->ax < minX)
        {
            minX = absDataPtr->ax;
        }
        if (absDataPtr->ay > maxY)
        {
            maxY = absDataPtr->ay;
        }
        if (absDataPtr->ay < minY)
        {
            minY = absDataPtr->ay;
        }

        //判断夹角是否大于60度或小于-60度
        if(dr >= ANGLECORR || dr <= -ANGLECORR)
        {
            if(dx > 0)
            {
                addx = 0 - nx;
            }
            else if(dx == 0)
            {
                DsAbsItem * prePtr = absDataPtr-1;
                double prex = prePtr->ax;
                while(prex == absDataPtr->ax)
                {
                    prePtr--;
                    prex = prePtr->ax;
                    if(prePtr == pData)
                    {
                        break;
                    }
                }
                double cx = prex - absDataPtr->ax;
                if(cx < 0)
                {
                    addx = px;
                }
                else
                {
                    addx = 0 - nx;
                }
            }
            else
            {
                addx = px;
            }

            if(dy > 0)
            {
                addy = py;
            }
            else if(dy == 0)
            {
                DsAbsItem * prePtr = absDataPtr-1;
                double prey = prePtr->ay;
                while(prey == absDataPtr->ay)
                {
                    prePtr--;
                    prey = prePtr->ay;
                    if(prePtr == pData)
                    {
                        break;
                    }
                }
                double cy = prey - absDataPtr->ay;
                if(cy < 0)
                {
                    addy = py;
                }
                else
                {
                    addy = 0 - ny;
                }
            }
            else
            {
                addy = 0 - ny;
            }

            absDataPtr--;
//            int ccx = absDataPtr->ax;
//            int ccy = absDataPtr->ay;
//            DsAbsItem * temp = absDataPtr - 1;
//            ccx = ccx - temp->ax;
//            ccy = ccy - temp->ay;
//            addx += ccx;
//            addy += ccy;

            if(absDataPtr->ctrl == DATA_SEWING)
            {
//                absDataPtr->ax += addx;
//                absDataPtr->ay += addy;

                DsAbsItem item;
                memcpy((char*)&item,(char*)absDataPtr,sizeof(DsAbsItem));

                double xyLen = sqrt((addx/100.0*addx/100.0)*10000.0+ (addy/100.0*addy/100.0)*10000.0);
                if(xyLen > 200)//大于2毫米
                {
                    double dx{0},dy{0};
                    double cdx{0},cdy{0};

                    //分割针步
                    double splitVal = 200.0;//分割针步为200

                    s32 stepNum = xyLen / splitVal;//拆分几步
                    double lastStep = (double)((int)xyLen % (int)splitVal);
                    double addStep = lastStep / stepNum;

                    for(int m = 0; m < stepNum; m++)
                    {
                        double stepX = 0;
                        double stepY = 0;

                        stepX = addx * splitVal / xyLen + addx * addStep / xyLen;
                        stepY = addy * splitVal / xyLen + addy * addStep / xyLen;

                        dx = qRound(stepX);//四舍五入
                        dy = qRound(stepY);

                        if (m == stepNum-1)
                        {
                            //最后一针,消除累计误差
                            dx = addx - cdx;
                            dy = addy - cdy;
                        }

                        cdx += dx;
                        cdy += dy;

//                        item.ax = temp->ax + cdx;
//                        item.ay = temp->ay + cdy;
                        item.ax = absDataPtr->ax + cdx;
                        item.ay = absDataPtr->ay + cdy;

                        int rsize = ary.size();
                        DsAbsItem tmp;
                        memcpy(&tmp,ary.data()+rsize-sizeof(DsAbsItem),sizeof(DsAbsItem));

//                        if(m == 0)
//                        {
//                            ary.remove(rsize-sizeof(DsAbsItem),sizeof(DsAbsItem));
//                        }
                        ary.append((char*)&item,sizeof(DsAbsItem));
                    }
                }
                else
                {
                    item.ax = absDataPtr->ax + addx;
                    item.ay = absDataPtr->ay + addy;

//                    int rsize = ary.size();
//                    ary.remove(rsize-sizeof(DsAbsItem),sizeof(DsAbsItem));
                    ary.append((char*)&item,sizeof(DsAbsItem));
                }
            }
            absDataPtr++;
        }

        ax = absDataPtr->ax;
        ay = absDataPtr->ay;
        ar = absDataPtr->ar;

        ary.append((char*)absDataPtr,sizeof(DsAbsItem));
        absDataPtr++;
    }

    DsAbsItem *tempPtr = (DsAbsItem *)(ary.data() + ary.size() - sizeof(DsAbsItem));
    //让结束后再回到起点位置上，避免越缝越偏
    DsAbsItem addPtr;
    memcpy(&addPtr,&firstAbsDataPtr,sizeof(DsAbsItem));
    addPtr.ax = tempPtr->ax + (secAbsDataPtr.ax - firstAbsDataPtr.ax);
    addPtr.ay = tempPtr->ay + (secAbsDataPtr.ay - firstAbsDataPtr.ay);

    pData = (DsAbsItem *)(ary.data() + sizeof(DataDs16FileHead));

    int idx = 0;
    while(tempPtr->ctrl != DATA_SEWING)
    {
        tempPtr--;
        if(tempPtr == pData)
        {
            return -1;
        }
        idx++;
    }

    ary.insert(ary.size() - sizeof(DsAbsItem)*idx, (char*)&addPtr, sizeof(DsAbsItem));

    m_embAbsData.clear();
    m_embAbsData.append(ary);

    //重新计算角度
    size = m_embAbsData.size();
    datasize = size - sizeof(DataDs16FileHead);
    stepsize = datasize/sizeof(DsAbsItem);
    DsAbsItem * ptr = (DsAbsItem *)(m_embAbsData.data()+sizeof(DataDs16FileHead));
    double prex = 0;
    double prey = 0;
    double curx = 0;
    double cury = 0;
    double ddx = 0;
    double ddy = 0;
    for(int i = 0; i < stepsize; i++)
    {
        curx = ptr->ax;
        cury = ptr->ay;
        ddx = curx - prex;
        ddy = cury - prey;
        double tar = atan2(ddy,ddx);
        ptr->ar = (tar * 10000+0.5*(tar>0?1:-1));
        prex = curx;
        prey = cury;
        ptr++;
    }

    return 0;
}

//按固定针步重新拟合（用户可设置的参数，暂未用到）
void EmbData::reFitByStep(s32 stepLen)
{
    QList<LineItem> lineList;
    lineList.clear();

    int stepLength = stepLen;//参数(300-800 单位0.01mm)

    LineItem item;
    item.absItemList.clear();

    int dr = 0;
    unsigned char ctrl;
    double prer = 0;

    double ax, ay, ar;
    ax = ay = ar = 0;

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

    //添加线段集合（夹角大于某个值时为新的一段线段）
    int datasize = m_embAbsData.size() - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        return;
    }
    int stepsize = datasize/sizeof(DsAbsItem);
    DsAbsItem * dataBeg = (DsAbsItem *)(m_embAbsData.data()+sizeof(DataDs16FileHead));
    prer = dataBeg->ar;
    for (int i = 0; i < stepsize; i++)
    {
        ctrl = dataBeg->ctrl;
        dr = dataBeg->ar - prer;

        unsigned char nctrl,bctrl;
        if(i == stepsize-1)
        {
            nctrl = ctrl;
        }
        else
        {
            dataBeg++;
            nctrl = dataBeg->ctrl;//下一针步属性
            dataBeg--;
        }

        if(i == 0)
        {
            bctrl = ctrl;
        }
        else
        {
            dataBeg--;
            bctrl = dataBeg->ctrl;//上一针步属性
            dataBeg++;
        }

        if(ctrl != DATA_SEWING)
        {
            item.absItemList.append(*dataBeg);
        }

        //上一针非缝纫属性且当前针为缝纫属性
        if(bctrl != DATA_SEWING && ctrl == DATA_SEWING)
        {
            lineList.append(item);
            item.absItemList.clear();
            item.absItemList.append(*dataBeg);
        }
        //下一针非缝纫针步与当前针为缝纫针步
        else if(nctrl != DATA_SEWING && ctrl == DATA_SEWING)
        {
            lineList.append(item);
            item.absItemList.clear();
            item.absItemList.append(*dataBeg);
        }
        //上一针为缝纫针步与当前针非缝纫针步
        else if(bctrl == DATA_SEWING && ctrl != DATA_SEWING)
        {
            lineList.append(item);
            item.absItemList.clear();
            item.absItemList.append(*dataBeg);
        }
        //下一针为缝纫针步与当前针非缝纫针步
        else if(nctrl == DATA_SEWING && ctrl != DATA_SEWING)
        {
            lineList.append(item);
            item.absItemList.clear();
            item.absItemList.append(*dataBeg);
        }
        else if(ctrl == DATA_SEWING)
        {
            double angle = dr / 10000.0 * (180.0 / PI);
            if(angle > 30 || angle < -30)//新的一条线段(30度为分界)
            {
                lineList.append(item);
                item.absItemList.clear();
                item.absItemList.append(*dataBeg);
            }
            else
            {
                item.absItemList.append(*dataBeg);
            }
        }
        prer = dataBeg->ar;
        dataBeg++;
    }

    //开始重置针步（绝对坐标的线段集合）
    QByteArray nabsData;
    nabsData.clear();
    double cx,cy,cr;
    cx = cy = cr = 0;
    int lSize = lineList.size();
    for(int j = 0; j < lSize; j++)
    {
        int pSize = lineList[j].absItemList.size();
        for(int m = 0; m < pSize; m++)
        {
            memset(&absItem,0,sizeof(DsAbsItem));
            absItem = lineList[j].absItemList[m];

            ctrl = absItem.ctrl;
            //absItem.ax = absItem.ax - minX;
            //absItem.ay = absItem.ay - minY;
            ax = absItem.ax;
            ay = absItem.ay;
            ar = absItem.ar;

            if(ctrl != DATA_SEWING)
            {
                nabsData.append((char*)&absItem,sizeof(DsAbsItem));
                continue;
            }
            if(m == 0)
            {
                cx = ax;
                cy = ay;
                nabsData.append((char*)&absItem,sizeof(DsAbsItem));
            }
            if(m == pSize - 1 && pSize > 1)
            {
                //最后一步如果超出长度就均分
                int pos = nabsData.size()-sizeof(DsAbsItem);
                DsAbsItem * litem = (DsAbsItem *)((nabsData.data()+pos));

                double curX = absItem.ax;
                double curY = absItem.ay;

                double preX = litem->ax;
                double preY = litem->ay;

                double ldis = sqrt(((curX-preX)/100.0*(curX-preX)/100.0)*10000.0+((curY-preY)/100.0*(curY-preY)/100.0)*10000.0);
                if(ldis > stepLength)
                {
                    DsAbsItem addItem;
                    memset(&addItem,0,sizeof(DsAbsItem));
                    addItem = absItem;

                    if(litem->ay == absItem.ay)//y相同
                    {
                        addItem.ay = absItem.ay;
                        addItem.ax = (absItem.ax+litem->ax)/2;

                        nabsData.append((char*)&addItem,sizeof(DsAbsItem));
                        nabsData.append((char*)&absItem,sizeof(DsAbsItem));
                        break;
                    }
                    else if(litem->ax == absItem.ax)//x相同
                    {
                        addItem.ax = absItem.ax;
                        addItem.ay = (absItem.ay+litem->ay)/2;

                        nabsData.append((char*)&addItem,sizeof(DsAbsItem));
                        nabsData.append((char*)&absItem,sizeof(DsAbsItem));
                        break;
                    }
                    else
                    {
                        double k = ((double)(absItem.ay-litem->ay))/((double)(absItem.ax-litem->ay));
                        double cdis = ldis / 2;
                        double r = atan(k);
                        double x = cdis * cos(r);
                        double y = cdis * sin(r);

                        addItem.ax = litem->ax + x;
                        addItem.ay = litem->ay + y;
                        nabsData.append((char*)&addItem,sizeof(DsAbsItem));

                        nabsData.append((char*)&absItem,sizeof(DsAbsItem));
                        break;
                    }
                }
                else
                {
                    nabsData.append((char*)&absItem,sizeof(DsAbsItem));
                    break;
                }
            }
            double dis = sqrt(((ax-cx)/100.0*(ax-cx)/100.0)*10000.0+((ay-cy)/100.0*(ay-cy)/100.0)*10000.0);
            while(dis > stepLength)
            {
                QPoint firstPoint(0,0);//直线第一个点
                if((m-1) >= 0)
                {
                    //                    firstPoint.setX(lineList[j].absItemList[m-1].ax-minX);
                    //                    firstPoint.setY(lineList[j].absItemList[m-1].ay-minY);
                    firstPoint.setX(lineList[j].absItemList[m-1].ax);
                    firstPoint.setY(lineList[j].absItemList[m-1].ay);
                }

                QPoint secondPoint;//直线第二个点
                secondPoint.setX(ax);
                secondPoint.setY(ay);

                QPoint circlePoint;//圆心
                circlePoint.setX(cx);
                circlePoint.setY(cy);

                QPoint p;
                if(secondPoint.x()-firstPoint.x() == 0)
                {
                    p.setX(secondPoint.x());
                    //int y = (secondPoint.y()/stepLength)*stepLength;
                    //int y = (secondPoint.y()+firstPoint.y())/2;
                    //取出上一点的坐标
                    int pos = nabsData.size()-sizeof(DsAbsItem);
                    DsAbsItem * litem = (DsAbsItem *)((nabsData.data()+pos));
                    int y = 0;
                    if(litem->ay >= secondPoint.y())
                    {
                        y = litem->ay - stepLength;
                    }
                    else
                    {
                        y = litem->ay + stepLength;
                    }

                    p.setY(y);

                    cx = p.x();
                    cy = p.y();

                    if(cx < 0 || cy < 0)
                    {
                        //qDebug()<<j<<m<<cx<<cy;
                    }

                    absItem.ax = cx;
                    absItem.ay = cy;
                    nabsData.append((char*)&absItem,sizeof(DsAbsItem));

                    dis = sqrt(((ax-cx)/100.0*(ax-cx)/100.0)*10000.0+((ay-cy)/100.0*(ay-cy)/100.0)*10000.0);
                }
                else
                {
                    //(x - cx )^2 + (y - cy)^2 = r^2
                    //y = kx +b

                    // 求得直线方程
                    double k = ((double)(secondPoint.y()-firstPoint.y()))/(secondPoint.x()-firstPoint.x());
                    double b = firstPoint.y()-k*firstPoint.x();

                    // 列方程
                    //(1 + k^2)*x^2 - x*(2*cx -2*k*(b -cy) ) + cx*cx + ( b - cy)*(b - cy) - r*r = 0

                    int x1,y1,x2,y2;
                    double c = (circlePoint.x()/100.0)*(circlePoint.x()/100.0)*10000.0+((b-circlePoint.y())/100.0)*((b-circlePoint.y())/100.0)*10000.0-stepLength*stepLength;
                    double a = (1+k*k);
                    double b1 = 2*circlePoint.x()-2*k*(b-circlePoint.y());
                    // 得到下面的简化方程
                    // a*x^2 - b1*x + c = 0;

                    double sval = (b1/100.0)*(b1/100.0)*10000.0-4*a*c;
                    if(sval < 0)
                    {
                        qDebug()<<j<<sval;
                        //sval = abs(sval);
                    }
                    double tmp = sqrt(sval);
                    x1 = qRound((b1+tmp)/(2*a));
                    y1 = qRound(k*x1+b);
                    x2 = qRound((b1-tmp)/(2*a));
                    y2 = qRound(k*x2+b);

                    //判断点是否在第一个和第二个点之间
                    QPoint p1(x1,y1);
                    QPoint p2(x2,y2);

                    QRect rect(firstPoint,secondPoint);
                    bool bl1 = false;
                    if(rect.contains(p1))
                    {
                        bl1 = true;
                    }

                    bool bl2 = false;
                    if(rect.contains(p2))
                    {
                        bl2 = true;
                    }

                    // 判断求出的点是否在圆上
                    int res = qRound(sqrt((x1-cx)*(x1-cx)+(y1-cy)*(y1-cy)));
                    bool bl3 = true;//这里让此条件一直成立
                    if(res <= (stepLength+10) &&
                            res >= (stepLength-10))
                    {
                        bl3 = true;
                    }

                    if(bl3)
                    {
                        if(bl1 == true && bl2 == true)
                        {
                            double dis1 = sqrt(((ax-x1)/100.0*(ax-x1)/100.0)*10000.0+((ay-y1)/100.0*(ay-y1)/100.0)*10000.0);
                            double dis2 = sqrt(((ax-x2)/100.0*(ax-x2)/100.0)*10000.0+((ay-y2)/100.0*(ay-y2)/100.0)*10000.0);
                            if(dis1 > dis2)
                            {
                                cx = x2;
                                cy = y2;
                            }
                            else
                            {
                                cx = x1;
                                cy = y1;
                            }

                            absItem.ax = cx;
                            absItem.ay = cy;
                            nabsData.append((char*)&absItem,sizeof(DsAbsItem));

                            dis = sqrt(((ax-cx)/100.0*(ax-cx)/100.0)*10000.0+((ay-cy)/100.0*(ay-cy)/100.0)*10000.0);
                        }
                        else
                        {
                            if(bl1)
                            {
                                p.setX(x1);
                                p.setY(y1);
                            }
                            else if(bl2)
                            {
                                p.setX(x2);
                                p.setY(y2);
                            }
                            else
                            {
                                qDebug()<<"bl1&bl2=false";
                                break;
                            }

                            cx = p.x();
                            cy = p.y();

                            if(cx < 0 || cy < 0)
                            {
                                //qDebug()<<j<<m<<cx<<cy;
                            }

                            absItem.ax = cx;
                            absItem.ay = cy;
                            nabsData.append((char*)&absItem,sizeof(DsAbsItem));

                            dis = sqrt(((ax-cx)/100.0*(ax-cx)/100.0)*10000.0+((ay-cy)/100.0*(ay-cy)/100.0)*10000.0);
                        }
                    }
                    else
                    {
                        qDebug()<<"bl3=false";
                        break;
                    }
                }
            }
        }
    }

    //修改绝对坐标数据
    stepsize = nabsData.size() / sizeof(DsAbsItem);

    m_pEmbDs16Head->dataSize = stepsize*sizeof(DsAbsItem);    // 数据字节数
    m_pEmbDs16Head->itemNums = stepsize;                    // 数据项个数
    m_pEmbDs16Head->dataChecksum = calcCheckSum32((u8 *)(nabsData.data()) , nabsData.length());		// 数据累加校验和
    m_pEmbDs16Head->checkCrc = calcCrc16((u8 *)(m_pEmbDs16Head), HEAD_FIX_INFO_LEN);	// 前面6个字段的CRC校验，（6个字段分别为：文件名称，字节数，项个数，每项字节数，每块字节数，数据累加和的CRC校验值）
    u32 fileID = 0;
    fileID = calcCheckSum32((u8 *)(nabsData.data()) , nabsData.length());		// 原始数据累加校验和
    m_pEmbDs16Head->fileid = fileID;  //中间数据的 fileid  =

    m_embAbsData.clear();
    m_embAbsData.append((char *)(m_pEmbDs16Head), sizeof(DataDs16FileHead));
    m_embAbsData.append(nabsData);
}

#define MERGEANGLE      PI/180*70*10000 //70度
void EmbData::reFitLine(s32 stepLen)
{
    QList<LineItem> lineList;
    lineList.clear();

    double stepLength = stepLen;//参数(200-800 单位0.01mm)
    if(stepLength <= 0)
    {
        return;
    }

    LineItem item;
    item.absItemList.clear();

    int dr = 0;
    double prer = 0;
    DsAbsItem preItem;
    memset(&preItem,0,sizeof(DsAbsItem));
    s16 addOftFlag = 0;
    s16 addSewFlag = 0;

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

    //添加线段集合（夹角大于某个值时为新的一段线段）
    int datasize = m_embAbsData.size() - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        return;
    }
    int stepsize = datasize/sizeof(DsAbsItem);
    memcpy((char*)m_pEmbDs16Head,m_embAbsData.data(),sizeof(DataDs16FileHead));
    DsAbsItem * dataBeg = (DsAbsItem *)(m_embAbsData.data()+sizeof(DataDs16FileHead));
    prer = dataBeg->ar;
    for (int i = 0; i < stepsize; i++)
    {
        dr = dataBeg->ar - prer;

        while (dr < -PI10000)
        {
            dr += PI20000;
        }
        while (dr > PI10000)
        {
            dr -= PI20000;
        }

        if(dataBeg->ctrl == DATA_OFFSET)
        {
            if(item.absItemList.size() > 0)
            {
                lineList.append(item);
            }
            item.absItemList.clear();

            item.absItemList.append(*dataBeg);
            lineList.append(item);
            item.absItemList.clear();
        }
        else if(dataBeg->ctrl != DATA_SEWING)
        {
            if(addSewFlag == 1)
            {
                lineList.append(item);
                item.absItemList.clear();
                item.absItemList.append(*(dataBeg-1));
                addSewFlag = 0;
            }
            item.absItemList.append(*dataBeg);
            addOftFlag = 1;
        }
        else
        {
            addSewFlag = 1;
            if(addOftFlag == 1)
            {
                lineList.append(item);
                item.absItemList.clear();
                item.absItemList.append(*(dataBeg-1));
                item.absItemList.append(*dataBeg);
                addOftFlag = 0;
            }
            if((abs(dr) > MERGEANGLE))//新的一条线段
            {
                lineList.append(item);
                item.absItemList.clear();
                item.absItemList.append(*(dataBeg-1));
                item.absItemList.append(*dataBeg);
            }
            else
            {
                item.absItemList.append(*dataBeg);
            }
        }

        prer = dataBeg->ar;
        dataBeg++;
    }

    //开始重置针步（绝对坐标的线段集合）
    QByteArray nabsData;
    nabsData.clear();
    QList<DsAbsItem> outList;

    int lSize = lineList.size();
    for(int i = 0; i < lSize; i++)
    {
        outList.clear();

        int pSize = lineList[i].absItemList.size();
        if(pSize == 1)//只有一个点
        {
            nabsData.append((char*)&lineList[i].absItemList[0],sizeof(DsAbsItem));
        }
        else
        {
            getCurvePointFillLine(lineList[i].absItemList,stepLength,outList);
            //从第二段开始起始点不向绝对坐标中添加，如果添加会出现空针步
            int idx = 0;
            if(i > 0)
            {
                idx = 1;
            }
            for(int m = idx; m < outList.size(); m++)
            {
                nabsData.append((char*)(&outList[m]), sizeof(DsAbsItem));
            }
        }
    }

    //重新计算ar
    stepsize = nabsData.size() / sizeof(DsAbsItem);
    if(stepsize <= 0)
    {
        return;
    }

    //如果最后一针不为结束码，则添加结束码，ax和ay是最后一针的
    DsAbsItem dsAbsItem;
    memcpy(&dsAbsItem,nabsData.data()+(nabsData.size() - sizeof(DsAbsItem)),sizeof(DsAbsItem));
    if(dsAbsItem.ctrl != DATA_END && dsAbsItem.ctrl != DATA_NULL)
    {
        dsAbsItem.ctrl = DATA_END;
        nabsData.append((char*)(&dsAbsItem), sizeof(DsAbsItem));
        stepsize++;
    }

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

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

    double prex,prey,curx,cury,dx,dy;
    prex = prey = curx = cury = dx = dy = 0;

    prex = absDataPtr->ax;
    prey = absDataPtr->ay;

    for (int i = 0; i < stepsize; i++)
    {
        curx = absDataPtr->ax;
        cury = absDataPtr->ay;

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

        double tar = atan2(dy,dx);
        absDataPtr->ar = (tar*10000+0.5*(tar>0?1:-1));
        //        qDebug()  <<"dx dy " << dx << " /"<< dy <<  " index(absDataPtr->ar) : " << i << " : "<< absDataPtr->ar;
        if(curx > maxX)
        {
            maxX = curx;
        }
        if(curx < minX)
        {
            minX = curx;
        }

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

        prex = curx;
        prey = cury;

        absDataPtr++;
    }

    //修改绝对坐标数据
    m_pEmbDs16Head->dataSize = stepsize*sizeof(DsAbsItem);    // 数据字节数
    m_pEmbDs16Head->itemNums = stepsize;                    // 数据项个数
    m_pEmbDs16Head->maxX = maxX;
    m_pEmbDs16Head->minX = minX;
    m_pEmbDs16Head->maxY = maxY;
    m_pEmbDs16Head->minY = minY;
    qDebug() << "--------    m_pEmbDs16Head->maxY = maxY;" << m_pEmbDs16Head->maxY ;
    m_pEmbDs16Head->dataChecksum = calcCheckSum32((u8 *)(nabsData.data()) , nabsData.length());		// 数据累加校验和
    m_pEmbDs16Head->checkCrc = calcCrc16((u8 *)(m_pEmbDs16Head), HEAD_FIX_INFO_LEN);	// 前面6个字段的CRC校验，（6个字段分别为：文件名称，字节数，项个数，每项字节数，每块字节数，数据累加和的CRC校验值）
    u32 fileID = 0;
    fileID = calcCheckSum32((u8 *)(nabsData.data()) , nabsData.length());		// 原始数据累加校验和
    m_pEmbDs16Head->fileid = fileID;  //中间数据的 fileid  =

    m_embAbsData.clear();
    m_embAbsData.append((char *)(m_pEmbDs16Head), sizeof(DataDs16FileHead));
    m_embAbsData.append(nabsData);

    m_ritStepSize = stepLen;
}

void EmbData::reFitLineDoubleHead(s32 stepLen)
{
    QList<LineItem> lineList;
    lineList.clear();

    double stepLength = stepLen;//参数(200-800 单位0.01mm)
    if(stepLength <= 0)
    {
        return;
    }

    LineItem item;
    item.absItemList.clear();

    int dr = 0;
    double prer = 0;
    DsAbsItem preItem;
    memset(&preItem,0,sizeof(DsAbsItem));

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

    //添加线段集合（夹角大于某个值时为新的一段线段）
    int datasize = m_embAbsData.size() - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        return;
    }
    int stepsize = datasize/sizeof(DsAbsItem);
    memcpy((char*)m_pEmbDs16Head,m_embAbsData.data(),sizeof(DataDs16FileHead));
    DsAbsItem * dataBeg = (DsAbsItem *)(m_embAbsData.data()+sizeof(DataDs16FileHead));
    prer = dataBeg->ar;
    for (int i = 0; i < stepsize; i++)
    {
        dr = dataBeg->ar - prer;

        while (dr < -PI10000)
        {
            dr += PI20000;
        }
        while (dr > PI10000)
        {
            dr -= PI20000;
        }

        //只要遇到左机头偏移或右机头偏移，就添加到一段新的线段中
        if(dataBeg->ctrl == DATA_OFFSET || dataBeg->ctrl == DATA_OFFSET_SEC)
        {
            if(item.absItemList.size() > 0)
            {
                lineList.append(item);
            }
            item.absItemList.clear();

            item.absItemList.append(*dataBeg);
            lineList.append(item);
            item.absItemList.clear();
        }
        //只要遇到剪线码，就添加到一段新的线段中
        else if(dataBeg->ctrl == DATA_CUTTRD || dataBeg->ctrl == DATA_SYNC_CUTTER || dataBeg->ctrl == DATA_CUTTER_SEC)
        {
            if(item.absItemList.size() > 0)
            {
                lineList.append(item);
            }
            item.absItemList.clear();

            item.absItemList.append(*dataBeg);
            lineList.append(item);
            item.absItemList.clear();
        }
        else
        {
            if((abs(dr) > MERGEANGLE))//新的一条线段
            {
                if(item.absItemList.size() > 0)
                {
                    lineList.append(item);
                }
                item.absItemList.clear();

                DsAbsItem * preDataBeg = dataBeg - 1;
                if(preDataBeg->ctrl != DATA_OFFSET_SEC)
                {
                    if(preDataBeg->ctrl == dataBeg->ctrl ||
                       (dataBeg->ctrl == DATA_SYNCSEW || dataBeg->ctrl == DATA_MIRROR_SEC ||
                        dataBeg->ctrl == DATA_SYNCOFST || dataBeg->ctrl == DATA_MIRROR_OFT_SEC))
                    {
                        item.absItemList.append(*preDataBeg);
                    }
                }
                else
                {
                    DsAbsItem * preDataBeg2 = dataBeg - 2;
                    if(preDataBeg2->ctrl != DATA_OFFSET)
                    {
                        if(preDataBeg2->ctrl == dataBeg->ctrl ||
                           (dataBeg->ctrl == DATA_SYNCSEW || dataBeg->ctrl == DATA_MIRROR_SEC ||
                            dataBeg->ctrl == DATA_SYNCOFST || dataBeg->ctrl == DATA_MIRROR_OFT_SEC))
                        {
                            item.absItemList.append(*preDataBeg2);
                        }
                    }
                }
                item.absItemList.append(*dataBeg);
            }
            else
            {
                item.absItemList.append(*dataBeg);
            }
        }

        prer = dataBeg->ar;
        dataBeg++;
    }

    if(item.absItemList.size() > 0)
    {
        lineList.append(item);
    }

    //开始重置针步（绝对坐标的线段集合）
    QByteArray nabsData;
    nabsData.clear();
    QList<DsAbsItem> outList;

    int lSize = lineList.size();
    for(int i = 0; i < lSize; i++)
    {
        outList.clear();

        int pSize = lineList[i].absItemList.size();
        if(pSize == 1)//只有一个点
        {
            nabsData.append((char*)&lineList[i].absItemList[0],sizeof(DsAbsItem));
        }
        else
        {
            //            for(int j = 0; j < lineList[i].absItemList.size(); j++)
            //            {
            //                nabsData.append((char*)&lineList[i].absItemList[j],sizeof(DsAbsItem));
            //            }

            getCurvePointFillLine(lineList[i].absItemList,stepLength,outList);
            //从第二段开始起始点不向绝对坐标中添加，如果添加会出现空针步
            int idx = 0;
            if(i > 0)
            {
                idx = 1;
            }
            for(int m = idx; m < outList.size(); m++)
            {
                nabsData.append((char*)(&outList[m]), sizeof(DsAbsItem));
            }
        }
    }

    //重新计算ar
    stepsize = nabsData.size() / sizeof(DsAbsItem);
    if(stepsize <= 0)
    {
        return;
    }

    //如果最后一针不为结束码，则添加结束码，ax和ay是最后一针的
    DsAbsItem dsAbsItem;
    memcpy(&dsAbsItem,nabsData.data()+(nabsData.size() - sizeof(DsAbsItem)),sizeof(DsAbsItem));
    if(dsAbsItem.ctrl != DATA_END && dsAbsItem.ctrl != DATA_NULL)
    {
        dsAbsItem.ctrl = DATA_END;
        nabsData.append((char*)(&dsAbsItem), sizeof(DsAbsItem));
        stepsize++;
    }

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

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

    double prex,prey,curx,cury,dx,dy;
    prex = prey = curx = cury = dx = dy = 0;

    prex = absDataPtr->ax;
    prey = absDataPtr->ay;

    for (int i = 0; i < stepsize; i++)
    {
        curx = absDataPtr->ax;
        cury = absDataPtr->ay;

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

        double tar = atan2(dy,dx);
        absDataPtr->ar = (tar*10000+0.5*(tar>0?1:-1));
        //        qDebug()  <<"dx dy " << dx << " /"<< dy <<  " index(absDataPtr->ar) : " << i << " : "<< absDataPtr->ar;
        if(curx > maxX)
        {
            maxX = curx;
        }
        if(curx < minX)
        {
            minX = curx;
        }

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

        prex = curx;
        prey = cury;

        absDataPtr++;
    }

    //修改绝对坐标数据
    m_pEmbDs16Head->dataSize = stepsize*sizeof(DsAbsItem);    // 数据字节数
    m_pEmbDs16Head->itemNums = stepsize;                    // 数据项个数
    m_pEmbDs16Head->maxX = maxX;
    m_pEmbDs16Head->minX = minX;
    m_pEmbDs16Head->maxY = maxY;
    m_pEmbDs16Head->minY = minY;
    qDebug() << "--------    m_pEmbDs16Head->maxY = maxY;" << m_pEmbDs16Head->maxY ;
    m_pEmbDs16Head->dataChecksum = calcCheckSum32((u8 *)(nabsData.data()) , nabsData.length());		// 数据累加校验和
    m_pEmbDs16Head->checkCrc = calcCrc16((u8 *)(m_pEmbDs16Head), HEAD_FIX_INFO_LEN);	// 前面6个字段的CRC校验，（6个字段分别为：文件名称，字节数，项个数，每项字节数，每块字节数，数据累加和的CRC校验值）
    u32 fileID = 0;
    fileID = calcCheckSum32((u8 *)(nabsData.data()) , nabsData.length());		// 原始数据累加校验和
    m_pEmbDs16Head->fileid = fileID;  //中间数据的 fileid  =

    m_embAbsData.clear();
    m_embAbsData.append((char *)(m_pEmbDs16Head), sizeof(DataDs16FileHead));
    m_embAbsData.append(nabsData);

    m_ritStepSize = stepLen;
}

//移动起始点，左边，前边
int EmbData::moveStartPoint(short left, short front)
{
    if(m_pEmbDs16Head == NULL){return -1;}
    if(m_embDs16Data.size() <= 0){return -1;}

    m_pEmbDs16Head->anchorX += left;
    m_pEmbDs16Head->anchorY += front;
    m_pEmbDs16Head->beginX += left;
    m_pEmbDs16Head->beginY += front;

    //将最大最小值写入文件头
    m_pEmbDs16Head->maxX += left;
    m_pEmbDs16Head->minX += left;
    m_pEmbDs16Head->maxY += front;
    m_pEmbDs16Head->minY += front;
    qDebug() << "--------    m_pEmbDs16Head->maxY += front;" << m_pEmbDs16Head->maxY ;

    m_maxX += left;
    m_minX += left;
    m_maxY += front;
    m_minY += front;
    memcpy(m_embDs16Data.data(),(char*)m_pEmbDs16Head,sizeof(DataDs16FileHead));

    return 0;
}

QByteArray & EmbData::lolaComp(s16 valuePos, s16 valueNeg, s16 valueZero)
{
    if(valuePos == 0 && valueNeg == 0 && valueZero == 0)
    {
        return m_embDs16Data;
    }

    m_minY = S32_MAX;
    m_maxY = S32_MIN;

    double compValPos = valuePos / 1000.0;//一米补偿量,单位mm
    compValPos *= 100;//单位0.01mm

    double compValNeg = valueNeg / 1000.0;//一米补偿量,单位mm
    compValNeg *= 100;//单位0.01mm

    double compValZero = valueZero / 1000.0;//一米补偿量,单位mm
    compValZero *= 100;//单位0.01mm

    // ds16数据
    int size = m_embDs16Data.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        return m_embDs16Data;
    }
    int datasize = size - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        return m_embDs16Data;
    }
    int stepsize = datasize/sizeof(Ds16Item);
    if (stepsize <= 0)
    {
        return m_embDs16Data;
    }

    DataDs16FileHead * pDsHead = (DataDs16FileHead *)(m_embDs16Data.data());
    Ds16Item * ds16DataPtr;
    Ds16Item * pData = (Ds16Item *)(m_embDs16Data.data() + sizeof(DataDs16FileHead));
    ds16DataPtr = pData;

    double actY = pDsHead->beginY;
    m_minY = m_maxY = ds16DataPtr->dy;

    for (int i = 0; i < stepsize; i++)
    {
        // 读入一个针步数据
        if(ds16DataPtr->dx > 0)
        {
            ds16DataPtr->dy += compValPos;
        }

        if(ds16DataPtr->dx < 0)
        {
            ds16DataPtr->dy += compValNeg;
        }

        if(ds16DataPtr->dx == 0)
        {
            ds16DataPtr->dy += compValZero;
        }

        actY += ds16DataPtr->dy;
        if(m_minY > actY)
        {
            m_minY = actY;
        }
        if(m_maxY < actY)
        {
            m_maxY = actY;
        }

        ds16DataPtr++;
    }

#if(1)
    //保存成ds16文件
    QString ds16FilePath = m_filePath + ".ds16";
    QFile file(ds16FilePath);

    if(file.exists())//存在ds16文件
    {
        QFile::remove(ds16FilePath);
    }

    if(!file.open(QIODevice::WriteOnly | QIODevice::Truncate))
    {
        qDebug() << "open file fail when wirte, path =" << m_filePath;
        return m_embDs16Data;
    }
    else
    {
        file.write(m_embDs16Data);
        file.close();
    }
#endif

    return m_embDs16Data;
}

void EmbData::setLastStepAngle()
{
    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return;
    }

    int datasize = size - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        qDebug("absdat dataBegin err");
        return;
    }
    int stepsize = datasize/sizeof(DsAbsItem);
    if (stepsize <= 0)
    {
        qDebug("absdat data size err");
        return;
    }

    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步

    DsAbsItem * preAbsDataPtr = NULL;
    DsAbsItem * lastAbsDataPtr = NULL;

    int rsize = m_embAbsData.size();
    DsAbsItem tmp;
    memcpy(&tmp,m_embAbsData.data()+rsize-2*sizeof(DsAbsItem),sizeof(DsAbsItem));

    int firstFlag = 0;
    int dx = 0;
    int dy = 0;

    for (int j = 0; j < stepsize; j++)
    {
        if(j == 0)
        {
            preAbsDataPtr = absDataPtr;
        }
        else
        {
            if(firstFlag == 0)
            {
                dx = absDataPtr->ax - preAbsDataPtr->ax;
                dy = absDataPtr->ay - preAbsDataPtr->ay;
                firstFlag = 1;
            }
        }

        if(absDataPtr->ctrl == DATA_SEWING)
        {
            lastAbsDataPtr = absDataPtr;
        }
        absDataPtr++;
    }

    //到下一版的第一针的角度变化
    if(lastAbsDataPtr != NULL)
    {
        double tar = atan2(dy,dx);
        lastAbsDataPtr->ar = 0 + (tar * 10000+0.5*(tar>0?1:-1));//0度为基准，再加上第一针的角度变化
    }

    memcpy(&tmp,m_embAbsData.data()+rsize-2*sizeof(DsAbsItem),sizeof(DsAbsItem));
    return;
}

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

void EmbData::appendAEmbAbsFile(QString filePath, QByteArray array, int mirror)
{
    m_filePath = filePath;
    convertAbsDat(array,mirror);//是否镜像、旋转、缩放的转换
    m_embAbsData.clear();
    m_embAbsData.append(array);
    m_editedflag = 1;
}

void EmbData::setAbsDat(QByteArray & dat)
{
    m_embAbsData = dat;
}

QByteArray &  EmbData::getAbsDat(void)
{
    return m_embAbsData;
}

int EmbData::getPosInfoFromNeedleIdx(int stitchIdx, int & posx, int & posy, int & colorIdx, int & dr, int & ar, int & dxV, int & dyV)
{
    if (m_editedflag != 0)
    {
        createEmbDs16FromAbs();
    }

    posx = 0;
    posy = 0;
    colorIdx = 0;
    dr = 0;
    ar = 0;

    // 文件头
    int size = m_embDs16Data.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("m_embDs16Data data less then head size");
        return -1;
    }

    DataDs16FileHead * pDsHead = (DataDs16FileHead *)(m_embDs16Data.data());

    int datasize = size - sizeof(DataDs16FileHead);
    int stepsize = datasize/sizeof(Ds16Item);
    if (stepsize <= 0)
    {
        qDebug("ds16 data size err");
        return -1;
    }

    Ds16Item * ds16DataPtr;
    Ds16Item * pData = (Ds16Item *)(m_embDs16Data.data() + sizeof(DataDs16FileHead));
    ds16DataPtr = pData;

    posx = pDsHead->beginX;
    posy = pDsHead->beginY;

//    posx = 0;
//    posy = 0;

    if (stitchIdx <= 0)
    {
        return 0;
    }

    colorIdx = 1;

    if (stitchIdx > datasize)
    {
        stitchIdx = datasize;
    }

    int dx, dy;
    u8 ctrl, attr;

    for (int i = 0; i < stitchIdx; i++)
    {
        ctrl = ds16DataPtr->ctrl;
        attr = ds16DataPtr->attr;
        dx = ds16DataPtr->dx;
        dy = ds16DataPtr->dy;
        dr = ds16DataPtr->dr;
        dxV = ds16DataPtr->dx;
        dyV = ds16DataPtr->dy;

        if (ctrl == DATA_CHGND)
        {
            colorIdx++;
        }

        if ((attr&0x80) != 0)
        {
            dx *= -1;
        }

        if ((attr&0x40) != 0)
        {
            dy *= -1;
        }

        posx += dx;
        posy += dy;
        ar += dr;

        ds16DataPtr++;
    }

    return 0;
}

//设置起始点
void EmbData::setStartPosition(int x, int y)
{
    qDebug()<<__FUNCTION__;
    if(m_pEmbDs16Head == NULL){
        qDebug()<< "(m_pEmbDs16Head == NULL)";
        return;
    }
    if(m_embDs16Data.size() <= 0){
        qDebug()<< "(m_embDs16Data.size() <= 0)";
        return;
    }

    //旧的起始点坐标
    int oldBeginX = m_pEmbDs16Head->beginX;
    int oldBeginY = m_pEmbDs16Head->beginY;

    m_pEmbDs16Head->beginX = x;
    m_pEmbDs16Head->beginY = y;

    //新的起始点坐标与旧的起始点坐标的差值
    int cx =  x - oldBeginX;
    int cy =  y - oldBeginY;

    //重新计算最大最小XY
    double maxX = m_pEmbDs16Head->maxX + cx;
    double minX = m_pEmbDs16Head->minX + cx;
    double maxY = m_pEmbDs16Head->maxY + cy;
    double minY = m_pEmbDs16Head->minY + cy;

    //将最大最小值写入文件头
    m_pEmbDs16Head->maxX = maxX;
    m_pEmbDs16Head->minX = minX;
    m_pEmbDs16Head->maxY = maxY;
    m_pEmbDs16Head->minY = minY;
    qDebug() << "--------m_pEmbDs16Head->maxY = maxY" << m_pEmbDs16Head->maxY ;

    //修复偶尔点击中间按钮花样消失的bug
    m_maxX = maxX;
    m_minX = minX;
    m_maxY = maxY;
    m_minY = minY;

    memcpy(m_embDs16Data.data(),(char*)m_pEmbDs16Head,sizeof(DataDs16FileHead));
    qDebug()<<"m_maxX"<<m_maxX<<"m_minX"<<m_minX;
    qDebug()<<"m_maxY"<<m_maxY<<"m_minY"<<m_minY;
    qDebug()<<"beginx"<<x<<"beginy"<<y;

#if(0)
    QString suffix = ".ds16";
    QString dsFilePath = m_filePath + suffix;
    QFile file(dsFilePath);

    if(!file.open(QIODevice::WriteOnly | QIODevice::Truncate))
    {
        qDebug() << "open file fail when wirte, path =" << m_filePath;
        return;
    }
    else
    {
        file.write(m_embDs16Data);
        file.close();
    }
#endif
}

void EmbData::setStartPositionDoubleHead(int left,int front)
{
    if(m_pEmbDs16Head == NULL)
    {
        return;
    }
    if((u32)m_embDs16Data.size() < sizeof(DataDs16FileHead))
    {
        return;
    }

#if(0)
    int oldStartX = m_pEmbDs16Head->beginX;
    int oldStartY = m_pEmbDs16Head->beginY;
#endif

    //起始点y1与y2的差
    int cy = m_pEmbDs16Head->beginY2 - m_pEmbDs16Head->beginY;

    int high = m_maxY - m_minY;
    int beginY = high - abs(m_pEmbDs16Head->beginY);//因为y数据与机器坐标相反，所以要用最大值减去起始y
    //int beginY = m_pEmbDs16Head->beginY - m_minY;

    m_pEmbDs16Head->beginX += left;
    m_pEmbDs16Head->beginY = beginY + front;
    double btar = atan2(m_pEmbDs16Head->beginY,m_pEmbDs16Head->beginX);
    double begR = (btar*10000+0.5*(btar>0?1:-1));
    m_pEmbDs16Head->beginR = begR;

    m_pEmbDs16Head->beginX2 += left;
    m_pEmbDs16Head->beginY2 = beginY + front - cy;//因为y数据与机器坐标相反，所以用减

#if(0)
    int sx = m_pEmbDs16Head->beginX - oldStartX;
    int sy = m_pEmbDs16Head->beginY - oldStartY;
    m_pEmbDs16Head->minX += sx;
    m_pEmbDs16Head->maxX += sx;
    m_pEmbDs16Head->minY += sy;
    m_pEmbDs16Head->maxY += sy;
#endif

    int width = m_pEmbDs16Head->maxX - m_pEmbDs16Head->minX;
    int height = m_pEmbDs16Head->maxY - m_pEmbDs16Head->minY;

    m_pEmbDs16Head->minX = left;
    m_pEmbDs16Head->maxX = left + width;
    m_pEmbDs16Head->minY = front;
    m_pEmbDs16Head->maxY = front + height;

    memcpy(m_embDs16Data.data(),(char*)m_pEmbDs16Head,sizeof(DataDs16FileHead));
}

void EmbData::setStartPositionFromLeftFront(int left, int front)
{
    if(m_pEmbDs16Head == NULL)
    {
        return;
    }
    if((u32)m_embDs16Data.size() < sizeof(DataDs16FileHead))
    {
        return;
    }

    int x = 0 - m_minX;
    int y = 0 - m_minY;

    m_pEmbDs16Head->beginX = m_pEmbDs16Head->beginX + left + x;
    m_pEmbDs16Head->beginY = m_pEmbDs16Head->beginY + front + y;
    double btar = atan2(m_pEmbDs16Head->beginY,m_pEmbDs16Head->beginX);

    //边走边裁不用计算起始角度
    if(g_emMacType != MACHINE_CUTTINGWALK)
    {
        double begR = (btar*10000+0.5*(btar>0?1:-1));
        m_pEmbDs16Head->beginR = begR;
    }

    m_minX = m_minX + left + x;
    m_maxX = m_maxX + left + x;
    m_minY = m_minY + front + y;
    m_maxY = m_maxY + front + y;

    m_pEmbDs16Head->minX = m_minX;
    m_pEmbDs16Head->maxX = m_maxX;
    m_pEmbDs16Head->minY = m_minY;
    m_pEmbDs16Head->maxY = m_maxY;

    memcpy(m_embDs16Data.data(),(char*)m_pEmbDs16Head,sizeof(DataDs16FileHead));
}

void EmbData::reCreatDispDat()
{
    createDispFromEmbDs16DatDoubleHeadComb(m_embDs16Data);
}

void EmbData::setAnchorPosition(int x, int y)
{
    if(m_pEmbDs16Head == NULL){return;}
    if(m_embDs16Data.size() <= 0){return;}

    m_pEmbDs16Head->anchorX = x;
    m_pEmbDs16Head->anchorY = y;

    memcpy(m_embDs16Data.data(),(char*)m_pEmbDs16Head,sizeof(DataDs16FileHead));

#if(0)
    QString suffix = ".ds16";
    QString dsFilePath = m_filePath + suffix;
    QFile file(dsFilePath);

    if(!file.open(QIODevice::WriteOnly | QIODevice::Truncate))
    {
        qDebug() << "open file fail when wirte, path =" << m_filePath;
        return;
    }
    else
    {
        file.write(m_embDs16Data);
        file.close();
    }
#endif
}

double EmbData::getAngle(double x1, double y1, double x2, double y2)
{
    double angle;
    if(x1 == x2)
    {
        if(y2 > y1)
        {
            angle = 90.0;
        }
        else
        {
            angle = 270.0;
        }
    }
    else if (y1 == y2)
    {
        if(x1 > x2)
        {
            angle = 180.0;
        }
        else
        {
            angle = 0.0;
        }
    }
    else
    {
        angle = atan((y2 - y1)*1.0 / (x2 - x1) *1.0)*180/M_PI;

        if(angle < 0)
        {
            if(x1 > x2)
            {
                angle = angle + 180.0;
            }
            else
            {
                angle = angle + 360.0;
            }
        }
        else
        {
            if(x1 > x2)
            {
                angle = angle + 180.0;
            }
        }
    }

    return angle;
}

int EmbData::setDatSizeChange(int dsx, int dsy)
{
    //因为帽绣机要有100%以下的缩放倍率，所以将  dsx <= 0 && dsy <= 0，改为以下 -rq
    if (dsx <= 0 && dsy <= 0)
    {
        return 0;
    }

    // 文件头
    const QByteArray & ary = m_embAbsData;
    int size = ary.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    int datasize = size - sizeof(DataDs16FileHead);
    int stepsize = datasize/sizeof(DsAbsItem);
    if (stepsize <= 0)
    {
        qDebug("dat data size err");
        return -1;
    }

    DataDs16FileHead * pDsHead = (DataDs16FileHead *)(ary.data());

    DsAbsItem * pData = (DsAbsItem *)(ary.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;

    int  width  = m_maxX - m_minX;
    int height = m_maxY - m_minY;

    double nw = dsx * 1.0;
    double nh = dsy * 1.0;

    double factorx,factory;
    if (width != 0)
    {
        factorx = nw/(double)width;
    }
    else
    {
        factorx = 1;
    }

    if (height != 0)
    {
        factory = nh/(double)height;
    }
    else
    {
        factory = 1;
    }

    pDsHead->beginX *= factorx;
    pDsHead->beginY *= factory;

    // 数据缩放
    for (int j = 0; j < stepsize; j++)
    {
        double ax = absDataPtr->ax;
        double ay = absDataPtr->ay;

        ax *= factorx;
        ay *= factory;

        absDataPtr->ax = ax;
        absDataPtr->ay = ay;

        absDataPtr++;
    }

    m_editedflag = 1;

    return 1;
}

int EmbData::setMirror(MirrorType mirror)
{
    int mirrorr = 0;
    int mirrorrdir = 0;

    if(mirror == HorizontalMirror)
    {
        mirrorr = 1*PI*10000;
        mirrorrdir = -1;
    }
    else if (mirror == VerticalMirror)
    {
        mirrorr = 2*PI*10000;
        mirrorrdir = -1;
    }
    else if (mirror == BothMirror)
    {
        mirrorr = 1*PI*10000;
        mirrorrdir = 1;
    }

    // 文件头
    const QByteArray & ary = m_embAbsData;
    if(!checkData(ary.size()))
    {
        return -1;
    }
    int stepsize = (ary.size() - sizeof(DataDs16FileHead))/sizeof(DsAbsItem);
    DataDs16FileHead * pDsHead = (DataDs16FileHead *)(ary.data());

    int maxX = pDsHead->maxX;
    int minX = pDsHead->minX;
    int maxY = pDsHead->maxY;
    int minY = pDsHead->minY;
    int width  = maxX - minX; //宽
    int height  = maxY - minY; //高

    //在最大最小xy中 对起始点进行镜像处理
    int bx = pDsHead->beginX;
    int by = pDsHead->beginY;
    //平移到原点
    bx -= minX;
    by -= minY;

    //镜像
    if(mirror == HorizontalMirror || mirror == BothMirror)
        pDsHead->beginX = (width  - bx) + minX;
    if(mirror == VerticalMirror || mirror == BothMirror)
        pDsHead->beginY = (height - by) + minY;

    //beginR的旋转
    double br = pDsHead->beginR;
    if (mirrorrdir > 0)
    {
        br = br + mirrorr;
    }
    else if (mirrorrdir < 0)
    {
        br = mirrorr - br;
    }
    while (br > 2*PI * 10000)
    {
        br -= 2*PI * 10000;
    }
    while (br < -2*PI * 10000)
    {
        br += 2*PI * 10000;
    }
    pDsHead->beginR = br;

    DsAbsItem * pData = (DsAbsItem *)(ary.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;

    // 数据镜像
    for (int j = 0; j < stepsize; j++)
    {
        double ax = absDataPtr->ax;
        double ay = absDataPtr->ay;
        double ar = absDataPtr->ar;

        //平移到原点
        ax -= minX;
        ay -= minY;

        //镜像
        if(mirror == HorizontalMirror || mirror == BothMirror)
            absDataPtr->ax = (width  - ax) + minX;
        if(mirror == VerticalMirror || mirror == BothMirror)
            absDataPtr->ay = (height - ay) + minY;

        if (mirrorrdir > 0)
        {
            ar = ar + mirrorr;
        }
        else if (mirrorrdir < 0)
        {
            ar = mirrorr - ar;
        }

        while (ar > 2*PI * 10000)
        {
            ar -= 2*PI * 10000;
        }
        while (ar < -2*PI * 10000)
        {
            ar += 2*PI * 10000;
        }
        absDataPtr->ar = ar;

        absDataPtr++;
    }

    m_editedflag = 1;
    return 1;
}

//flag :true代表顺时针方向
int EmbData::setRotate90(bool flag)
{

    // 文件头
    const QByteArray & ary = m_embAbsData;
    if(!checkData(ary.size()))
    {
        return -1;
    }
    int stepsize = (ary.size() - sizeof(DataDs16FileHead))/sizeof(DsAbsItem);
    DataDs16FileHead * pDsHead = (DataDs16FileHead *)(ary.data());

    int maxX = pDsHead->maxX;
    int minX = pDsHead->minX;
    int maxY = pDsHead->maxY;
    int minY = pDsHead->minY;
    int width  = maxX - minX; //宽
    int height  = maxY - minY; //高

    int bx = pDsHead->beginX;
    int by = pDsHead->beginY;
    //平移到原点
    bx -= minX;
    by -= minY;

    int tempX;
    int tempY;
    //旋转
    if(flag)
    {
        tempX = by;
        tempY = width - bx;
    }
    else
    {
        tempX = height - by;
        tempY = bx;
    }
    pDsHead->beginX = tempX + minX;
    pDsHead->beginY = tempY + minY;
    qDebug() << "__=++++++++++++++++++++++pDsHead->beginX" << pDsHead->beginX;
    qDebug() << "__=++++++++++++++++++++++pDsHead->beginY" << pDsHead->beginY;

    DsAbsItem * absDataPtr = (DsAbsItem *)(ary.data() + sizeof(DataDs16FileHead));
    for (int j = 0; j < stepsize; j++)
    {
        double ax = absDataPtr->ax;
        double ay = absDataPtr->ay;

        //平移到原点
        ax -= minX;
        ay -= minY;
        //旋转
        int rx, ry;
        if(flag){
            rx = ay;
            ry = width - ax;
        }
        else
        {
            rx = height - ay;
            ry = ax;
        }
        //平移回
        absDataPtr->ax = rx + minX;
        absDataPtr->ay = ry + minY;
        absDataPtr++;
    }

    m_editedflag = 1;
    return 1;

}

///
/// \brief //获得下一个图元的第一缝纫针步
/// \param curIndex
/// \return
///
int EmbData::getNextElementIndex(int curIndex)
{
    // ds16数据
    int size = m_embDs16Data.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("16 data less then head size");
        return -1;
    }
    int datasize = size - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        qDebug("dat dataBegin err");
        return -1;
    }
    int stepsize = datasize/sizeof(Ds16Item);
    if (stepsize <= 0)
    {
        qDebug("ds16 data size err");
        return -1;
    }

    Ds16Item * ds16DataPtr = (Ds16Item *)(m_embDs16Data.data() + sizeof(DataDs16FileHead));
    ds16DataPtr = ds16DataPtr + curIndex;

    u8 curByte =ds16DataPtr->ctrl; //当前状态
    ds16DataPtr ++;
    curIndex ++;

    int i = curIndex;
    for (; i < stepsize; i++)
    {

        if(curByte != DATA_SEWING)
        {
            if(ds16DataPtr->ctrl == DATA_SEWING)
                break;
        }else{
            if(ds16DataPtr->ctrl != DATA_SEWING)
                curByte = ds16DataPtr->ctrl;
        }
        ds16DataPtr++;
    }
    return i;
}

///
/// \brief //上一个图元(当前为跨步时)或当前图元(当前为缝纫时)的第一缝纫针步
/// \param curIndex
/// \return
///
int EmbData::getPreOrThisElementIndex(int curIndex)
{
    // ds16数据
    int size = m_embDs16Data.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("16 data less then head size");
        return -1;
    }
    int datasize = size - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        qDebug("dat dataBegin err");
        return -1;
    }
    int stepsize = datasize/sizeof(Ds16Item);
    if (stepsize <= 0)
    {
        qDebug("ds16 data size err");
        return -1;
    }

    Ds16Item * ds16DataPtr = (Ds16Item *)(m_embDs16Data.data() + sizeof(DataDs16FileHead));
    ds16DataPtr = ds16DataPtr + curIndex;

    u8 curByte =ds16DataPtr->ctrl; //当前状态
    ds16DataPtr--;
    curIndex --;

    int i = curIndex;

    for (; i > 0; i--)
    {
        //如果当前是缝纫数据，找到其他的就返回下一针
        if(curByte == DATA_SEWING)
        {
            if(ds16DataPtr->ctrl != DATA_SEWING)
                break;
        }else{
            //找到其他的就返回下一针
            if(ds16DataPtr->ctrl == DATA_SEWING)
                curByte = DATA_SEWING;
        }
        ds16DataPtr--;
    }
    return ++i;
}

//-------------------------------------------------
// 分割切刀数据(裁床专用代码)
//
#define     CUT_MINST_STP       (5.0)           // 拟合小针步,小于此值的针步将被合并,单位0.01mm
#define     CUT_LINE_MIN_STP    (20.0)          // 直线最小步长,单位0.01mm
#define     CUT_LINE_MAX_STP    (800.0)         // 直线最大步长,单位0.01mm

#define     CUT_ROUD_ANG        (ANGLECORR)     // 圆弧转角判断度数,单位:10000弧度
#define     CUT_ROUD_STP        (10.0)          // 圆弧补偿步长,单位0.01mm
#define     CUT1_RADIUS         (50.0)          // 切刀1圆弧补偿半径,精度0.01mm
#define     CUT2_RADIUS         (50.0)          // 切刀2圆弧补偿半径,精度0.01mm

// 分割直线 (匀变步长 分割针步)
// 返回值:       增加的针数
// posX1,posY1: 起点坐标
// posX2,posY2: 起点坐标
// stepMin:     最小分割针步大小
// stepMax:     最大分割针步大小

// 分割直线
int EmbData::splittingLine(double posX1, double posY1,
                           double posX2, double posY2,
                           int stepMin, int stepMax,
                           QByteArray &cutData, DsAbsItem item)
{
    int num = 0;    // 增加的针步数
    if ((stepMin == 0) || (stepMax == 0))
    {
        return -1;
    }

    DsAbsItem absItem;

    // 线段长
    double len = sqrt((posX1-posX2)*(posX1-posX2)+(posY1-posY2)*(posY1-posY2));

    if (len <= stepMin)
    {
        memcpy(&absItem,&item,sizeof(DsAbsItem));
        num++;
        cutData.append((char*)(&absItem), sizeof(DsAbsItem));    // 中间数据
    }
    else
    {// 分割份数
        int n = (int)(len/stepMin + 0.5);

        int i,j ;
        double add;

        j = stepMin;
        add = 0;
        for (i=0; i<(n/2);i++)
        {// 扫描匀速点和降速点
            add += j;
            j += stepMin;

            if (((add*2)>= len) ||
                    (j >= stepMax) ||
                    0)
            {
                break;
            }
        }

        int n1 = i;  // 匀速点
        int n2 = n-n1-2;  // 减速点

        j = 1;
        add = 1;

        for (i=1; i<=n;i++)
        {
            if (i >= add)
            {
                add += j;
                if (add > n)
                {
                    add = n;
                }

                if ((i >= n2) && (j > 2))
                {
                    j--;
                }
                else if (i < n1)
                {
                    j++;
                }


                memcpy(&absItem,&item,sizeof(DsAbsItem));
                absItem.ax = posX1+(posX2-posX1)*i/n;
                absItem.ay = posY1+(posY2-posY1)*i/n;
                num++;
                cutData.append((char*)(&absItem), sizeof(DsAbsItem));    // 中间数据
            }
        }
    }

    return num;
}


// 分割圆弧
// 返回值:       增加的针数
// posX1,posY1: 起点坐标
// posX2,posY2: 起点坐标
// xc,yc,r:		圆心,半径
// dr1,dr2:     起点,终点角度
// step:        分割针步大小

// 分割圆弧
int EmbData::splittingArc(double posX1, double posY1,
                          double posX2, double posY2,
                          double xc, double yc, double r,
                          double dr1,double dr2,int step,
                          QByteArray &cutData, DsAbsItem item)
{
    int num = 0;
    int dir = 1;

    // 弦长
    double len = sqrt((posX1-posX2)*(posX1-posX2)+(posY1-posY2)*(posY1-posY2));
    // 圆心角
    double k = (r*r+r*r-len*len)/(2*r*r);
    if (k < -1)
    {
        k = -1;
    }
    else if (k > 1)
    {
        k = 1;
    }

    double alph = acos(k);

    if (0)      // 执行此代码生成大圆弧
    {
        alph = PI*2 - alph;
    }

    if (1)
    {// 求旋转方向
        dr1 = dr1*-180/PI10000;
        dr2 = dr2*-180/PI10000;
        //qDebug()<<"bdr1="<<(dr1)<<",bdr2="<<(dr2);


        do
        {// 将dr1变换到整数
            if ((dr1 >= 0) && (dr1 < 360))    { break; }
            else if (dr1 < 0)                 { dr1 += 360; }
            else if (dr1 >= 360)              { dr1 -= 360; }
        }while(1);

        do
        {// 将dr2变换到整数
            if ((dr2 >= 0) && (dr2 < 360))    { break; }
            else if (dr2 < 0)                 { dr2 += 360; }
            else if (dr2 >= 360)              { dr2 -= 360; }
        }while(1);


        if (((dr1 <= 180) && (dr2 <= 180)) ||
                ((dr1 > 180) && (dr2 > 180)) ||
                0 )
        {
            if (dr1 < dr2)
            {
                dir = -1;   // 逆时针(正转)
            }
            else
            {
                dir = 1;    // 顺时针(反转)
            }
        }
        else if ((dr1 > 180) && (dr2 <= 180))
        {
            if ((dr1-180) > dr2)
            {
                dir = -1;   // 逆时针(正转)
            }
            else
            {
                dir = 1;    // 顺时针(反转)
            }
        }
        else if ((dr1 <= 180) && (dr2 > 180))
        {
            if ((dr1+180) > dr2)
            {
                dir = -1;   // 逆时针(正转)
            }
            else
            {
                dir = 1;    // 顺时针(反转)
            }
        }
        //   qDebug()<<"edr1="<<(int)(dr1+0.5)<<",edr2="<<(int)(dr2+0.5)<<",dir="<<dir;
    }


    // 弧长
    len = alph*r;

    // 分割份数
    int n = (int)(len/step + 0.5);

    // 增加的角度和方向
    double inc;
    inc = alph/n;
    inc *= dir;

    if (inc == 0)
    {
        return -1;
    }

    double lastx, lasty;
    double xrot, yrot;
    double ex, ey;

    lastx = posX1;
    lasty = posY1;

    int i = 0;
    DsAbsItem absItem;

    memcpy(&absItem,&item,sizeof(DsAbsItem));
    absItem.ax = posX1;
    absItem.ay = posY1;
    num++;
    cutData.append((char*)(&absItem), sizeof(DsAbsItem));    // 第一针

    do
    {// 点 (lastx, lasty) 在圆上旋转
        {// 旋转坐标值
            xrot=(lastx-xc)*cos(inc) - (lasty-yc)*sin(inc);
            yrot=(lastx-xc)*sin(inc) + (lasty-yc)*cos(inc);
        }

        lastx = xrot + xc;
        lasty = yrot + yc;

        ex = lastx;
        ey = lasty;

        memcpy(&absItem,&item,sizeof(DsAbsItem));
        absItem.ax = ex;
        absItem.ay = ey;

        if (((fabs(lastx-posX2) > 1) || (fabs(lasty-posY2) > 1)) &&
                (i < (n-1)) &&
                1)
        {// 圆弧中间 增加降速抬刀标志
            absItem.attr |= 0x10;
        }
        num++;
        cutData.append((char*)(&absItem), sizeof(DsAbsItem));

        i++;

        if ((fabs(lastx-posX2) <= 1) && (fabs(lasty-posY2) <= 1))
        {
            ex = posX2;
            ey = posY2;

            memcpy(&absItem,&item,sizeof(DsAbsItem));
            absItem.ax = ex;
            absItem.ay = ey;

            num++;
            cutData.append((char*)(&absItem), sizeof(DsAbsItem));
            break;
        }
    } while(i < n);

    return num;
}

// 偏心刀平板切割机补偿算法
// 增加对比数据
int EmbData::setCutcontrastData( )
{
    int cutLineMaxStp = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutLineMaxStp").toInt();
    if (cutLineMaxStp == 0)
    {
        cutLineMaxStp = 100;
    }

    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    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;
    }

    DataDs16FileHead * pHead =  (DataDs16FileHead *)(m_embAbsData.data());
    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步

    DsAbsItem absItem;

    int newstepnum = 0;
    QByteArray cutAbsData;      // 切割临时数据
    cutAbsData.clear();

    double begX;	// 起始点
    double begY;

    // 数据区
    {
        absDataPtr = pData;  //中间数据针步

        for (int j = 0; j < stepsize; j++)
        {
            if ((absDataPtr->ctrl == DATA_NULL) || (absDataPtr->ctrl == DATA_END))
            {
                //   memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                //   newstepnum++;
                //   cutAbsData.append((char*)(absDataPtr), sizeof(DsAbsItem));
            }
            else
            {
                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                newstepnum++;
                cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
            }

            absDataPtr++;
        }
    }

    // 参考数据
    if (1)
    {
        absDataPtr = pData;  //中间数据针步

        for (int j = 0; j < stepsize; j++)
        {
            if ((absDataPtr->ctrl == DATA_NULL) || (absDataPtr->ctrl == DATA_END))
            {
                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                newstepnum++;
                cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
            }
            else
            {
                if (j == 0)
                {
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    absItem.ctrl = DATA_OFFSET;
                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                }
                else
                {// 分割针步

                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    absItem.ctrl = DATA_OFFSET;
                    newstepnum += splittingLine(begX, begY, absDataPtr->ax, absDataPtr->ay,
                                                cutLineMaxStp, cutLineMaxStp,
                                                cutAbsData, absItem);   // 分割直线
                }

                begX = absDataPtr->ax;
                begY = absDataPtr->ay;
            }
            absDataPtr++;
        }
    }


    pHead->dataSize = newstepnum*sizeof(DsAbsItem);     // 数据字节数
    pHead->itemNums = newstepnum;                       // 数据项个数

    cutAbsData.insert(0,(char*)pHead,sizeof(DataDs16FileHead));  // 插入文件头

    m_embAbsData.clear();
    m_embAbsData = cutAbsData;
    m_editedflag = 1;

    return 0;
}

// 增加拐点数据
int EmbData::setCutCornerStep()
{
    int cutRoudAng  = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutRoudAng").toInt();
    cutRoudAng = cutRoudAng * 10000 * PI / 18000;       // 角度->10000弧度

    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    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;
    }

    DataDs16FileHead * pHead =  (DataDs16FileHead *)(m_embAbsData.data());
    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步

    DsAbsItem absItem;

    int newstepnum = 0;
    QByteArray cutAbsData;      // 切割临时数据
    cutAbsData.clear();

    double nf1r = 0;	// 切刀1角度
    double nf2r = 0;	// 切刀2角度

    // 将数据中最后一段的角度赋值给起始角度
    for (int j = 0; j < stepsize; j++)
    {
        if (absDataPtr->ctrl == DATA_EKNIFE1)
        {// 切刀1 角度
            nf1r= absDataPtr->ar;
        }
        else if (absDataPtr->ctrl == DATA_EKNIFE2)
        {// 切刀2 角度
            nf2r= absDataPtr->ar;
        }
        absDataPtr++;
    }

    absDataPtr = pData;  //中间数据针步
    for (int j = 0; j < stepsize; j++)
    {
        if ((absDataPtr->ctrl == DATA_NULL) || (absDataPtr->ctrl == DATA_END))
        {
            memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
            newstepnum++;
            cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
        }
        else
        {
            if (j == 0)
            {
                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                newstepnum++;
                cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
            }
            else if (absDataPtr->ctrl == DATA_EKNIFE1)
            {// 切刀1 补偿
                double dr = abs(absDataPtr->ar - nf1r);
                if (dr >= cutRoudAng)
                {// 判断夹角
                    absDataPtr--;       // 前一针的位置(圆心)
                    double x = absDataPtr->ax;
                    double y = absDataPtr->ay;

                    absDataPtr++;       // 当前针
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    absItem.ax = x;
                    absItem.ay = y;
                    absItem.attr |= 0x20;      // 临时增加拐点标志

                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));

                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                }
                else
                {
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                }

                nf1r = absDataPtr->ar;
            }
            else if (absDataPtr->ctrl == DATA_EKNIFE2)
            {// 切刀2 补偿
                double dr = abs(absDataPtr->ar - nf2r);
                if (dr >= cutRoudAng)
                {// 判断夹角
                    absDataPtr--;       // 前一针的位置(圆心)
                    double x = absDataPtr->ax;
                    double y = absDataPtr->ay;

                    absDataPtr++;       // 当前针
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    absItem.ax = x;
                    absItem.ay = y;
                    absItem.attr |= 0x20;      // 临时增加拐点标志

                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));

                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                }
                else
                {
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                }

                nf2r = absDataPtr->ar;
            }
            else
            {//
                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                newstepnum++;
                cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));    // 保存当前针信息
            }
        }
        absDataPtr++;
    }


    pHead->dataSize = newstepnum*sizeof(DsAbsItem);     // 数据字节数
    pHead->itemNums = newstepnum;                       // 数据项个数

    cutAbsData.insert(0,(char*)pHead,sizeof(DataDs16FileHead));  // 插入文件头

    m_embAbsData.clear();
    m_embAbsData = cutAbsData;
    m_editedflag = 1;

    return 0;
}

// 偏心刀刀尖补偿(裁床专用代码)
int EmbData::setCutEccentricCompensation()
{
    int cut1Radius  =  g_pSettings->readFromIniFile("FlatPanelAlgorithm/cut1Radius").toInt();
    int cut2Radius = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cut2Radius").toInt();
    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    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;
    }

    DataDs16FileHead * pHead =  (DataDs16FileHead *)(m_embAbsData.data());
    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步

    DsAbsItem absItem;

    QByteArray cutAbsData;      // 切割临时数据
    cutAbsData.clear();
    // 数据区
    for (int j = 0; j < stepsize; j++)
    {
        if ((absDataPtr->ctrl == DATA_NULL) || (absDataPtr->ctrl == DATA_END))
        {
            cutAbsData.append((char*)(absDataPtr), sizeof(DsAbsItem));
        }
        else
        {
            if (j == 0)
            {
                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
            }
            else if (absDataPtr->ctrl == DATA_EKNIFE1)
            {// 切刀1 补偿
                double crt = cut1Radius*1.0;               // 分割量
                double r = (absDataPtr->ar) / 10000.0;      // 角度(弧度制)
                double cosr = (double)qCos(r);
                double sinr = (double)qSin(r);
                double tx = cosr * (crt*1.0);
                double ty = sinr * (crt*1.0);

                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                absItem.ax += tx;
                absItem.ay += ty;
                cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
            }
            else if (absDataPtr->ctrl == DATA_EKNIFE2)
            {// 切刀2 补偿
                double crt = cut2Radius*1.0;               // 分割量
                double r = (absDataPtr->ar) / 10000.0;      // 角度(弧度制)
                double cosr = (double)qCos(r);
                double sinr = (double)qSin(r);
                double tx = cosr * (crt*1.0);
                double ty = sinr * (crt*1.0);

                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                absItem.ax += tx;
                absItem.ay += ty;
                cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
            }
            else
            {//
                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
            }
        }
        absDataPtr++;
    }

    cutAbsData.insert(0,(char*)pHead,sizeof(DataDs16FileHead));  // 插入文件头

    m_embAbsData.clear();
    m_embAbsData = cutAbsData;
    m_editedflag = 1;

    return 0;
}

// 增加两端补偿
// 输入
int EmbData:: setCutAddCutterComption()
{
    //int cutRnf1Comp =  g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutRnf1Comp").toInt();
    int cutRnf2Comp =  g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutRnf2Comp").toInt();

    if (cutRnf2Comp == 0)
    {
        return 0;
    }

    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    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;
    }

    DataDs16FileHead * pHead =  (DataDs16FileHead *)(m_embAbsData.data());
    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步

    if (0)
    {
        pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
        absDataPtr = pData;  //中间数据针步

        for (int j = 0; j < stepsize;j++)
        {
            qDebug()<<"3 idx:"<<j
                   <<"  ctrl:"<<absDataPtr->ctrl
                  <<"  attr:"<<absDataPtr->attr
                 <<"  x:"<<absDataPtr->ax
                <<"  y:"<<absDataPtr->ay
                  ;
            absDataPtr++;
        }
    }

    int begFlg = 0;

    DsAbsItem absItem;

    int newstepnum = 0;
    QByteArray cutAbsData;      // 切割临时数据
    cutAbsData.clear();

    {
        absDataPtr = pData;  //中间数据针步
        for (int j = 0; j < stepsize;j++)
        {
            if ((j == 0) ||
                    (absDataPtr->ctrl == DATA_OFFSET) ||        // 偏移
                    (absDataPtr->ctrl == DATA_NULL) ||
                    (absDataPtr->ctrl == DATA_END) ||
                    (absDataPtr->ctrl == DATA_DRAWING) ||        // 画笔
                    0 )
            {// 找到起点
                begFlg = 0;
                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                newstepnum++;
                cutAbsData.append((char*)(absDataPtr), sizeof(DsAbsItem));
            }
            else
            {
                if (begFlg == 0)
                {// 增加起始补偿数据
                    begFlg = 1; // 起始点标志
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    newstepnum++;
                    cutAbsData.append((char*)(absDataPtr), sizeof(DsAbsItem));
                }
                else
                {
                    absDataPtr++;
                    if ((absDataPtr->ctrl == DATA_NULL) ||
                            (absDataPtr->ctrl == DATA_END) ||
                            (absDataPtr->ctrl == DATA_OFFSET)    ||        // 偏移
                            (absDataPtr->ctrl == DATA_DRAWING)   ||        // 画笔
                            0 )
                    {// 增加收尾补偿数据
                        absDataPtr--;

                        double crt = cutRnf2Comp*1.0;              // 补偿量
                        double r = (absDataPtr->ar) / 10000.0;      // 角度(弧度制)
                        double cosr = (double)qCos(r);
                        double sinr = (double)qSin(r);
                        double tx = cosr * (crt*1.0);
                        double ty = sinr * (crt*1.0);

                        memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));

                        absItem.ax += tx;
                        absItem.ay += ty;

                        newstepnum++;
                        cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));

                    }
                    else
                    {
                        absDataPtr--;
                        // 复制当前针步
                        memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                        newstepnum++;
                        cutAbsData.append((char*)(absDataPtr), sizeof(DsAbsItem));

                    }
                }
            }
            absDataPtr++;
        }
    }

    pHead->dataSize = newstepnum*sizeof(DsAbsItem);     // 数据字节数
    pHead->itemNums = newstepnum;                       // 数据项个数

    cutAbsData.insert(0,(char*)pHead,sizeof(DataDs16FileHead));  // 插入文件头

    m_embAbsData.clear();
    m_embAbsData = cutAbsData;
    m_editedflag = 1;

    if (0)
    {
        pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
        absDataPtr = pData;  //中间数据针步

        for (int j = 0; j < newstepnum;j++)
        {
            qDebug()<<"4 idx:"<<j
                   <<"  ctrl:"<<absDataPtr->ctrl
                  <<"  attr:"<<absDataPtr->attr
                 <<"  x:"<<absDataPtr->ax
                <<"  y:"<<absDataPtr->ay
                  ;
            absDataPtr++;
        }
    }
    return 0;
}

// 增加转刀数据(裁床专用代码)
int EmbData::setCutRotaryCutterData()
{
    int cutRoudStp  = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutRoudStp").toInt();
    int cut1Radius = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cut1Radius").toInt();
    int cut2Radius  = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cut2Radius").toInt();

    if (cutRoudStp == 0)
    {
        cutRoudStp = 10;
    }
    if (cut1Radius == 0)
    {
        return 0;
    }
    if (cut2Radius == 0)
    {
        return 0;
    }

    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    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;
    }

    DataDs16FileHead * pHead =  (DataDs16FileHead *)(m_embAbsData.data());
    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步

    DsAbsItem absItem;

    int newstepnum = 0;
    QByteArray cutAbsData;      // 切割临时数据
    cutAbsData.clear();

    double nf1r = 0;	// 切刀1角度
    double nf2r = 0;	// 切刀2角度

    // 将数据中最后一段的角度赋值给起始角度
    for (int j = 0; j < stepsize; j++)
    {
        if (absDataPtr->ctrl == DATA_EKNIFE1)
        {// 切刀1 角度
            nf1r= absDataPtr->ar;
        }
        else if (absDataPtr->ctrl == DATA_EKNIFE2)
        {// 切刀2 角度
            nf2r= absDataPtr->ar;
        }
        absDataPtr++;
    }

    if (0)
    {
        pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
        absDataPtr = pData;  //中间数据针步

        for (int j = 0; j < 100;j++)
        {
            qDebug()<<"5 idx:"<<j
                   <<"  ctrl:"<<absDataPtr->ctrl
                  <<"  attr:"<<absDataPtr->attr
                 <<"  x:"<<absDataPtr->ax
                <<"  y:"<<absDataPtr->ay
                  ;
            absDataPtr++;
        }
    }


    double crt;             // 分割量
    double r;               // 角度(弧度制)
    double tx;
    double ty;

    double posX1,posY1;     // 起点
    double posX2,posY2;     // 终点
    double xc,yc,rc;        // 圆心半径
    double dr1,dr2;         // 起始,终止角度
    int    step;            // 针步
    int    num;             // 增加针数
    u8     ctrlold;         //

    absDataPtr = pData;  //中间数据针步
    // 数据区
    for (int j = 0; j < stepsize; j++)
    {
        if ((absDataPtr->ctrl == DATA_NULL) || (absDataPtr->ctrl == DATA_END))
        {
            memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
            newstepnum++;
            cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
        }
        else
        {
            if (j == 0)
            {
                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                newstepnum++;
                cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
            }
            else if (absDataPtr->ctrl == DATA_EKNIFE1)
            {// 切刀1 补偿
                if ((absDataPtr->attr & 0x20) == 0x20)
                {// 拐点位置针步
                    crt = cut1Radius*1.0;          //
                    posX2 = absDataPtr->ax;         // 终点
                    posY2 = absDataPtr->ay;

                    r = (absDataPtr->ar) / 10000.0;      // 角度(弧度制)
                    tx = (double)qCos(r) * (crt*1.0);
                    ty = (double)qSin(r) * (crt*1.0);

                    xc    = absDataPtr->ax - tx;    // 圆心
                    yc    = absDataPtr->ay - ty;

                    r = (nf1r) / 10000.0;           // 角度(弧度制)
                    tx = (double)qCos(r) * (crt*1.0);
                    ty = (double)qSin(r) * (crt*1.0);

                    posX1    = xc + tx;             // 起点
                    posY1    = yc + ty;

                    rc    = cut1Radius*1.0;        // 半径
                    dr1   = nf1r;                   // 起始角度
                    dr2   = absDataPtr->ar;         // 终止角度
                    step  = cutRoudStp*1.0;       // 步长

                    if (ctrlold != DATA_EKNIFE1)
                    {// 在起点增加偏移数据
                        memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                        absItem.ctrl = DATA_OFFSET;
                        absItem.attr = 0;
                        absItem.ax = posX1;
                        absItem.ay = posY1;
                        newstepnum++;
                        cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                    }
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    num = splittingArc(posX1, posY1, posX2, posY2,
                                       xc, yc, rc, dr1, dr2, step,
                                       cutAbsData, absItem);

                    newstepnum += num;
                }
                else
                {
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                }

                nf1r = absDataPtr->ar;
            }
            else if (absDataPtr->ctrl == DATA_EKNIFE2)
            {// 切刀2 补偿
                if ((absDataPtr->attr & 0x20) == 0x20)
                {// 拐点位置针步
                    crt = cut2Radius*1.0;          //
                    posX2 = absDataPtr->ax;         // 终点
                    posY2 = absDataPtr->ay;

                    r = (absDataPtr->ar) / 10000.0;      // 角度(弧度制)
                    tx = (double)qCos(r) * (crt*1.0);
                    ty = (double)qSin(r) * (crt*1.0);

                    xc    = absDataPtr->ax - tx;    // 圆心
                    yc    = absDataPtr->ay - ty;

                    r = (nf2r) / 10000.0;           // 角度(弧度制)
                    tx = (double)qCos(r) * (crt*1.0);
                    ty = (double)qSin(r) * (crt*1.0);

                    posX1    = xc + tx;             // 起点
                    posY1    = yc + ty;

                    rc    = cut2Radius*1.0;        // 半径
                    dr1   = nf2r;                   // 起始角度
                    dr2   = absDataPtr->ar;         // 终止角度
                    step  = cutRoudStp*1.0;       // 步长

                    if (ctrlold != DATA_EKNIFE2)
                    {// 在起点增加偏移数据
                        memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                        absItem.ctrl = DATA_OFFSET;
                        absItem.attr = 0;
                        absItem.ax = posX1;
                        absItem.ay = posY1;
                        newstepnum++;
                        cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                    }

                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    num = splittingArc(posX1, posY1, posX2, posY2,
                                       xc, yc, rc, dr1, dr2, step,
                                       cutAbsData, absItem);

                    newstepnum += num;
                }
                else
                {
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                }

                nf2r = absDataPtr->ar;
            }
            else
            {//
                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                newstepnum++;
                cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
            }
        }

        ctrlold = absDataPtr->ctrl;
        absDataPtr++;
    }

    pHead->dataSize = newstepnum*sizeof(DsAbsItem);     // 数据字节数
    pHead->itemNums = newstepnum;                       // 数据项个数
    cutAbsData.insert(0,(char*)pHead,sizeof(DataDs16FileHead));  // 插入文件头

    m_embAbsData.clear();
    m_embAbsData = cutAbsData;
    m_editedflag = 1;

    if (0)
    {
        pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
        absDataPtr = pData;  //中间数据针步

        for (int j = 0; j < 100;j++)
        {
            qDebug()<<"6 idx:"<<j
                   <<"  ctrl:"<<absDataPtr->ctrl
                  <<"  attr:"<<absDataPtr->attr
                 <<"  x:"<<absDataPtr->ax
                <<"  y:"<<absDataPtr->ay
                  ;
            absDataPtr++;
        }
    }
    return 0;
}

//  去掉拐点数据
int EmbData::setCutDecCornerStep()
{
    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    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;
    }

    DataDs16FileHead * pHead =  (DataDs16FileHead *)(m_embAbsData.data());
    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步

    if (0)
    {
        pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
        absDataPtr = pData;  //中间数据针步

        for (int j = 0; j < stepsize;j++)
        {
            qDebug()<<"7 idx:"<<j
                   <<"  ctrl:"<<absDataPtr->ctrl
                  <<"  attr:"<<absDataPtr->attr
                 <<"  x:"<<absDataPtr->ax
                <<"  y:"<<absDataPtr->ay
                  ;
            absDataPtr++;
        }

        absDataPtr = pData;  //中间数据针步
    }

    DsAbsItem absItem;

    int newstepnum = 0;
    QByteArray cutAbsData;      // 切割临时数据
    cutAbsData.clear();

    for (int j = 0; j < stepsize; j++)
    {
        if ((absDataPtr->ctrl == DATA_NULL) || (absDataPtr->ctrl == DATA_END))
        {
            memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
            newstepnum++;
            cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
        }
        else
        {
            if (1)// ((absDataPtr->ax != 0) || (absDataPtr->ay != 0)) // 不是第一针
            {
                if (absDataPtr->ctrl != DATA_EKNIFE1)
                {
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));

                    absDataPtr++;
                    if ((absDataPtr->ctrl == DATA_EKNIFE1) &&
                            ((absDataPtr->attr & 0x20) == 0x20) &&
                            1 )
                    {// 当前针是偏移,下一针是转刀补偿数据,将偏移数据的位置指向转刀补偿数据的起点
                        absItem.ax = absDataPtr->ax;
                        absItem.ay = absDataPtr->ay;
                    }
                    absDataPtr--;

                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                }
                else if (absDataPtr->ctrl != DATA_EKNIFE2)
                {
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));

                    absDataPtr++;
                    if ((absDataPtr->ctrl == DATA_EKNIFE2) &&
                            ((absDataPtr->attr & 0x20) == 0x20) &&
                            1 )
                    {// 当前针是偏移,下一针是转刀补偿数据,将偏移数据的位置指向转刀补偿数据的起点
                        absItem.ax = absDataPtr->ax;
                        absItem.ay = absDataPtr->ay;
                    }
                    absDataPtr--;

                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                }
                else
                {
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                }
            }
        }

        absDataPtr++;
    }


    pHead->dataSize = newstepnum*sizeof(DsAbsItem);     // 数据字节数
    pHead->itemNums = newstepnum;                       // 数据项个数

    cutAbsData.insert(0,(char*)pHead,sizeof(DataDs16FileHead));  // 插入文件头

    m_embAbsData.clear();
    m_embAbsData = cutAbsData;
    m_editedflag = 1;

    if (0)
    {
        pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
        absDataPtr = pData;  //中间数据针步

        for (int j = 0; j < newstepnum;j++)
        {
            qDebug()<<"8 idx:"<<j
                   <<"  ctrl:"<<absDataPtr->ctrl
                  <<"  attr:"<<absDataPtr->attr
                 <<"  x:"<<absDataPtr->ax
                <<"  y:"<<absDataPtr->ay
                  ;
            absDataPtr++;
        }
    }
    return 0;
}

// 分割切刀数据
int EmbData::setCutFitSplitStep()
{
    int cutLineMinStp = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutLineMinStp").toInt();
    int cutLineMaxStp  = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutLineMaxStp").toInt();
    if (cutLineMinStp == 0)
    {
        cutLineMinStp = 10;
    }

    if (cutLineMaxStp == 0)
    {
        cutLineMaxStp = 10;
    }

    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    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;
    }

    DataDs16FileHead * pHead =  (DataDs16FileHead *)(m_embAbsData.data());
    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步

    DsAbsItem absItem;

    int newstepnum = 0;
    QByteArray cutAbsData;      // 切割临时数据
    cutAbsData.clear();

    double begX;	// 起始点
    double begY;

    // 数据区
    {
        for (int j = 0; j < stepsize; j++)
        {
            if ((absDataPtr->ctrl == DATA_NULL) || (absDataPtr->ctrl == DATA_END))
            {
                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                newstepnum++;
                cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
            }
            else
            {
                if (j == 0)
                {
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                }
                else
                {// 分割针步
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    newstepnum += splittingLine(begX, begY, absDataPtr->ax, absDataPtr->ay,
                                                cutLineMaxStp, cutLineMaxStp,
                                                cutAbsData, absItem);   // 分割直线
                }

                begX = absDataPtr->ax;
                begY = absDataPtr->ay;
            }
            absDataPtr++;
        }
    }


    pHead->dataSize = newstepnum*sizeof(DsAbsItem);     // 数据字节数
    pHead->itemNums = newstepnum;                       // 数据项个数

    cutAbsData.insert(0,(char*)pHead,sizeof(DataDs16FileHead));  // 插入文件头

    m_embAbsData.clear();
    m_embAbsData = cutAbsData;
    m_editedflag = 1;

    return 0;
}

// 拟合切刀数据(过滤小针步)
int EmbData::setCutFitStepData()
{
    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    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;
    }

    DataDs16FileHead * pHead =  (DataDs16FileHead *)(m_embAbsData.data());
    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步

    DsAbsItem absItem;
    DsAbsItem absItemOld;

    int newstepnum = 0;
    QByteArray cutAbsData;      // 切割临时数据
    cutAbsData.clear();

    // 数据区
    {
        for (int j = 0; j < stepsize; j++)
        {
            if ((absDataPtr->ctrl == DATA_NULL) || (absDataPtr->ctrl == DATA_END))
            {
                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                newstepnum++;
                cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
            }
            else
            {
                if (j == 0)
                {
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    absItem.attr &= ~0x20;      // 删除拐点标志
                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                    memcpy(&absItemOld,absDataPtr,sizeof(DsAbsItem));
                }
                else
                {// 分割针步
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));

                    // 线段长
                    double len = sqrt((absItem.ax-absItemOld.ax)*(absItem.ax-absItemOld.ax)+
                                      (absItem.ay-absItemOld.ay)*(absItem.ay-absItemOld.ay));

                    if ((len <= CUT_MINST_STP) &&
                            (absItem.ctrl   == absItemOld.ctrl   ) &&
                            //(absItem.action == absItemOld.action ) &&
                            //(absItem.attr   == absItemOld.attr   ) &&
                            1)
                    {// 滤掉小针步
                    }
                    else
                    {
                        absItem.attr &= ~0x20;      // 删除拐点标志
                        newstepnum++;

                        double tar = atan2(absItem.ay,absItem.ax);
                        absItem.ar = (tar * 10000+0.5*(tar>0?1:-1));

                        cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                        memcpy(&absItemOld,absDataPtr,sizeof(DsAbsItem));
                    }
                }
            }
            absDataPtr++;
        }
    }

    pHead->dataSize = newstepnum*sizeof(DsAbsItem);     // 数据字节数
    pHead->itemNums = newstepnum;                       // 数据项个数

    cutAbsData.insert(0,(char*)pHead,sizeof(DataDs16FileHead));  // 插入文件头

    m_embAbsData.clear();
    m_embAbsData = cutAbsData;
    m_editedflag = 1;

    return 0;
}


// 飞行切割平板切割机补偿算法    coco
//#define     CUT_CRUTCH_ANG        (ANGLECORR)           // 拐点转角判断度数,单位:10000弧度
//#define     CUT_LINE_STP          (3000)               // 分割数据步长,单位0.01mm
//#define     CUT_X_LENGH           (500000)              // X向可切割长度,单位0.01mm
//#define     CUT_X_WINDOW          (CUT_X_LENGH*3/10)    // X向过窗长度:3/10
//#define     CUT_X_EDGE            (CUT_X_LENGH/10)      // X向过窗边缘 1/10
//#define     CUT_RNF_COMP          (10.00)               // 圆刀退刀补偿 ,单位0.01mm

#define     CUT_OFFSET_SPD        (80000)              // 偏移速度 ,单位0.01mm/s
#define     CUT_DRAWING_SPD       (60000)              // 画笔速度 ,单位0.01mm/s
#define     CUT_CUTTING_SPD       (40000)              // 切割速度 ,单位0.01mm/s
#define     CUT_LEFT_TIME         (1)                   // 升降机头时间 ,单位s
#define     CUT_SPD_ADJ           (100)                 // 行进速度校准 ,范围50%~200% 单位%
#define     CUT_SPD_MAX           (30000)               // 最大行进速度 ,单位0.01mm/s   (1~65500)
//

// 增加拐点数据
int EmbData:: setCut2CornerStep()
{
    int cutCrutchAng = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutCrutchAng").toInt();
    if (cutCrutchAng == 0)
    {
        cutCrutchAng = 60;
    }

    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    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;
    }

    DataDs16FileHead * pHead =  (DataDs16FileHead *)(m_embAbsData.data());
    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步

    DsAbsItem absItem;
    DsAbsItem lastItem;

    int newstepnum = 0;
    QByteArray cutAbsData;      // 切割临时数据
    cutAbsData.clear();

    for (int j = 0; j < stepsize; j++)
    {
        memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));

        if ((j == 0) ||
                (absItem.ctrl == DATA_NULL) ||
                (absItem.ctrl == DATA_END) ||
                0 )
        {
            newstepnum++;
            cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
        }
        else if (absItem.ctrl == DATA_OFFSET)
        {// 偏移数据
            memcpy(&lastItem,&absItem,sizeof(DsAbsItem));
            newstepnum++;
            cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
        }

        else
        {
#if(0)
            double dr = abs(absItem.ar - lastItem.ar);
            if ((dr >= CUT_CRUTCH_ANG) ||                   //改成dr >= (31415/180*cutCrutchAng)
                    (absItem.ctrl != lastItem.ctrl) ||
                    0 )
            {// 当两种控制字交替时,生成一个新数据(线迹起点)
                if ((absItem.ctrl != DATA_OFFSET) &&
                        (lastItem.ctrl != DATA_OFFSET) &&
                        1 )
                {// 如果前后两个控制字都不是偏移数据,插入一个偏移数据
                    absItem.ctrl = DATA_ANGLE_OLD;
                    absItem.ax = lastItem.ax;
                    absItem.ay = lastItem.ay;
                    absItem.ar = lastItem.ar;

                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                }

                {// 新数据段起点
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    absItem.ax = lastItem.ax;
                    absItem.ay = lastItem.ay;

                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                }

                {// 新数据段
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                    memcpy(&lastItem,&absItem,sizeof(DsAbsItem));
                }
            }
            else
#endif
            {
                newstepnum++;
                cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                memcpy(&lastItem,&absItem,sizeof(DsAbsItem));
            }
        }

        absDataPtr++;
    }


    pHead->dataSize = newstepnum*sizeof(DsAbsItem);     // 数据字节数
    pHead->itemNums = newstepnum;                       // 数据项个数

    cutAbsData.insert(0,(char*)pHead,sizeof(DataDs16FileHead));  // 插入文件头

    m_embAbsData.clear();
    m_embAbsData = cutAbsData;
    m_editedflag = 1;

    return 0;
}

// 修改数据方向
int EmbData:: setCut2ModifyDataDir()
{
    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    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;
    }

    DataDs16FileHead * pHead =  (DataDs16FileHead *)(m_embAbsData.data());
    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步
    DsAbsItem * absDataPtrBuf = pData;  //中间数据针步

    DsAbsItem absItem;

    int newstepnum = 0;
    QByteArray cutAbsData;      // 切割临时数据
    cutAbsData.clear();

    double begX = 0.0 ,endX = 0.0;           // 起始点/终止点X坐标
    int  begIdx,endIdx = 0;         // 单个图元起始/终止点

    // 数据区
    {
        absDataPtr = pData;  //中间数据针步

        for (int j = 0; j < stepsize;)
        {
            qDebug()<<"idx:"<<j <<"  ctrl:"<<absDataPtr->ctrl <<"  r:"<<absDataPtr->ar <<"  x:"<<absDataPtr->ax  <<"  y:"<<absDataPtr->ay   ;

            if ((absDataPtr->ctrl == DATA_NULL) ||
                    (absDataPtr->ctrl == DATA_END) ||
                    0 )
            {
                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                newstepnum++;
                cutAbsData.append((char*)(absDataPtr), sizeof(DsAbsItem));

                j++;
                absDataPtr++;
            }
            else if (absDataPtr->ctrl == DATA_ANGLE_OLD)
            {// 找到起点拐点
                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                newstepnum++;
                cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                j++;
                absDataPtr++;

                {//判断下一个数据
                    begIdx = j;
                    begX = absDataPtr->ax;
                    absDataPtrBuf = absDataPtr;
                    for (int i = j; i < stepsize;i++)
                    {
                        if ((absDataPtrBuf->ctrl == DATA_ANGLE_OLD) ||
                                (absDataPtrBuf->ctrl == DATA_NULL) ||
                                (absDataPtrBuf->ctrl == DATA_END) ||
                                0 )
                        {
                            i--;
                            endIdx = i;
                            absDataPtrBuf--;
                            endX = absDataPtrBuf->ax;
                            break;
                        }
                        absDataPtrBuf++;
                    }

                    if ((begIdx != endIdx) &&
                            (endX < begX) &&
                            1 )
                    {// 反转数据
                        for (int i = endIdx; i >= begIdx;i--)
                        {
                            memcpy(&absItem,absDataPtrBuf,sizeof(DsAbsItem));
                            absItem.attr |= 0x01;       // 反向标志
                            absItem.ar += PI10000;       // 方向反向
                            newstepnum++;
                            cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                            qDebug()<<"idx:"<<j <<"  ctrl:"<<absDataPtr->ctrl <<"  r:"<<absDataPtr->ar <<"  x:"<<absDataPtr->ax  <<"  y:"<<absDataPtr->ay   ;

                            j++;
                            absDataPtr++;

                            absDataPtrBuf--;
                        }
                    }
                }
            }
            else
            {
                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                newstepnum++;
                cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));

                j++;
                absDataPtr++;
            }
        }
    }

    pHead->dataSize = newstepnum*sizeof(DsAbsItem);     // 数据字节数
    pHead->itemNums = newstepnum;                       // 数据项个数

    cutAbsData.insert(0,(char*)pHead,sizeof(DataDs16FileHead));  // 插入文件头

    m_embAbsData.clear();
    m_embAbsData = cutAbsData;
    m_editedflag = 1;

    if (0)
    {
        pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
        absDataPtr = pData;  //中间数据针步

        for (int j = 0; j < stepsize;j++)
        {
            qDebug()<<"end idx:"<<j
                   <<"  ctrl:"<<absDataPtr->ctrl
                  <<"  r:"<<absDataPtr->ar
                 <<"  x:"<<absDataPtr->ax
                <<"  y:"<<absDataPtr->ay
                  ;
            absDataPtr++;
        }
    }
    return 0;
}

// 分割切刀数据
int EmbData:: setCut2FitSplitStep()
{
    int cutLineStp = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutLineStp").toInt();
    if(cutLineStp == 0)
    {
        cutLineStp = 3000;
    }
    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    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;
    }

    DataDs16FileHead * pHead =  (DataDs16FileHead *)(m_embAbsData.data());
    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步

    DsAbsItem absItem;

    int newstepnum = 0;
    QByteArray cutAbsData;      // 切割临时数据
    cutAbsData.clear();

    double begX;	// 起始点
    double begY;

    // 数据区
    {
        for (int j = 0; j < stepsize; j++)
        {
            if ((absDataPtr->ctrl == DATA_NULL) || (absDataPtr->ctrl == DATA_END))
            {
                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                newstepnum++;
                cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
            }
            else
            {
                if (j == 0)
                {
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                }
                else
                {// 分割针步
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    newstepnum += splittingLine(begX, begY, absDataPtr->ax, absDataPtr->ay,
                                                cutLineStp, cutLineStp,
                                                cutAbsData, absItem);   // 分割直线
                }

                begX = absDataPtr->ax;
                begY = absDataPtr->ay;
            }
            absDataPtr++;
        }
    }


    pHead->dataSize = newstepnum*sizeof(DsAbsItem);     // 数据字节数
    pHead->itemNums = newstepnum;                       // 数据项个数

    cutAbsData.insert(0,(char*)pHead,sizeof(DataDs16FileHead));  // 插入文件头

    m_embAbsData.clear();
    m_embAbsData = cutAbsData;
    m_editedflag = 1;

    if (0)
    {
        pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
        absDataPtr = pData;  //中间数据针步

        for (int j = 0; j < stepsize;j++)
        {
            qDebug()<<"end idx:"<<j
                   <<"  ctrl:"<<absDataPtr->ctrl
                  <<"  r:"<<absDataPtr->ar
                 <<"  x:"<<absDataPtr->ax
                <<"  y:"<<absDataPtr->ay
                  ;
            absDataPtr++;
        }
    }

    return 0;
}


// 判断区间
// 输入
//#define     CUT_X_LENGH           (500000)              // X向可切割长度
//#define     CUT_X_WINDOW          (CUT_X_LENGH*4/10)    // X向过窗长度:4/10
//#define     CUT_X_EDGE            (CUT_X_LENGH/10)      // X向过窗边缘 1/10
int EmbData:: setCut2JudgInterval()
{
    int cutXWindow = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutXLengh").toInt();
    if(cutXWindow == 0)
    {
        cutXWindow = 500000;
    }
    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    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;
    }

    DataDs16FileHead * pHead =  (DataDs16FileHead *)(m_embAbsData.data());
    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步

    // 求花样X范围
    double maxX = S32_MIN;
    double minX = S32_MAX;

    absDataPtr = pData;  //中间数据针步
    for (int j = 0; j < stepsize; j++)
    {
        if (//(j == 0) ||
                (absDataPtr->ctrl == DATA_NULL) ||
                (absDataPtr->ctrl == DATA_END) ||
                (absDataPtr->ctrl == DATA_ANGLE_OLD) ||
                (absDataPtr->ctrl == DATA_OFFSET) ||
                0 )
        {
        }
        else
        {//
            if(absDataPtr->ax > maxX)
            {
                maxX = absDataPtr->ax;
            }
            if(absDataPtr->ax < minX)
            {
                minX = absDataPtr->ax;
            }
        }
        absDataPtr++;
    }

    // 分割窗口数量
    int winNum,curWin,begFlg;

    int maxWinX = 0;     // 当前窗口最大值
    int minWinX = 0;     // 当前窗口最小值

    curWin = 1;
    begFlg = 0;
    winNum = floor((maxX - minX) / (cutXWindow*3/10)) + 1;

    qDebug()<<"maxx:"<<maxX<<"  minx:"<<minX<<"  winNum:"<<winNum;

    DsAbsItem absItem;

    int newstepnum = 0;
    QByteArray cutAbsData;      // 切割临时数据
    cutAbsData.clear();

    {
        absDataPtr = pData;  //中间数据针步

        for (int j = 0; j < stepsize;j++)
        {
            if ((absDataPtr->ctrl == DATA_NULL) ||
                    (absDataPtr->ctrl == DATA_END) ||
                    0 )
            {
                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                newstepnum++;
                cutAbsData.append((char*)(absDataPtr), sizeof(DsAbsItem));
            }
            else if ((absDataPtr->ctrl == DATA_ANGLE_OLD) ||
                     (absDataPtr->ctrl == DATA_OFFSET)    ||
                     0 )
            {// 找到起点拐点
                begFlg = 0;
                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                newstepnum++;
                cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
            }
            else
            {
                double dtx = absDataPtr->ax - minX;

                if (begFlg == 0)
                {
                    begFlg = 1; // 起始点标志
                    curWin = floor(dtx / (cutXWindow*3/10));

                    maxWinX = (cutXWindow*3/10) * (curWin + 1) + (cutXWindow/10);           // 当前窗口最大值
                    minWinX = (cutXWindow*3/10) * (curWin) - (cutXWindow/10);     // 当前窗口最小值
                    if (0)
                    {
                        qDebug()<<"curWin:"<<curWin
                               <<"  ax:"<<(absDataPtr->ax - minX)
                              <<"  Win:"<<(cutXWindow*3/10)
                             <<"  maxWinX:"<<maxWinX
                            <<"  minWinX:"<<minWinX
                              ;
                    }
                }

                if ((dtx < maxWinX) && (dtx >= minWinX))
                {// 当前窗口
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    absItem.action = curWin;
                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                }
                else if (dtx >= maxWinX)
                {// 下一个窗口
                    curWin++;
                    begFlg = 0;
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    absItem.ctrl = DATA_ANGLE_OLD;
                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));    // 增加一个拐点

                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    absItem.action = curWin;
                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                }
                else if (dtx < minWinX)
                {// 上一个窗口
                    curWin--;
                    begFlg = 0;
                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    absItem.ctrl = DATA_ANGLE_OLD;
                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));    // 增加一个拐点

                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
                    absItem.action = curWin;
                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
                }
            }
            absDataPtr++;
        }
    }

    pHead->dataSize = newstepnum*sizeof(DsAbsItem);     // 数据字节数
    pHead->itemNums = newstepnum;                       // 数据项个数

    cutAbsData.insert(0,(char*)pHead,sizeof(DataDs16FileHead));  // 插入文件头

    m_embAbsData.clear();
    m_embAbsData = cutAbsData;
    m_editedflag = 1;

    if (0)
    {
        pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
        absDataPtr = pData;  //中间数据针步

        for (int j = 0; j < newstepnum;j++)
        {
            qDebug()<<"end idx:"<<j
                   <<"  ctrl:"<<absDataPtr->ctrl
                  <<"  action:"<<absDataPtr->action
                 <<"  x:"<<absDataPtr->ax
                <<"  y:"<<absDataPtr->ay
                  ;
            absDataPtr++;
        }
    }
    return 0;
}

// 增加圆刀数据两端补偿
// 输入
//#define     CUT_RNF_COMP          (1000)                // 圆刀退刀补偿 ,单位0.01mm
int EmbData:: setCut2AddCutterComption()
{
    int cutRnfComp = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutRnfComp").toInt();
    if(cutRnfComp == 0)
    {
        return -1;
    }

    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    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;
    }

    DataDs16FileHead * pHead =  (DataDs16FileHead *)(m_embAbsData.data());
    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步

    if (0)
    {
        pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
        absDataPtr = pData;  //中间数据针步

        for (int j = 0; j < stepsize;j++)
        {
            qDebug()<<"123 idx:"<<j
                   <<"  ctrl:"<<absDataPtr->ctrl
                  <<"  x:"<<absDataPtr->ax
                 <<"  y:"<<absDataPtr->ay
                   ;
            absDataPtr++;
        }
    }

    bool isCuttingData = false;//上一针是切割数据

    DsAbsItem absItem;

    int newstepnum = 0;
    QByteArray cutAbsData;      // 切割临时数据
    cutAbsData.clear();

    absDataPtr = pData;  //中间数据针步
    for (int j = 0; j < stepsize;j++)
    {
        if ((j == 0) ||
                (absDataPtr->ctrl == DATA_NULL) ||
                (absDataPtr->ctrl == DATA_END) ||
                (absDataPtr->ctrl == DATA_ANGLE_OLD) ||        // 拐点
                (absDataPtr->ctrl == DATA_OFFSET)    ||        // 偏移
                (absDataPtr->ctrl == DATA_DRAWING) )       // 画笔
        {// 找到起点
            isCuttingData = false;
            memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
            newstepnum++;
            cutAbsData.append((char*)(absDataPtr), sizeof(DsAbsItem));
        }
        else
        {
            if (!isCuttingData)//上一针不是切割数据
            {// 增加起始补偿数据
                isCuttingData = true; // 起始点标志

                double crt = cutRnfComp*1.0;              // 补偿量
                double r = (absDataPtr->ar) / 10000.0;      // 角度(弧度制)
                double cosr = (double)qCos(r);
                double sinr = (double)qSin(r);
                double tx = cosr * (crt*1.0);
                double ty = sinr * (crt*1.0);

                memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));

                absItem.ax -= tx;
                absItem.ay -= ty;

                newstepnum++;
                cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
            }

            // 复制当前针步
            memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
            newstepnum++;
            cutAbsData.append((char*)(absDataPtr), sizeof(DsAbsItem));

            if (isCuttingData) //上一针是切割数据
            {// 增加收尾补偿数据
                absDataPtr++;
                if ((absDataPtr->ctrl == DATA_NULL) ||
                        (absDataPtr->ctrl == DATA_END) ||
                        (absDataPtr->ctrl == DATA_ANGLE_OLD) ||        // 拐点
                        (absDataPtr->ctrl == DATA_OFFSET)    ||        // 偏移
                        (absDataPtr->ctrl == DATA_DRAWING))        // 画笔
                {
                    absDataPtr--;

                    double crt = cutRnfComp*1.0;              // 补偿量
                    double r = (absDataPtr->ar) / 10000.0;      // 角度(弧度制)
                    double cosr = (double)qCos(r);
                    double sinr = (double)qSin(r);
                    double tx = cosr * (crt*1.0);
                    double ty = sinr * (crt*1.0);

                    memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));

                    absItem.ax += tx;
                    absItem.ay += ty;

                    newstepnum++;
                    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));

                }
                else
                {
                    absDataPtr--;
                }
            }
        }
        absDataPtr++;
    }


    pHead->dataSize = newstepnum*sizeof(DsAbsItem);     // 数据字节数
    pHead->itemNums = newstepnum;                       // 数据项个数

    cutAbsData.insert(0,(char*)pHead,sizeof(DataDs16FileHead));  // 插入文件头

    m_embAbsData.clear();
    m_embAbsData = cutAbsData;
    m_editedflag = 1;

    return 0;
}

//yct实现
int EmbData::setCut2AddCutterComption2()
{
    qDebug()<<__FUNCTION__;
    //补偿长度
    int cutRnfComp = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutRnfComp").toInt();
    double comDistance = cutRnfComp*1.0 ;              // 补偿量

    //垂直补偿
    int cutVertComp = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutVertComp").toInt();
    double comDistanceVert = cutVertComp*1.0 ;              // 补偿量

    //补偿最大角度
    int cutCrutchAng =  g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutCrutchAng").toInt();
    double cutMaxAng = (cutCrutchAng * PI / 180) * 10000; //转换为弧度

    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    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;
    }

    DataDs16FileHead * pHead =  (DataDs16FileHead *)(m_embAbsData.data());
    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步

#if 0
    pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    absDataPtr = pData;  //中间数据针步
    qDebug() << __FUNCTION__ << "PreCompensation Ptr stepsize+++++++++++++++++++++++++++++" << stepsize;
    for (int j = 0; j < stepsize;j++)
    {
        qDebug()<<"idx:"<< j <<"  x:"<<absDataPtr->ax <<"  y:"<<absDataPtr->ay  << "ar:" << absDataPtr->ar <<"  ctrl:"<< QString::number(absDataPtr->ctrl,16);;
        absDataPtr++;
    }
#endif


    int newstepnum = 0;
    QByteArray cutAbsData;      // 切割临时数据
    cutAbsData.clear();
    absDataPtr = pData;  //中间数据针步

    DsAbsItem preAbsItem;//前一针
    int firstCutData = 0; //第一帧数据

    for (int j = 0; j < stepsize; j++)
    {
        // 复制当前针步
        DsAbsItem curAbsItem;
        memcpy(&curAbsItem,absDataPtr,sizeof(DsAbsItem));

        if((firstCutData == 0) && (curAbsItem.ctrl == DATA_RKNIFE  || curAbsItem.ctrl == DATA_SKNIFE)){
            firstCutData = 1;
        }

        DsAbsItem * nextItemPtr = absDataPtr + 1;
        DsAbsItem nextItem;
        memcpy((char*)&nextItem,(char *)nextItemPtr,sizeof(DsAbsItem));
        double dr = qAbs(nextItem.ar) - qAbs(curAbsItem.ar); //偏转角度
        dr = qAbs(dr);

        //倒数第一针 //结尾补偿
        if((j == stepsize - 1) && isCutCtrl(curAbsItem.ctrl)){
            cutDataEndCompensate(curAbsItem,preAbsItem,comDistance);
            cutDataVertCut(curAbsItem, comDistanceVert, cutAbsData,newstepnum);
        }
        else if(j == 0){//第一针不处理

        }
        //结尾补偿
        else if( isCutCtrl(curAbsItem.ctrl)
                 && (nextItem.ctrl == DATA_NULL || nextItem.ctrl == DATA_END
                     || nextItem.ctrl == DATA_ANGLE_OLD || nextItem.ctrl == DATA_OFFSET )
                 && 1)
        {
            cutDataEndCompensate(curAbsItem,preAbsItem,comDistance);
            cutDataVertCut(curAbsItem, comDistanceVert, cutAbsData,newstepnum);
        }
        //开头补偿
        else if (isCutCtrl(nextItem.ctrl)
                 && (curAbsItem.ctrl == DATA_NULL || curAbsItem.ctrl == DATA_END
                     || curAbsItem.ctrl == DATA_ANGLE_OLD || curAbsItem.ctrl == DATA_OFFSET )
                 && 1)
        {
            cutDataStartCompensate(curAbsItem,preAbsItem,nextItem,comDistance);
        }
        //切割数据中大角度分割
        else if((isCutCtrl(preAbsItem.ctrl))
                && (isCutCtrl(curAbsItem.ctrl))
                && (dr > cutMaxAng)
                && (comDistance > 0.0)
                && ((curAbsItem.ay != nextItem.ay) || (curAbsItem.ax != nextItem.ax))
                && 1)
        {
            //            qDebug()<< " cur double end :" << j << "x :" << curAbsItem.ax << "y :" << curAbsItem.ay << "dr:" << dr << "cutMaxAng :" <<cutMaxAng << " ctrl" <<QString::number(curAbsItem.ctrl,16);
            //前一个针步延长
            DsAbsItem endExItem; //结尾延长
            endExItem =  curAbsItem;
            cutDataEndCompensate(endExItem,preAbsItem,comDistance);
            //添加结尾补偿针
            newstepnum++;
            cutAbsData.append((char*)(&endExItem), sizeof(DsAbsItem));

            //后一个针步起点补偿
            curAbsItem.ctrl = DATA_OFFSET;
            cutDataStartCompensate(curAbsItem,preAbsItem,nextItem,comDistance);
        }

        newstepnum++;
        cutAbsData.append((char*)(&curAbsItem), sizeof(DsAbsItem));//添加这一针
        preAbsItem = curAbsItem;//记录针
        absDataPtr++;
    }

    pHead->dataSize = newstepnum*sizeof(DsAbsItem);     // 数据字节数
    pHead->itemNums = newstepnum;                       // 数据项个数
    cutAbsData.insert(0,(char*)pHead,sizeof(DataDs16FileHead));  // 插入文件头

    m_embAbsData.clear();
    m_embAbsData = cutAbsData;
    m_editedflag = 1;
    return 0;
}

// 排序&组成新数据
int EmbData:: setCut2SortNewData()
{
    qDebug()<<__FUNCTION__;
    //是否启用画笔
    //bool enableBrush = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutEnableBrush").toBool();
    bool enableBrush = true;
    int i,j;
    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    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;
    }

    DataDs16FileHead * pHead =  (DataDs16FileHead *)(m_embAbsData.data());
    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));

    int winNum = 0;         // 窗口个数范围
    int begFlg = 0;
    DsAbsItem * absDataPtrWin = pData;  //中间数据针步
    for (j = 0; j < stepsize; j++)
    {
        if (winNum < absDataPtrWin->action)
        {
            winNum = absDataPtrWin->action;
        }
        absDataPtrWin++;
    }
    winNum++;

    // 数据分类
    QVector<QVector<QByteArray> > penVisited(winNum, QVector<QByteArray>(0));       // 画笔数据
    QVector<QVector<QByteArray> > cutShakeVisited(winNum, QVector<QByteArray>(0));       // 震刀数据
    QVector<QVector<QByteArray> > cutRountVisited(winNum, QVector<QByteArray>(0));       // 圆刀数据

#if 0
    DsAbsItem * pData1 = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr1 = pData1;  //中间数据针步
    qDebug() << __FUNCTION__ << "stepsize+++++++++++++++++++++++++++++" << stepsize;
    for (int j = 0; j < stepsize;j++)
    {
        qDebug()<<"idx:"<< j <<"  x:"<<absDataPtr1->ax <<"  y:"<<absDataPtr1->ay  << "ar:" << absDataPtr1->ar <<"  ctrl:"<< QString::number(absDataPtr1->ctrl,16);;
        absDataPtr1++;
    }
#endif
    QByteArray ary;
    DsAbsItem absItem;
    DsAbsItem * preDataPtr;  //前一步指针
    DsAbsItem * absDataPtr = pData;  //中间数据针步
    //偏移数据和拐角数据的赋值策略不一样
    double preAxData = absDataPtr->ax;	//上一个切割数据X
    double preAyData = absDataPtr->ay;	//上一个切割数据Y
    double preAxAngleOld = absDataPtr->ax;	//上一个切割数据X
    double preAyAngleOld = absDataPtr->ay;	//上一个切割数据Y
    bool offsetFlg = false;//偏移数据标志位

    for (j = 0; j < stepsize; j++)
    {
        if ((absDataPtr->ctrl == DATA_NULL) ||
                (absDataPtr->ctrl == DATA_END) ||
                (absDataPtr->ctrl == DATA_ANGLE_OLD) ||
                (absDataPtr->ctrl == DATA_OFFSET))
        {
            begFlg = 0;
            //如果是偏移数据 则记录最后一针位置,
            //然后赋值给拐角数据,这样在偏移的时候不会少第一针
            if(absDataPtr->ctrl == DATA_OFFSET){
                preAxAngleOld = absDataPtr->ax;
                preAyAngleOld = absDataPtr->ay;
                offsetFlg = true;
            }
        }
        else if (begFlg == 0)
        {
            // 增加拐点
            begFlg = 1;         // 起始点标志
            memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));

            if(offsetFlg) //偏移数据 赋值上一拐角数据位置
            {
                absItem.ax = preAxAngleOld;
                absItem.ay = preAyAngleOld;
                offsetFlg = false;
            }else{ //拐角数据 赋值上一针切割数据位置
                absItem.ax = preAxData;
                absItem.ay = preAyData;
            }

            absItem.ctrl = DATA_ANGLE_OLD;
            ary.clear();
            ary.append((char*)&absItem, sizeof(DsAbsItem));
            if (absDataPtr->ctrl == DATA_DRAWING)
            {// 画笔数据
                penVisited[absItem.action].append(ary);
            }
            else if(absDataPtr->ctrl == DATA_SKNIFE)
            {
                cutShakeVisited[absItem.action].append(ary);
            }
            else if(absDataPtr->ctrl == DATA_RKNIFE)
            {
                cutRountVisited[absItem.action].append(ary);
            }
        }

        //记录切割数据  拐角数据分割区域的时候需要赋值
        if(absDataPtr->ctrl == DATA_DRAWING
                || absDataPtr->ctrl == DATA_SKNIFE
                ||absDataPtr->ctrl == DATA_RKNIFE)
        {
            preAxData = absDataPtr->ax;
            preAyData = absDataPtr->ay;
        }

        if( (j!=0) //绝对位置没变化角度也要同前一个
                &&(preDataPtr->ax == absDataPtr->ax)
                && (preDataPtr->ay == absDataPtr->ay)
                &&(preDataPtr->ctrl  == absDataPtr->ctrl))
        {
            absDataPtr->ar = preDataPtr->ar;
        }

        // 增加数据
        memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
        ary.clear();
        ary.append((char*)&absItem, sizeof(DsAbsItem));

        if (absDataPtr->ctrl == DATA_DRAWING)
        {// 画笔数据
            penVisited[absItem.action].append(ary);
        }
        else if(absDataPtr->ctrl == DATA_SKNIFE)
        {
            cutShakeVisited[absItem.action].append(ary);
        }
        else if(absDataPtr->ctrl == DATA_RKNIFE)
        {
            cutRountVisited[absItem.action].append(ary);
        }
        preDataPtr = absDataPtr;
        absDataPtr++;
    }

    //optimizationOrder(penVisited,absItem,winNum,DATA_DRAWING);//画笔不排序-注释
    optimizationOrder(cutShakeVisited,absItem,winNum,DATA_SKNIFE);
    optimizationOrder(cutRountVisited,absItem,winNum,DATA_RKNIFE);

    int newstepnum = 0;
    QByteArray cutAbsData;      // 切割临时数据
    // 合并数据
    cutAbsData.clear();
    s16 penFlag = 0;

    for (i = 0; i<winNum;i++)
    {
        penFlag = 0;
        if(enableBrush)
        {
            int penIndex = i;
            int stepnumPen = penVisited[penIndex].size();   // 画笔数据
            qDebug() << "stepnumPen"  << stepnumPen;
            if (stepnumPen > 0)
            {
                newstepnum += stepnumPen;
                for (j = 0;j<stepnumPen;j++)
                {
                    cutAbsData.append(penVisited[penIndex][j]);
                    memcpy((char*)&absItem, (char *)penVisited[penIndex][j].data(), sizeof(DsAbsItem));
                }
                penFlag = 1;
            }
        }

        int stepCutShake = cutShakeVisited[i].size();   // 切刀数据
        qDebug() << "stepCutShake"  << stepCutShake;
        if (stepCutShake > 0)
        {
            //画笔与切刀数据转换之间增加偏移属性
            if(penFlag == 1)
            {
                DsAbsItem item;
                memcpy(&item,cutShakeVisited[i][0].data(),sizeof(DsAbsItem));
                if(item.ctrl != DATA_OFFSET)
                {
                    item.ctrl = DATA_OFFSET;
                }
                cutAbsData.append((char*)&item,sizeof(DsAbsItem));
                penFlag = 0;
            }
            newstepnum += stepCutShake;
            for (j = 0;j < stepCutShake;j++)
            {
                cutAbsData.append(cutShakeVisited[i][j]);
                memcpy((char*)&absItem, (char *)cutShakeVisited[i][j].data(), sizeof(DsAbsItem));
            }
        }

        int stepCutRound = cutRountVisited[i].size();   // 圆刀数据
        qDebug() << "stepCutRound"  << stepCutRound;
        if (stepCutRound > 0)
        {
            //画笔与切刀数据转换之间增加偏移属性
            if(penFlag == 1)
            {
                DsAbsItem item;
                memcpy(&item,cutRountVisited[i][0].data(),sizeof(DsAbsItem));
                if(item.ctrl != DATA_OFFSET)
                {
                    item.ctrl = DATA_OFFSET;
                }
                cutAbsData.append((char*)&item,sizeof(DsAbsItem));
                penFlag = 0;
            }
            newstepnum += stepCutRound;
            for (j = 0;j < stepCutRound;j++)
            {
                cutAbsData.append(cutRountVisited[i][j]);
                memcpy((char*)&absItem, (char *)cutRountVisited[i][j].data(), sizeof(DsAbsItem));
            }
        }

    }

    //重新计算角度，因为线条进行了排序，所以要重新计算角度
    DsAbsItem * ptr = (DsAbsItem *)(cutAbsData.data());

    double prex = 0;
    double prey = 0;
    double curx = 0;
    double cury = 0;
    double ddx = 0;
    double ddy = 0;
    for(int i = 0; i < newstepnum; i++)
    {
        curx = ptr->ax;
        cury = ptr->ay;
        ddx = curx - prex;
        ddy = cury - prey;
        if(ddx == 0 && ddy == 0 && i > 0)
        {
            DsAbsItem * ptrPre = ptr;
            ptrPre--;
            ptr->ar = ptrPre->ar;
        }
        else
        {
            double tar = atan2(ddy,ddx);
            ptr->ar = (tar * 10000+0.5*(tar>0?1:-1));
        }
        prex = curx;
        prey = cury;
        ptr++;
    }

    pHead->dataSize = newstepnum*sizeof(DsAbsItem);     // 数据字节数
    pHead->itemNums = newstepnum;                       // 数据项个数

#if 0
    DsAbsItem * cutAbsPtr = (DsAbsItem *)cutAbsData.data();
    qDebug()<< "cutAbsData stepsize" << newstepnum;
    for(int i = 0 ; i< newstepnum;i++){
        qDebug()<<"cutAbsData printPtr:"<< "Index :" << i << " ax" << cutAbsPtr->ax << " ay" << cutAbsPtr->ay <<" ctrl" <<QString::number(cutAbsPtr->ctrl,16);
        cutAbsPtr++;
    }
#endif

    cutAbsData.insert(0,(char*)pHead,sizeof(DataDs16FileHead));  // 插入文件头
    m_embAbsData.clear();
    m_embAbsData = cutAbsData;
    m_editedflag = 1;

    return 0;
}


// 增加偏移数据,结束码
int EmbData:: setCut2AddOffsetData()
{
    qDebug()<<__FUNCTION__;
    int cutLineStp = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutLineStp").toInt();
    if(cutLineStp == 0)
    {
        cutLineStp = 3000;
    }
    int size = m_embAbsData.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    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;
    }

    DataDs16FileHead * pHead =  (DataDs16FileHead *)(m_embAbsData.data());
    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步

    DsAbsItem absItem;

    int newstepnum = 0;
    QByteArray cutAbsData;      // 切割临时数据
    cutAbsData.clear();

#if 0
    DsAbsItem * cutAbsPtr = absDataPtr;
    qDebug()<< "Pre AddOffsetData stepsize+++++++++++++++++++++++++++++" << stepsize;
    for(int i = 0 ; i< stepsize;i++){
        qDebug()<<"AddOffsetDataAndEnd Ptr:"<< "Index :" << i << " ax" << cutAbsPtr->ax << " ay" << cutAbsPtr->ay <<" ctrl" <<QString::number(cutAbsPtr->ctrl,16) << "winNum" <<cutAbsPtr->action;
        if(cutAbsPtr->ctrl == DATA_ANGLE_OLD)
            qDebug()<<" == ";
        cutAbsPtr++;
    }
#endif

    // 数据区
    double begX = 0;// 起始点
    double begY = 0;
    for (int j = 0; j < stepsize; j++)
    {
        memcpy(&absItem,absDataPtr,sizeof(DsAbsItem));
        if (j == 0)
        {
            newstepnum++;
            cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
        }
        else if (absItem.ctrl == DATA_ANGLE_OLD)
        {// 分割偏移数据
            absItem.ctrl = DATA_OFFSET;
            absItem.attr = 0;
            if ((begX != absDataPtr->ax) || (begY != absDataPtr->ay))
            {
                newstepnum += splittingLine(begX, begY, absDataPtr->ax, absDataPtr->ay,
                                            cutLineStp, cutLineStp,
                                            cutAbsData, absItem);   // 分割直线
            }
        }
        else
        {
            absItem.attr = 0;
            newstepnum++;
            cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));
        }

        begX = absItem.ax;
        begY = absItem.ay;
        absDataPtr++;
    }



    //结束码
    absItem.ctrl = DATA_NULL;
    newstepnum++;
    cutAbsData.append((char*)(&absItem), sizeof(DsAbsItem));

    pHead->dataSize = newstepnum*sizeof(DsAbsItem);     // 数据字节数
    pHead->itemNums = newstepnum;                       // 数据项个数

    cutAbsData.insert(0,(char*)pHead,sizeof(DataDs16FileHead));  // 插入文件头

    m_embAbsData.clear();
    m_embAbsData = cutAbsData;
    m_editedflag = 1;

    return 0;
}

// 计算最大行进速度 (返回值单位: 0.01mm/s)
// 输入
//#define     CUT_OFFSET_SPD        (100)                 // 偏移速度 ,单位0.01mm/s
//#define     CUT_DRAWING_SPD       (100)                 // 画笔速度 ,单位mm/s
//#define     CUT_CUTTING_SPD       (100)                 // 切割速度 ,单位mm/s
//#define     CUT_LEFT_TIME         (1)                   // 升降机头时间 ,单位s
//#define     CUT_SPD_ADJ           (100)                 // 行进速度校准 ,范围50%~200% 单位%

int EmbData:: setCut2CalMaxSpd()
{
    int cutXWindow = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutXLengh").toInt();
    if(cutXWindow == 0)
    {
        cutXWindow = 500000;
    }

    int j;
    int size = m_embDs16Data.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    int datasize = size - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        qDebug("absdat dataBegin err");
        return -1;
    }
    int stepsize = datasize/sizeof(Ds16Item);
    if (stepsize <= 0)
    {
        qDebug("absdat data size err");
        return -1;
    }
    else
    {
        qDebug()<<"stepsize"<<stepsize;
    }

    Ds16Item * pData = (Ds16Item *)(m_embDs16Data.data() + sizeof(DataDs16FileHead));
    Ds16Item * embDataPtr = pData;
    Ds16Item * curDataPtr;

    // 数据区
    {
        int winNum;
        winNum = 0;         // 窗口个数范围
        u16 curWin;         // 当前窗口

        curDataPtr = embDataPtr;
        for (j = 0; j < stepsize; j++)
        {
            curWin = MAKEWORD(curDataPtr->action[0],curDataPtr->action[1]);
            if (winNum < curWin)
            {
                winNum = curWin;
            }
            curDataPtr++;
        }
        winNum++;

        double winSpd[winNum];      // 窗口速度
        double penlen[winNum];      // 画笔长度
        double cutlen[winNum];      // 裁切长度
        double ofstlen[winNum];     // 偏移长度
        u32 leftTim[winNum];        // 升降次数

        for (j = 0; j < winNum; j++)
        {
            winSpd[j] = 0;         // 窗口速度
            penlen[j] = 0;         // 画笔长度
            cutlen[j] = 0;         // 裁切长度
            ofstlen[j] = 0;        // 偏移长度
            leftTim[j] = 0;        // 升降次数
        }

        // 数据区
        {
            double lastX = 0;
            double lastY = 0;
            double curX = 0;
            double curY = 0;
            double len = 0;
            u8 laetCtrl = DATA_OFFSET;

            curDataPtr = embDataPtr;
            for (j = 0; j < stepsize; j++)
            {
                if (j == 0)
                {
                }
                else if (curDataPtr->ctrl == DATA_OFFSET)
                {// 偏移数据
                    curX = curDataPtr->dx;
                    curY = curDataPtr->dy;
                    len = sqrt((lastX-curX)*(lastX-curX)+(lastY-curY)*(lastY-curY));
                    curWin = MAKEWORD(curDataPtr->action[0],curDataPtr->action[1]);
                    ofstlen[curWin] += len;
                }
                else if (curDataPtr->ctrl == DATA_DRAWING)
                {// 画笔数据
                    curX = curDataPtr->dx;
                    curY = curDataPtr->dy;
                    len = sqrt((lastX-curX)*(lastX-curX)+(lastY-curY)*(lastY-curY));
                    curWin = MAKEWORD(curDataPtr->action[0],curDataPtr->action[1]);
                    penlen[curWin] += len;
                }
                else
                {// 裁切数据
                    curX = curDataPtr->dx;
                    curY = curDataPtr->dy;
                    len = sqrt((lastX-curX)*(lastX-curX)+(lastY-curY)*(lastY-curY));
                    cutlen[curDataPtr->action[0]] += len;
                }

                if (laetCtrl != curDataPtr->ctrl)
                {
                    laetCtrl = curDataPtr->ctrl;
                    curWin = MAKEWORD(curDataPtr->action[0],curDataPtr->action[1]);
                    leftTim[curWin] += 2;       // 升降次数+2
                }

                lastX = curDataPtr->dx;
                lastY = curDataPtr->dy;
                curDataPtr++;
            }

            for (j = 0; j < winNum; j++)
            {// 计算过窗传送电机最大行进速度
                double time = 0;

                time += cutlen[j] / CUT_CUTTING_SPD;    // 裁切时间(单位:s)
                time += penlen[j] / CUT_DRAWING_SPD;    // 画笔时间(单位:s)
                time += ofstlen[j] / CUT_OFFSET_SPD;    // 偏移时间(单位:s)
                time += leftTim[j] * CUT_LEFT_TIME;     // 升降时间(单位:s)

                if (time == 0)
                {
                    winSpd[j] = CUT_SPD_MAX;
                }
                else
                {
                    winSpd[j] = ((cutXWindow*3/10) * CUT_SPD_ADJ / 100 / time);
                }

                if (winSpd[j] > CUT_SPD_MAX)
                {
                    winSpd[j] = CUT_SPD_MAX;
                }

                if (winSpd[j] == 0)
                {
                    winSpd[j] = 1;
                }
                qDebug()<<"winSpd["<<j<<"]="<<winSpd[j];
            }

            {// 将最大速度保存到针步中
                U32ToU8 curmaxpps;
                for (j = 0; j < stepsize; j++)
                {
                    curWin = MAKEWORD(embDataPtr->action[0],curDataPtr->action[1]);
                    curmaxpps.buf32 = (u32)(winSpd[curWin]);
                    memcpy(&embDataPtr->rev,&curmaxpps.buf32,4);
                    embDataPtr++;
                }
            }
        }

    }
    return 0;
}

void EmbData::recalculateAngles()
{
    qDebug()<<__FUNCTION__;
    u32 size = m_embAbsData.size();
    if (size < sizeof(DataDs16FileHead))
    {
        return ;
    }

    DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;  //中间数据针步
    int stepsize = (size - sizeof(DataDs16FileHead))/sizeof(DsAbsItem);

    DsAbsItem * lastItem;
    memset(&lastItem,0,sizeof(DsAbsItem));

    qDebug() <<__FUNCTION__<< "stepsize:" <<stepsize;
    for (int j = 0; j < stepsize - 1; j++)
    {

#if 0
        qDebug()<< "index "<<  j<<" ax" << absDataPtr->ax << "ay" << absDataPtr->ay << "ctrl" <<QString::number(absDataPtr->ctrl,16);
#endif
        if (j == 0)
        {
            lastItem->ax = 0;
            lastItem->ay = 0;
        }
        s32 ar =  calculateAngles(absDataPtr->ax, absDataPtr->ay, lastItem->ax, lastItem->ay);
        absDataPtr->ar = ar;
        //先赋值再递增
        lastItem = absDataPtr++;
    }

}

s32 EmbData::calculateAngles(double endX, double endY, double beginX, double beginY)
{
    double Dx = endX - beginX ;
    double Dy = endY - beginY ;

    double tar = atan2(Dy,Dx);
    s32 ar = (tar * 10000+0.5*(tar>0?1:-1));
    return ar;
}

//切割数据结尾的补偿  移动结尾切割点的方法
void EmbData::cutDataEndCompensate(DsAbsItem &curItem,DsAbsItem &preItem, double comDistance)
{
    if(comDistance <= 0.0)
        return;
    //    curItem.ar = calculateAngles(curItem.ax,curItem.ay,preItem.ax,preItem.ay);
    double preR = curItem.ar / 10000.0;
    double comDisX = qCos(preR) * comDistance;
    double comDisY = qSin(preR) * comDistance;
    //切割数据正向移动
    curItem.ax += comDisX;
    curItem.ay += comDisY;

    if(preItem.ctrl == 0){}//为了去掉警告
}

//添加切割数据结尾 垂直补偿
void EmbData::cutDataVertCut(DsAbsItem &curItem, double comDistance, QByteArray &cutAbsData,int &newstepnum)
{
    if(comDistance <= 0.0)
        return;

    //添加原始切割终点
    newstepnum++;
    cutAbsData.append((char*)(&curItem), sizeof(DsAbsItem));
    qDebug()<<"CrossCut ADD Point:" <<"  x:"<<curItem.ax <<"  y:"<<curItem.ay<< "ar:" << curItem.ar <<"  ctrl:"<< QString::number(curItem.ctrl,16);

    int angle = 45;//45度夹角
    double includedAngle = (angle * PI / 180) * 10000; //转换为弧度

    //新增偏移点  移动到小横切起始点
    double arOffsetPoint = curItem.ar +includedAngle ;
    double offsetX = qCos(arOffsetPoint / 10000.0) * comDistance;
    double offsetY = qSin(arOffsetPoint / 10000.0) * comDistance;
    DsAbsItem offsetPoint;
    memcpy((char*)&offsetPoint, (char*)&curItem, sizeof(DsAbsItem));
    offsetPoint.ctrl = DATA_OFFSET;
    offsetPoint.ax -= offsetX;
    offsetPoint.ay -= offsetY;
    offsetPoint.ar = calculateAngles(offsetPoint.ax,offsetPoint.ay,curItem.ax,curItem.ay);
    newstepnum++;
    cutAbsData.append((char*)(&offsetPoint), sizeof(DsAbsItem));
    qDebug()<<"CrossCut ADD offsetPoint:" <<"  x:"<<offsetPoint.ax <<"  y:"<<offsetPoint.ay<< "ar:" << offsetPoint.ar <<"  ctrl:"<< QString::number(offsetPoint.ctrl,16);;

    //小横切针步
    //此针会在调用函数的循环中被添加
    double arCutPoint = curItem.ar - includedAngle;
    offsetX = qCos(arCutPoint / 10000.0) * comDistance;
    offsetY = qSin(arCutPoint / 10000.0) * comDistance;
    curItem.ax -= offsetX;
    curItem.ay -= offsetY;
    curItem.ar = calculateAngles(curItem.ax,curItem.ay,offsetPoint.ax,offsetPoint.ay);
    qDebug()<<"cur Point:" <<"  x:"<<curItem.ax <<"  y:"<<curItem.ay<< "ar:" << curItem.ar <<"  ctrl:"<< QString::number(curItem.ctrl,16);;

}

//切割数据开头的补偿  移动切割起始点
void EmbData::cutDataStartCompensate(DsAbsItem &curItem, DsAbsItem &preItem, DsAbsItem &nextItem, double comDistance)
{
    if(comDistance <= 0)
        return;

    double nextR = nextItem.ar / 10000.0; //下一针的绝对角度
    double comDisX = qCos(nextR) * comDistance;
    double comDisY = qSin(nextR) * comDistance;
    //跨步数据反向移动
    curItem.ax -= comDisX;
    curItem.ay -= comDisY;
    //计算偏移角度
    curItem.ar = calculateAngles(curItem.ax, curItem.ay, preItem.ax, preItem.ay);
}

bool EmbData::isCutCtrl(u8 &ctrl)
{
    return (ctrl == DATA_RKNIFE || ctrl == DATA_SKNIFE );
}

void EmbData::optimizationOrder(QVector<QVector<QByteArray> > &visited, DsAbsItem &absItem,int winNum,u8 ctrl)
{
    if(winNum <= 1)
    {
        return;
    }

    if(absItem.ctrl == 0){}//为了去掉警告
    int stepnum = 0;

    QVector<QVector<QByteArray> > cpvisited;
    cpvisited = visited;

    int flag = 0;
    double ax,ay;
    ax = ay = 0;

    for (int i=0;i<winNum;i++)
    {
        int duan = 0;       // 数据段
        DsAbsItem * tmpDataPtr;  //数据针步
        stepnum = visited[i].size();   // 数据

        for (int j = 0;j<stepnum;j++)
        {// 判断段数
            tmpDataPtr = (DsAbsItem *)(visited[i][j].data());
            if (tmpDataPtr->ctrl == DATA_ANGLE_OLD)
            {
                duan++;
            }
        }
        //        qDebug()<< "optimizationOrder :duan :" <<duan;
        if (duan < 0)
        {
            return;
        }

        QVector<QVector<QByteArray> > duanData(duan, QVector<QByteArray>(0));      // 临时数据 (正向)

        //        qDebug()<< "optimizationOrder :stepnum :" <<stepnum;
        int k = -1;
        for (int j = 0;j<stepnum;j++)
        {// 拆分段,给临时数据赋值
            tmpDataPtr = (DsAbsItem *)(visited[i][j].data());
            if (tmpDataPtr->ctrl == DATA_ANGLE_OLD)
            {
                k++;
                tmpDataPtr->ctrl = ctrl;
                duanData[k].append(QByteArray((char*)tmpDataPtr, sizeof(DsAbsItem)));     // 保存正向数据
            }
            else
            {
                duanData[k].append(QByteArray((char*)tmpDataPtr, sizeof(DsAbsItem)));     // 保存正向数据
            }
        }

        //重组数据
        cpvisited[i].clear();

        QVector<QVector<QByteArray> > cpduanData;
        cpduanData = duanData;

        for (k=0;k<duan;k++)
        {
            if (duanData[k].size() != 0)
            {
                for(int m = 0; m < duanData[k].size(); m++)
                {
                    tmpDataPtr = (DsAbsItem *)(duanData[k][m].data());
                    if(tmpDataPtr->ctrl != DATA_SKNIFE && tmpDataPtr->ctrl != DATA_RKNIFE)
                    {
                        cpvisited[i].append(QByteArray((char*)tmpDataPtr, sizeof(DsAbsItem)));     // 增加数据
                    }
                    else
                    {
                        if(flag == 0)
                        {
                            ax = tmpDataPtr->ax;
                            ay = tmpDataPtr->ay;//终点坐标
                            cpvisited[i].append(QByteArray((char*)tmpDataPtr, sizeof(DsAbsItem)));     // 增加数据
                        }
                        else
                        {
                            int idx = -1;//索引
                            QList<int> dirList;//方向，0为正向
                            dirList.clear();
                            u32 len = U32_MAX;
                            int dir = 0;
                            //扫描哪个段的起点离上个段的终点最近
                            for(int p=0;p<cpduanData.size();p++)
                            {
                                dir = 0;
                                if (cpduanData[p].size() != 0)
                                {
                                    DsAbsItem *tmpDataPtr1 = (DsAbsItem *)(cpduanData[p][0].data());
                                    DsAbsItem *tmpDataPtr2 = (DsAbsItem *)(cpduanData[p][cpduanData[p].size()-1].data());
                                    u32 len1 = sqrt((tmpDataPtr1->ax-ax)*(tmpDataPtr1->ax-ax)+(tmpDataPtr1->ay-ay)*(tmpDataPtr1->ay-ay));
                                    u32 len2 = sqrt((tmpDataPtr2->ax-ax)*(tmpDataPtr2->ax-ax)+(tmpDataPtr2->ay-ay)*(tmpDataPtr2->ay-ay));

                                    if(len1 > len2)
                                    {
                                        dir = 1;//反向
                                    }
                                    dirList.append(dir);

                                    if(len > len1)
                                    {
                                        idx = p;
                                        len = len1;
                                    }
                                    if(len > len2)
                                    {
                                        idx = p;
                                        len = len2;
                                    }
                                }
                            }
                            //将idx的段加入到cpvisited中
                            if(idx < dirList.size() && idx >= 0)
                            {
                                dir = dirList[idx];
                                if(dir == 0)
                                {
                                    for(int p=0;p<cpduanData[idx].size();p++)
                                    {
                                        DsAbsItem *tmpPtr = (DsAbsItem *)(cpduanData[idx][p].data());
                                        //添加偏移
                                        if(p == 0)
                                        {
                                            DsAbsItem *oftTmpPtr = (DsAbsItem *)(cpduanData[idx][p].data());
                                            oftTmpPtr->ctrl = DATA_OFFSET;
                                            cpvisited[i].append(QByteArray((char*)oftTmpPtr, sizeof(DsAbsItem)));     // 增加偏移
                                        }
                                        cpvisited[i].append(QByteArray((char*)tmpPtr, sizeof(DsAbsItem)));     // 增加数据
                                        if(p == cpduanData[idx].size()-1)
                                        {
                                            ax = tmpPtr->ax;
                                            ay = tmpPtr->ay;
                                        }
                                    }
                                }
                                else
                                {
                                    for(int p=cpduanData[idx].size()-1;p>=0;p--)
                                    {
                                        DsAbsItem *tmpPtr = (DsAbsItem *)(cpduanData[idx][p].data());
                                        //添加偏移
                                        if(p == cpduanData[idx].size()-1)
                                        {
                                            DsAbsItem *oftTmpPtr = (DsAbsItem *)(cpduanData[idx][p].data());
                                            oftTmpPtr->ctrl = DATA_OFFSET;
                                            cpvisited[i].append(QByteArray((char*)oftTmpPtr, sizeof(DsAbsItem)));     // 增加偏移
                                        }
                                        cpvisited[i].append(QByteArray((char*)tmpPtr, sizeof(DsAbsItem)));     // 增加数据
                                        if(p == 0)
                                        {
                                            ax = tmpPtr->ax;
                                            ay = tmpPtr->ay;
                                        }
                                    }
                                }
                                cpduanData.remove(idx);
                                break;
                            }
                            else
                            {
                                break;
                            }
                        }
                    }
                }
                if(flag == 0)
                {
                    cpduanData.remove(k);
                }
                flag = 1;
            }
        }

#if(0)                            //dr 出的问题    coco
        double lastX,lastY,curX,curY,len,minlen;
        lastX = 0;
        lastY = 0;

        {// 重组数据
            int nearDuan;       // 最近的段
            visited[i].clear();

            for (int j=0;j<duan;j++)
            {// 正反方向,判断最近的点
                minlen = S32_MAX;
                nearDuan = 0;       // 最近的段

                for (k=0;k<duan;k++)
                {// 正反方向,判断最近的点
                    if (duanData[k].size() != 0) // 未判断过的段
                    {
                        tmpDataPtr = (DsAbsItem *)(duanData[k][0].data());
                        // 起点距离
                        curX = tmpDataPtr->ax;
                        curY = tmpDataPtr->ay;
                        len = sqrt((lastX-curX)*(lastX-curX)+(lastY-curY)*(lastY-curY));
                        if (minlen >= len)
                        {
                            minlen = len;
                            nearDuan = (k+1);       // 最近的段
                        }

                        // 终点距离
                        tmpDataPtr = (DsAbsItem *)(duanData[k][duanData[k].size()-1].data());
                        curX = tmpDataPtr->ax;
                        curY = tmpDataPtr->ay;
                        len = sqrt((lastX-curX)*(lastX-curX)+(lastY-curY)*(lastY-curY));
                        if (minlen >= len)
                        {
                            minlen = len;
                            nearDuan = (k+1)*(-1);       // 最近的段
                        }
                    }
                }
                qDebug()<< "nearDuan " <<nearDuan;
                if (nearDuan > 0)
                {// 正向赋值
                    nearDuan--;

                    tmpDataPtr = (DsAbsItem *)(duanData[nearDuan][0].data());
                    absItem.ctrl = DATA_ANGLE_OLD;
                    visited[i].append(QByteArray((char*)tmpDataPtr, sizeof(DsAbsItem)));     // 增加拐点数据

                    for (int k=0;k<duanData[nearDuan].size();k++)
                    {
                        tmpDataPtr = (DsAbsItem *)(duanData[nearDuan][k].data());
                        visited[i].append(QByteArray((char*)tmpDataPtr, sizeof(DsAbsItem)));     // 增加拐点数据
                    }
                    lastX = absItem.ax;
                    lastY = absItem.ay;
                    duanData[nearDuan].clear();
                }
                else
                {// 反向赋值
                    nearDuan = (nearDuan*(-1))-1;

                    int l = duanData[nearDuan].size();
                    tmpDataPtr = (DsAbsItem *)(duanData[nearDuan][l-1].data());

                    memcpy(&absItem,tmpDataPtr,sizeof(DsAbsItem));
                    absItem.ctrl = DATA_ANGLE_OLD;
                    visited[i].append(QByteArray((char*)&absItem, sizeof(DsAbsItem)));     // 增加拐点数据

                    for (k=0;k<l;k++)
                    {
                        tmpDataPtr = (DsAbsItem *)(duanData[nearDuan][l-1-k].data());
                        if (absItem.ar >= 0)
                        {
                            absItem.ar -= PI10000;
                        }
                        else
                        {
                            absItem.ar += PI10000;
                        }
                        visited[i].append(QByteArray((char*)tmpDataPtr, sizeof(DsAbsItem)));     // 增加拐点数据
                    }
                    lastX = absItem.ax;
                    lastY = absItem.ay;
                    duanData[nearDuan].clear();
                }
            }
        }
#endif
    }
    visited.clear();
    visited = cpvisited;
}




// 主控参数(与主板参数同步更改)
//#define     CUT_SPD_MINPPS      (10)            // 最小切割速度, 范围 1--100，单位mm/s，默认 10
//#define     CUT_SPD_MAXPPS      (600)          // 最大切割速度, 范围 1--1200，单位mm/s，默认 1000
//#define     CUT_ADD_PPSG        (1000)           // 切割加速度, 范围 1--4000，单位mm/s2，默认 500
//#define     CUT_SLOW_ANGLE      (6000)          // 切割降速最小偏差角度，范围 0--18000，单位 0.01度，默认 3000
//#define     CUT_WORK_MINADD     (1)            // 工作最小加速度

#define     CUTTINGVX_MUTI      (5)             // 切割虚轴脉冲倍数
#define     PULSE_PER_MM        (100)           // 每毫米脉冲数
#define     RADIAN_ACCURACY		(10000)         // 万分之一弧度
#define     N1_FPGA_CLK         (72000000L)     // N1主板FPGA主频
#define     DEG_PER_CIRCLE		(360)           // 每圈的度数（单位 度）
#define     DEG001_PER_DEG		(100)
#define     DEG001_PER_CIRCLE	(DEG_PER_CIRCLE*DEG001_PER_DEG)     // 每圈的度数（单位 0.01度）

#define     MMPS_TO_PPS(mmps)           ((mmps)*PULSE_PER_MM)                       // 单位转换，由“毫米每秒”转换为“脉冲个数每秒”
#define     MMPSS_TO_PPSG(mmpss)        (N1_FPGA_CLK/(PULSE_PER_MM)/(mmpss))           // 单位转换，由“毫米每秒平方”转换为“脉冲个数每秒间隔”，间隔单位为1/72000000秒

#define     ROT_001DEG_TO_PITK(deg)     ((double)(deg)*2*PI*RADIAN_ACCURACY/DEG001_PER_CIRCLE)  // 单位转换，由“0.01度”转换为“万分之一弧度”
#define     VAxisMMPSToPPS(mmps)		(MMPS_TO_PPS(mmps) * CUTTINGVX_MUTI)		// 虚轴速度加快
#define     VAxisMMPSSToPPSG(mmpss)		(MMPSS_TO_PPSG(mmpss) / CUTTINGVX_MUTI)		// 加速度增大


//fillctrl.minchgpps = VAxisMMPSToPPS(g_pCuttingMcPara->workMinAdd*1.0);

u32 EmbData::CalcDisplacement(u32 pps1, u32 pps2, u32 calcTime)
{
    double temp;
    if (pps1 < pps2)
    {
        temp = (pps2-pps1);
    }
    else
    {
        temp = (pps1-pps2);
    }
    temp *= (pps1+pps2);
    temp *= calcTime;
    temp /= (2*N1_FPGA_CLK);
    return (u32)(temp+0.5);
}

s16 EmbData::Rot001ToPitk(s32 ang001)
{
    double temp = ang001;
    temp = ROT_001DEG_TO_PITK(temp);
    return (s16)temp;
}

// 计算切刀运动参数
// 输入:m_embDs16Data
// 输出:m_embDs16Data (在保留数据中增加最大速度)
int EmbData::setCutMoveParameters()
{
    int cutSpdMinpps = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutSpdMinpps").toInt();
    int cutSpdMaxpps = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutSpdMaxpps").toInt();
    int cutAddPpsg = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutAddPpsg").toInt();
    int cutSlowAngle = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutSlowAngle").toInt();
    int cutWorkMinadd = g_pSettings->readFromIniFile("FlatPanelAlgorithm/cutWorkMinadd").toInt();

    int size = m_embDs16Data.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    int datasize = size - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        qDebug("absdat dataBegin err");
        return -1;
    }
    int stepsize = datasize/sizeof(Ds16Item);
    if (stepsize <= 0)
    {
        qDebug("absdat data size err");
        return -1;
    }
    else
    {
        qDebug()<<"stepsize"<<stepsize;
    }

    Ds16Item * pData = (Ds16Item *)(m_embDs16Data.data() + sizeof(DataDs16FileHead));
    Ds16Item * embDataPtr = pData;
    Ds16Item * curDataPtr;

    // 数据区
    u32 minpps = VAxisMMPSToPPS(cutSpdMinpps);	// 最小速度
    u32 maxpps = VAxisMMPSToPPS(cutSpdMaxpps);	// 最大速度
    u32 addppsg = VAxisMMPSSToPPSG(cutAddPpsg);
    u32 minchgpps = VAxisMMPSToPPS(cutWorkMinadd);

    u32 decCount = CalcDisplacement(maxpps, 0, addppsg);	// 最大速度降速到0所需要的位移
    s16 slowAngle = Rot001ToPitk(cutSlowAngle);

    qDebug()<<"minpps"<<minpps;
    qDebug()<<"maxpps"<<maxpps;
    qDebug()<<"addppsg"<<addppsg;
    qDebug()<<"minchgpps"<<minchgpps;
    qDebug()<<"decCount"<<decCount;
    qDebug()<<"slowAngle"<<slowAngle;
    qDebug()<<"---------------------";

    U32ToU8 curmaxpps;
    u32 mintpps;       // 最小速度
    u32 temp;          // 临时速度

    int i,j;
    int geted = 0;
    s32 dx, dy, len, odx, ody, olen, mdx, mdy, mdxy;

    for (j = 0; j < stepsize; j++)
    {
        curmaxpps.buf32 = 0;
        mintpps = maxpps;       // 最小速度初值为最大切割速度

        if ((embDataPtr->ctrl == DATA_NULL) || (embDataPtr->ctrl == DATA_END))
        {
            break;
        }
        else
        {
            curDataPtr = embDataPtr;
            for (i=j; i<stepsize; i++)
            {
                if ((curDataPtr->ctrl == DATA_NULL) || (curDataPtr->ctrl == DATA_END))
                {
                    mintpps = minpps;	// 简化处理，直接降速到最低
                    break;
                }

                temp = mintpps;

                // 得到当前数据需要的速度
                if (curDataPtr->ctrl == embDataPtr->ctrl) 			// 数据类型相同
                {
                    if (abs(curDataPtr->dr) > slowAngle)			// 角度差大于降速角度，需要降速
                    {
                        temp = minpps;	// 简化处理，直接降速到最低
                    }
                    else
                    {
                        // 计算本针步最大允许速度
                        // 用XY的速度变化差值限制
                        if (curDataPtr->len != 0)
                        {
                            if (geted != 0)
                            {
                                odx = dx;
                                ody = dy;
                                olen = len;
                            }

                            dx = curDataPtr->dx;
                            dy = curDataPtr->dy;
                            len = curDataPtr->len;

                            if (geted == 0)
                            {
                                odx = dx;
                                ody = dy;
                                olen = len;
                                geted = 1;
                            }

                            mdx = abs(dx*olen - odx*len);
                            mdy = abs(dy*olen - ody*len);
                            mdxy = mdx;
                            if (mdxy < mdy)
                            {
                                mdxy = mdy;
                            }

                            if (mdxy != 0)
                            {
                                temp = minchgpps * len * olen / mdxy;
                            }
                        }
                    }
                }
                else
                {
                    // 不同类型，直接降速到最低
                    mintpps = minpps;	// 目标速度
                    break;
                }

                if (mintpps > temp)		// 最小速度大于当前计算速度
                {
                    mintpps = temp;		// 开始降速
                }
                if (mintpps < minpps)
                {
                    mintpps = minpps;
                    break;
                }

                if (decCount > curDataPtr->len)
                {
                    decCount -= curDataPtr->len;
                }
                else
                {
                    decCount = 0;
                    break;
                }

                curDataPtr++;
            }
        }

        curmaxpps.buf32 = mintpps;
        memcpy(&embDataPtr->rev,&curmaxpps.buf32,4);
        embDataPtr++;
    }
    return 0;
}

//-----------------------------------------------------

int EmbData::setRotate(int dr)
{
    double rr = (dr * PI / 180) * 10000; //转换为弧度

    if (dr == 0 || dr == 360)
    {
        return 0;
    }

    double angle, sina, cosa;

#if (1)
    // 因为计算三角函数有问题，现在只支持 1度，10度，90度
    switch(dr)
    {
    case 1:
        sina = 0.01745240643728351281941897851632;
        cosa = 0.99984769515639123915701155881391;
        break;
    case 10:
        sina = 0.17364817766693034885171662676931;
        cosa = 0.98480775301220805936674302458952;
        break;
    case 90:
        sina = 1;
        cosa = 0;
        break;
    case -1:
        sina = -0.01745240643728351281941897851632;
        cosa = 0.99984769515639123915701155881391;
        break;
    case -10:
        sina = -0.17364817766693034885171662676931;
        cosa = 0.98480775301220805936674302458952;
        break;
    case -90:
        sina = -1;
        cosa = 0;
        break;
    default:
        angle = (dr * PI) / 180.0;
        sina = (double)qSin(angle);
        cosa = (double)qCos(angle);
        break;
    }

#else

    angle = (dr * PI) / 180.0;
    sina = (double)qSin(angle);
    cosa = (double)qCos(angle);
#endif

    // 文件头
    const QByteArray & ary = m_embAbsData;
    int size = ary.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return -1;
    }

    int datasize = size - sizeof(DataDs16FileHead);
    int stepsize = datasize/sizeof(DsAbsItem);
    if (stepsize <= 0)
    {
        qDebug("dat data size err");
        return -1;
    }
    DataDs16FileHead * pDsHead = (DataDs16FileHead *)(ary.data());

    //beginR的旋转
    double br = pDsHead->beginR + rr;
    while (br > 2*PI * 10000)
    {
        br -= 2*PI * 10000;
    }
    while (br < -2*PI * 10000)
    {
        br += 2*PI * 10000;
    }
    pDsHead->beginR = br;

    DsAbsItem * pData = (DsAbsItem *)(ary.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;

    // 数据旋转
    for (int j = 0; j < stepsize; j++)
    {
        // 变换前点坐标
        double ax = absDataPtr->ax;
        double ay = absDataPtr->ay;
        double ar = absDataPtr->ar + rr;

        while (ar > 2*PI * 10000)
        {
            ar -= 2*PI * 10000;
        }
        while (ar < -2*PI * 10000)
        {
            ar += 2*PI * 10000;
        }
        // 变换后点的坐标
        double rax = (ax*cosa - ay*sina);
        double ray = (ax*sina + ay*cosa);

        absDataPtr->ax = rax;
        absDataPtr->ay = ray;
        absDataPtr->ar =  ar;
        absDataPtr++;
    }

    m_editedflag = 1;

    return 1;
}

//此函数转换传入的绝对坐标值，是否取镜像及反复时数据之间的间距
void EmbData::convertAbsDat(QByteArray &dat, int mirror)
{
    //无镜像、xy间距、角度旋转、缩放比例都为0时数据无需转换
    if(mirror == 0 &&
            m_spaceX == 0 &&
            m_spaceY == 0 )
    {
        return;
    }

    int size = dat.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("data less then head size");
        return;
    }
    DataDs16FileHead * pDsHead = (DataDs16FileHead *)(dat.data());

    int datasize = size - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        qDebug("dat dataBegin err");
        return;
    }
    int stepsize = datasize/sizeof(DsAbsItem);
    if (stepsize <= 0)
    {
        qDebug("dat data size err");
        return;
    }
    DsAbsItem * pData = (DsAbsItem *)(dat.data() + sizeof(DataDs16FileHead));
    DsAbsItem * absDataPtr = pData;
    //--------

    //镜像数值不为0---开始
    // mirror 0, 无镜像; 1, 水平镜像; 2, 垂直镜像; 3, 水平和垂直镜像
    int mirrorx = 1;
    int mirrory = 1;
    int mirrorr = 1;

    if(mirror == 1 || mirror == 3)
    {
        mirrorx = -1;
        mirrorr = -1;
    }
    if(mirror == 2 || mirror == 3)
    {
        mirrory = -1;
        mirrorr = -1;
    }

    // 镜像文件头转换
    if(mirror != 0)
    {
        pDsHead->beginX = pDsHead->beginX * mirrorx;
        pDsHead->beginY = pDsHead->beginY * mirrory;
    }

    // 镜像或列表间距不为0
    if(mirror != 0 || m_spaceX != 0 || m_spaceY != 0)
    {
        //图形先居中，起始点在加上偏移
        int centerx = (m_maxX + m_minX)/2;
        int centery = (m_maxY + m_minY)/2;

        int rx = (pDsHead->beginX - centerx) * mirrorx;
        int ry = (pDsHead->beginY - centery) * mirrory;

        int beginx = rx + centerx;
        int beginy = ry + centery;

        //用下面两行代码，否则反复方式为Y轴对称或XY对称时不对
        pDsHead->beginX = beginx + m_spaceX;
        pDsHead->beginY = beginy + m_spaceY;
    }
    //镜像数值不为0---结束

    absDataPtr = pData;

    //镜像有变换时运动步才转换
    double dx, dy, dr;

    if(mirror != 0)
    {
        for (int i = 0; i < stepsize; i++)
        {
            // 读入一个针步数据
            dx = absDataPtr->ax;
            dy = absDataPtr->ay;
            dr = absDataPtr->ar;

            //镜像不为0
            if(mirror != 0)
            {
                dx = dx * mirrorx;
                dy = dy * mirrory;
                dr = dr * mirrorr;
            }

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

            absDataPtr++;
        }
    }

    return;
}

int EmbData::calcLine(double x0, double y0, double x1, double y1, s16 step, QByteArray &absAry, DsAbsItem item)
{
    DsAbsItem absItem;
    memcpy(&absItem,&item,sizeof(DsAbsItem));

    s32 dx, dy;
    double length;
    double tmp;
    int count;
    int i;
    double stepx, stepy;
    double sx, sy;
    int actx, acty;
    double k;

    if(x0 == x1 && y0 == y1)
    {
        return 0;
    }

    if(x0 > x1)
    {
        sx = -1.0;				// x反向
    }
    else
    {
        sx = 1.0;
    }

    if(y0 > y1)
    {
        sy = -1.0;				// y反向
    }
    else
    {
        sy = 1.0;
    }

    // 开始分割针步
    length = sqrt((x0-x1)*(x0-x1)+(y0-y1)*(y0-y1));

    tmp = length/step;		/* 实际针步数 */
    count = floor(tmp);		/* 最少整针步数 */

    if (tmp - count > 0.01)
    {
        count += 1;
    }

    if (count == 0 && length > 0)	// 短直线
    {
        count = 1;
    }

    tmp = 0;
    actx = x0;
    acty = y0;

    if (x1 != x0 && y1 == y0)				// 横直线
    {
        for (i = 0; i < count; i++)
        {
            tmp = ((i+1)*(length)/count)*sx+x0;	// 实际针步

            stepx = tmp - actx;
            dx = (s32)(stepx+0.5*sx);
            dy = 0;
            actx += dx;

            absItem.ax = actx;
            absItem.ay = y0;
            absAry.append((char*)&absItem,sizeof(DsAbsItem));
        }
    }
    else if (x1 == x0 && y1 != y0)			// 竖直线
    {
        for (i = 0; i < count; i++)
        {
            tmp = ((i+1)*(length)/count)*sy + y0;	// 实际针步

            stepy = tmp - acty;

            dx = 0;
            dy = (s32)(stepy+0.5*sy);
            acty += dy;

            absItem.ax = x0;
            absItem.ay = acty;
            absAry.append((char*)&absItem,sizeof(DsAbsItem));
        }
    }
    else if(x1 != x0 && y1 != y0)			 // 任意斜线
    {
        k = (y1-y0)/(x1-x0);
        for (i = 0; i < count; i++)
        {
            tmp = ((i+1)*(length)/count);

            stepx = fabs(tmp*cos(atan(k)))*sx + x0;	// 实际针步x
            stepy = fabs(tmp*sin(atan(k)))*sy + y0;	// 实际针步y

            dx = (s32)(stepx-actx+0.5*sx);
            dy = (s32)(stepy-acty+0.5*sy);

            actx += dx;
            acty += dy;

            absItem.ax = actx;
            absItem.ay = acty;
            absAry.append((char*)&absItem,sizeof(DsAbsItem));
        }
    }
    else
    {
        printf("what's this?\n");
    }

    return count;
}

//花版的定位点为绝对坐标数据点，起始点为相对于定位点的相对坐标点，第一针为相对于起始点的坐标点
//有的花版起始点有偏移量，第一针偏移量为0，有的花版起始点偏移量为0，第一针有偏移量
//所以ds16文件头定位点坐标就是花版中的定位点，起始点坐标为花版中的定位点坐标+起始点坐标+第一针的坐标，同时ds16数据的第一针坐标偏移应置为0
//生成DS16数据
int EmbData::createEmbDs16FromAbs()
{
    if(g_emMacType == MACHINE_DOUBLEHEADQUI || g_emMacType == MACHINE_FOURHEADQUI)
    {
        createEmbDs16FromAbsDoubleHeadComb();
        return 0;
    }

    if (m_editedflag != 0)
    {
        m_minX = S32_MAX;
        m_maxX = S32_MIN;
        m_minY = S32_MAX;
        m_maxY = S32_MIN;

        m_embDs16Data.clear();

        char fileName[32];
        memset(fileName,0,sizeof(fileName));
        QByteArray tgtdsdat;
        tgtdsdat.clear();

        int colornum = 1;
        int jumpNeedleNum = 0;//跳针数
        int totalstepsize = 0;
        memset(m_pEmbDs16Head,0,sizeof(DataDs16FileHead));

        const QByteArray & ary = m_embAbsData;
        int size = ary.size();
        if (size <= (int)sizeof(DataDs16FileHead))
        {
            qDebug("ary data less then head size");
            return -1;
        }
        DataDs16FileHead * pDsHead = (DataDs16FileHead *)(ary.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 *)(ary.data() + sizeof(DataDs16FileHead));
        DsAbsItem * absDataPtr = pData;  //中间数据针步

        // 文件名称
        QString str = QString::fromLocal8Bit(pDsHead->fileName);
        QTextCodec * gbkCodec = QTextCodec::codecForName("GBK");
        QByteArray name;
        if (gbkCodec != NULL)
        {
            name = gbkCodec->fromUnicode(str);
        }
        else
        {
            name = str.toLocal8Bit();
        }
        //memcpy(fileName,pDsHead->fileName,sizeof(pDsHead->fileName));
        memcpy(fileName,name,name.size());

        int minx = absDataPtr->ax;
        int maxx = absDataPtr->ax;
        int miny = absDataPtr->ay;
        int maxy = absDataPtr->ay;

        int actx = 0;
        int acty = 0;
        int actr = 0;
        int beginx = 0;
        int beginy = 0;
        int beginr = 0;
        double absAr = 0;

        // 数据区
        qDebug()<<"stepsize:"<<stepsize;
        //static bool firstStep = true;
        //int firstXYFlag = 0;
        for (int j = 0; j < stepsize; j++)
        {
            u16 len;
            int ddx, ddy, ddr;

            Ds16Item ds16Item;
            memset(&ds16Item,0,sizeof(Ds16Item));//清空ds16针步

            u8 ctrlByte = absDataPtr->ctrl;
            u8 attrByte = absDataPtr->attr;//绝对数据的属性字节

            WORD actionWord = absDataPtr->action;

            double ax = absDataPtr->ax;//绝对数据的X位置
            double ay = absDataPtr->ay;
            double ar = absDataPtr->ar;

            //            qDebug()<< " index(absDataPtr->ar j ) : " << j << " : "<< absDataPtr->ar;

            // 轮廓
            if (minx > ax) { minx = ax; }
            if (maxx < ax) { maxx = ax; }
            if (miny > ay) { miny = ay; }
            if (maxy < ay) { maxy = ay; }

            if (j == 0)//第一针
            {
                beginx = ax;
                beginy = ay;
                beginr = ar;
                absAr += beginr;
                //qDebug()<<"absAr"<<absAr<<totalstepsize;

                actx = ax;
                acty = ay;
                actr = ar;

                ddx = 0;
                ddy = 0;
                //让ddr等于0，因为在datafiledsr中将beginR置为0而非第一针的角度，所以不应该用 absDataPtr->ar - pDsHead->beginR
                //如果beginR等于第一针的角度，那么第一针的ddr就应该是0
                ddr = 0;

                //过滤掉空针
//                if(ddx == 0 && ddy == 0 && ddr == 0)
//                {
//                    absDataPtr++;
//                    continue;
//                }
            }
            else
            {
                ddx = ax - actx;
                ddy = ay - acty;
                ddr = ar - actr;

                //起始角度，因为切刀的最初角度是0，如果第一个数据有坐标值变化，要算起始角度
//                if(firstXYFlag == 0 && (ddx != 0 || ddy != 0) && g_emMacType == MACHINE_CUTTINGWALK)
//                {
//                    double tar = atan2(ddy,ddx);
//                    beginr = (tar * 10000+0.5*(tar>0?1:-1));
//                    firstXYFlag = 1;
//                }
            }

            if( ctrlByte == DATA_END    ||
                    ctrlByte == DATA_PAUSE  ||
                    ctrlByte == DATA_CHGND  ||
                    ctrlByte == DATA_CUTTRD ||
                    ctrlByte == DATA_ANGLE ||
                    ctrlByte == DATA_SYNCOFST ||
                    0 )
            {
                ddx = 0;
                ddy = 0;
                ddr = 0;
            }

            s32 dx = ddx;
            s32 dy = ddy;
            s32 dr = ddr;

            actx += ddx;
            acty += ddy;
            actr += ddr;

            while (dr < -PI10000)
            {
                dr += PI20000;
            }
            while (dr > PI10000)
            {
                dr -= PI20000;
            }

            //剪线码必须有
            if (ctrlByte == DATA_END || ctrlByte == DATA_NULL)
            {
                dx = dy = dr = len = 0;
                // 增加剪线
                ds16Item.ctrl = DATA_CUTTRD;
                ds16Item.attr = 0;
                ds16Item.action[0] = 0;
                ds16Item.action[1] = 0;
                ds16Item.dx = 0;
                ds16Item.dy = 0;
                ds16Item.dr = 0;
                ds16Item.len = 0;
                memset(ds16Item.rev,0,sizeof(ds16Item.rev));

                tgtdsdat.append((char*)(&ds16Item), sizeof(Ds16Item));
                totalstepsize++;

                absAr += ds16Item.dr;
                //qDebug()<<"absAr"<<absAr<<dr<<totalstepsize;
            }

            //分割针步
            double maxStep = 2200.0;

            //多针机大于拟合针步大小（加100）时再分割，因为拐角补偿后针步可能会很大，需要分割，
            //这里加100是因为，如果不加100，很多超出一点的针步都会被分割
            if(g_emMacType == MACHINE_HIGHSPEEDSINGLEQUI || g_emMacType == MACHINE_FLYSHUTTLE ||
               g_emMacType == MACHINE_SINGLE_MUTIL_NEEDLE || g_emMacType == MACHINE_L2000_MULTI)
            {
                if(m_ritStepSize > 0)
                {
                    maxStep = m_ritStepSize + 100.0;
                }
            }

            //如果dx或dy数值太大时，平方会超出double范围，所以先都除以100再乘以10000
            double xyLen = sqrt((dx/100.0*dx/100.0)*10000.0+ (dy/100.0*dy/100.0)*10000.0);
            //if( 0 && xyLen > maxStep && ctrlByte == DATA_SEWING)
            if(xyLen > maxStep)
            {
                int addx{0},addy{0};

                //分割针步
                double splitVal = 400.0;//分割针步为400
                if(m_ritStepSize > 0)
                {
                    splitVal = m_ritStepSize;
                }

                s32 stepNum = xyLen / splitVal;//拆分几步

                double lastStep = (double)((int)xyLen % (int)splitVal);

                if(lastStep != 0)
                {
                    stepNum += 1;
                    splitVal = xyLen / stepNum;
                }

                for(int m = 0; m < stepNum; m++)
                {
                    double stepX = 0;
                    double stepY = 0;
                    double stepDr = 0;
                    memset(&ds16Item,0,sizeof(Ds16Item));//初始化结构体

                    stepX = dx * splitVal / xyLen;
                    stepY = dy * splitVal / xyLen;

                    if(m == 0)
                    {
                        stepDr = dr;
                    }

                    ds16Item.dx = qRound(stepX);//四舍五入
                    ds16Item.dy = qRound(stepY);

                    if (m == stepNum-1)
                    {// 最后一针,消除累计误差
                        ds16Item.dx = dx - addx;
                        ds16Item.dy = dy - addy;
                    }

                    addx += ds16Item.dx;
                    addy += ds16Item.dy;

                    ds16Item.ctrl = ctrlByte;
                    len = sqrt(ds16Item.dx*ds16Item.dx + ds16Item.dy*ds16Item.dy);
                    ds16Item.attr = attrByte;
                    ds16Item.action[0] = 0;
                    ds16Item.action[1] = 0;
                    ds16Item.dr = stepDr;
                    ds16Item.len = len;
                    memset(ds16Item.rev,0,sizeof(ds16Item.rev));
                    tgtdsdat.append((char*)(&ds16Item), sizeof(Ds16Item));
                    totalstepsize++;

                    absAr += ds16Item.dr;
                    //qDebug()<<"absAr"<<ds16Item.ctrl<<absAr<<ds16Item.dr<<totalstepsize;
                }
            }
            else
            {
                //粗线布线机,赋len的长度
                if((ctrlByte == DATA_SYNCOFST) && (g_emMacType == MACHINE_THICK_WIRING))
                {
                    memset((char*)&ds16Item,0,sizeof(ds16Item));
                    ds16Item.ctrl = DATA_SYNCOFST;
                    ds16Item.len = m_splitLen;
                }
                else
                {
                    len = sqrt(dx*dx + dy*dy);
                    ds16Item.ctrl = ctrlByte;
                    ds16Item.attr = attrByte;

                    memcpy(ds16Item.action,&actionWord,sizeof(actionWord));

                    ds16Item.dx = dx;
                    ds16Item.dy = dy;
                    ds16Item.dr = dr;
                    ds16Item.len = len;
                    memset(ds16Item.rev,0,sizeof(ds16Item.rev));
                }

                if(dx == 0 && dy == 0 && ctrlByte == DATA_MILLING)
                {

                }
                else
                {
                    tgtdsdat.append((char*)(&ds16Item), sizeof(Ds16Item));//ds16针步
                    totalstepsize++;

                    absAr += ds16Item.dr;
                    //qDebug()<<"absAr"<<ds16Item.ctrl<<absAr<<ds16Item.dr<<totalstepsize;
                }
            }

            if (ctrlByte == DATA_CHGND)
            {
                colornum++;
            }

            if (ctrlByte == DATA_OFFSET)
            {
                jumpNeedleNum++;//跨步总数加1
            }

            absDataPtr++;
        }

        if (m_minX > minx) { m_minX = minx; }
        if (m_minX > maxx) { m_minX = maxx; }
        if (m_maxX < minx) { m_maxX = minx; }
        if (m_maxX < maxx) { m_maxX = maxx; }
        if (m_minY > miny) { m_minY = miny; }
        if (m_minY > maxy) { m_minY = maxy; }
        if (m_maxY < miny) { m_maxY = miny; }
        if (m_maxY < maxy) { m_maxY = maxy; }

        // 针数
        int newstepnum = tgtdsdat.size() / sizeof(Ds16Item);

        if (newstepnum > 0)
        {
            // 修改文件头
//            int namelen = name.size();
//            if (namelen > HEAD_NAME_STR_LEN)
//            {
//                namelen = HEAD_NAME_STR_LEN;
//            }

//            QByteArray array = name.toLocal8Bit().data();
//            int asize = array.length();
            memcpy(m_pEmbDs16Head->fileName, fileName, sizeof(m_pEmbDs16Head->fileName));   // 文件名称
            m_pEmbDs16Head->dataSize = newstepnum*sizeof(Ds16Item);    // 数据字节数
            m_pEmbDs16Head->itemNums = newstepnum;                    // 数据项个数
            m_pEmbDs16Head->bytesPerItem = sizeof(Ds16Item);           // 每项占的字节数
            m_pEmbDs16Head->bytesPerBlk = MAX_EXDP_LEN;               // 数据内容划分块大小
            m_pEmbDs16Head->dataChecksum = calcCheckSum32((u8 *)(tgtdsdat.data()) , m_pEmbDs16Head->dataSize);	// 数据累加校验和
            m_pEmbDs16Head->checkCrc = calcCrc16((u8 *)(m_pEmbDs16Head), HEAD_FIX_INFO_LEN); // 前面6个字段的CRC校验，（6个字段分别为：文件名称，字节数，项个数，每项字节数，每块字节数，数据累加和的CRC校验值）
            m_pEmbDs16Head->fileid = m_pEmbDs16Head->checkCrc;

            m_pEmbDs16Head->anchorX = pDsHead->anchorX;            // 定位点坐标X
            m_pEmbDs16Head->anchorY = pDsHead->anchorY;            // 定位点坐标Y, 设置为0，作为基准
            m_pEmbDs16Head->beginX  = beginx;              // 数据起点坐标X
            m_pEmbDs16Head->beginY  = beginy;              // 数据起点坐标Y
            m_pEmbDs16Head->beginR  = beginr;              // 数据起点坐标R  //-rq
            m_pEmbDs16Head->minX    = minx;
            m_pEmbDs16Head->maxX    = maxx;
            m_pEmbDs16Head->minY    = miny;
            m_pEmbDs16Head->maxY    = maxy;                // 轮廓范围，使用重新计算之后的值
            qDebug() << "m_pEmbDs16Head->beginR " <<  m_pEmbDs16Head->beginR ;

            qDebug() << "--------m_pEmbDs16Head->beginX  = beginx " <<  m_pEmbDs16Head->beginX ;
            qDebug() << "--------m_pEmbDs16Head->beginY  = beginy " <<  m_pEmbDs16Head->beginY ;
            qDebug() << "--------m_pEmbDs16Head->minX    = minx; " << m_pEmbDs16Head->minX ;
            qDebug() << "--------m_pEmbDs16Head->maxX    = maxx; " << m_pEmbDs16Head->maxX ;
            qDebug() << "--------m_pEmbDs16Head->minY    = miny; " << m_pEmbDs16Head->minY ;
            qDebug() << "--------m_pEmbDs16Head->maxY    = maxy; " << m_pEmbDs16Head->maxY ;
            //中间数据的文件头

            // 添加文件头
            m_embDs16Data.append((char*)m_pEmbDs16Head, sizeof(DataDs16FileHead));//ds16头文件存在ds16中
            // 添加文件数据
            m_embDs16Data.append(tgtdsdat);
        }

#if(1)
        if(m_filePath.length() > 0)
        {
            //保存成ds16文件
            QString ds16FilePath = m_filePath + ".ds16";
            QFile file(ds16FilePath);

            if(file.exists())//存在ds16文件
            {
                QFile::remove(ds16FilePath);
            }

            if(!file.open(QIODevice::WriteOnly | QIODevice::Truncate))
            {
                qDebug() << "open file fail when wirte, path =" << m_filePath;
                return -1;
            }
            else
            {
                file.write(m_embDs16Data);
                file.close();
            }
        }
#endif
    }

    m_editedflag = 0;

    return 0;
}

int EmbData::createEmbDs16FromAbsDoubleHeadComb()
{
    if (m_editedflag != 0)
    {
        m_embDs16Data.clear();

        QByteArray tgtdsdat;
        tgtdsdat.clear();

        int colornum = 1;
        int jumpNeedleNum = 0;//跳针数
        int totalstepsize = 0;
        memset(m_pEmbDs16Head,0,sizeof(DataDs16FileHead));

        const QByteArray & ary = m_embAbsData;
        int size = ary.size();
        if (size <= (int)sizeof(DataDs16FileHead))
        {
            qDebug("ary data less then head size");
            return -1;
        }
        DataDs16FileHead * pDsHead = (DataDs16FileHead *)(ary.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 *)(ary.data() + sizeof(DataDs16FileHead));
        DsAbsItem * absDataPtr = pData;  //中间数据针步

        // 文件名称
        QString name = QString::fromLocal8Bit(pDsHead->fileName);

        //机头2与机头1的偏差
        double secOftX = pDsHead->beginX2 - pDsHead->beginX;
        double secOftY = pDsHead->beginY2 - pDsHead->beginY;

        int actx = 0;
        int acty = 0;
        int actr = 0;

        int actx2 = 0;
        int acty2 = 0;

        u8 preCtrlLeft,preCtrlRight;
        preCtrlLeft = preCtrlRight = 0;

        // 数据区
        qDebug()<<"stepsize:"<<stepsize;
        for (int j = 0; j < stepsize; j++)
        {
            u16 len;
            int ddx, ddy, ddr;

            Ds16Item ds16Item;
            memset(&ds16Item,0,sizeof(Ds16Item));//清空ds16针步

            u8 ctrlByte = absDataPtr->ctrl;
            u8 attrByte = absDataPtr->attr;//绝对数据的属性字节

            WORD actionWord = absDataPtr->action;

            double ax = absDataPtr->ax;//绝对数据的X位置
            double ay = absDataPtr->ay;
            double ar = absDataPtr->ar;

#if(0)
            if(j >= 1150)
            {
                int a = 0;
                a = 1;
            }
#endif

#if(0)
            if(ctrlByte == DATA_CUTTRD || ctrlByte == DATA_CUTTER_SEC || ctrlByte == DATA_SYNC_CUTTER || ctrlByte == DATA_MIRROR_OFT_SEC)
            {
                int a = 0;
                a = 1;
            }
#endif

#if(0)
            if(totalstepsize >= 2960)
            {
                int a = 0;
                a = 1;
            }
#endif

            if (j == 0)//第一针
            {
                //起始为第二机头数据
                if(ctrlByte == DATA_OFFSET_SEC || ctrlByte == DATA_SEWING_R)
                {
                    actx2 = ax;
                    acty2 = ay;

                    actx = ax - secOftX;//反着来
                    acty = ay + secOftY;
                }
                else
                {
                    actx = ax;
                    acty = ay;

                    actx2 = ax + secOftX;
                    acty2 = ay - secOftY;//因为双头组合机型Y数据方向取反了，所以这里用减
                }

                actr = ar;

                ddx = 0;
                ddy = 0;
                //让ddr等于0，因为在datafiledsr中将beginR置为0而非第一针的角度，所以不应该用 absDataPtr->ar - pDsHead->beginR
                //如果beginR等于第一针的角度，那么第一针的ddr就应该是0
                ddr = 0;

                //过滤掉空针
                if(ddx == 0 && ddy == 0)
                {
                    absDataPtr++;
                    actr = absDataPtr->ar;
                    continue;
                }
            }
            else
            {
                ddx = ax - actx;
                ddy = ay - acty;
                ddr = ar - actr;
            }

            int flag = 0;
            //左机头当前针步属性不为缝纫，且上一针步属性为缝纫时插入剪线码
            if(ctrlByte == DATA_OFFSET || ctrlByte == DATA_OFFSET_SEC || ctrlByte == DATA_SYNCOFST || ctrlByte == DATA_MIRROR_OFT_SEC)
            {
                if(preCtrlLeft == DATA_SEWING || preCtrlLeft == DATA_SYNCSEW || preCtrlLeft == DATA_MIRROR_SEC)
                {
                    Ds16Item *firstDs16Ptr = (Ds16Item*)(tgtdsdat.data());
                    Ds16Item *ds16Ptr = (Ds16Item*)(tgtdsdat.data() + tgtdsdat.size() - sizeof(Ds16Item));
                    int idx = 0;
                    while(1)
                    {
                        if(ds16Ptr <= firstDs16Ptr)
                        {
                            break;
                        }
                        if(ds16Ptr->ctrl == DATA_CUTTRD)
                        {
                            break;
                        }
                        if(ds16Ptr->ctrl == DATA_SEWING || ds16Ptr->ctrl == DATA_SYNCSEW || ds16Ptr->ctrl == DATA_MIRROR_SEC)
                        {
                            Ds16Item item;
                            memset(&item,0,sizeof(Ds16Item));
                            item.ctrl = DATA_CUTTRD;
                            tgtdsdat.insert(tgtdsdat.size()-idx*sizeof(Ds16Item),(char*)&item,sizeof(Ds16Item));
                            totalstepsize++;
                            flag |= 0x01;
                            break;
                        }
                        ds16Ptr--;
                        idx++;
                    }
                }
            }

            //右机头当前针步属性不为缝纫，且上一针步属性为缝纫时插入剪线码
            if(ctrlByte == DATA_OFFSET || ctrlByte == DATA_OFFSET_SEC || ctrlByte == DATA_SYNCOFST || ctrlByte == DATA_MIRROR_OFT_SEC)
            {
                if(preCtrlRight == DATA_SEWING_R || preCtrlRight == DATA_SYNCSEW || preCtrlRight == DATA_MIRROR_SEC)
                {
                    Ds16Item *firstDs16Ptr = (Ds16Item*)(tgtdsdat.data());
                    Ds16Item *ds16Ptr = (Ds16Item*)(tgtdsdat.data() + tgtdsdat.size() - sizeof(Ds16Item));
                    int idx = 0;
                    while(1)
                    {
                        if(ds16Ptr <= firstDs16Ptr)
                        {
                            break;
                        }
                        if(ds16Ptr->ctrl == DATA_CUTTER_SEC)
                        {
                            break;
                        }
                        if(ds16Ptr->ctrl == DATA_SEWING_R || ds16Ptr->ctrl == DATA_SYNCSEW || ds16Ptr->ctrl == DATA_MIRROR_SEC)
                        {
                            flag |= 0x02;

                            //都插入了剪线码
                            if(flag == 0x03)
                            {
                                Ds16Item *item = (Ds16Item *)(tgtdsdat.data() + tgtdsdat.size()-sizeof(Ds16Item));
                                while(1)
                                {
                                    if(item <= firstDs16Ptr)
                                    {
                                        break;
                                    }
                                    if(item->ctrl == DATA_SYNC_CUTTER)
                                    {
                                        break;
                                    }
                                    if(item->ctrl == DATA_CUTTRD)
                                    {
                                        item->ctrl = DATA_SYNC_CUTTER;
                                        preCtrlLeft = DATA_SYNC_CUTTER;
                                        preCtrlRight = DATA_SYNC_CUTTER;
                                        break;
                                    }
                                    item--;
                                }
                            }
                            else
                            {
                                Ds16Item item;
                                memset(&item,0,sizeof(Ds16Item));
                                item.ctrl = DATA_CUTTER_SEC;
                                tgtdsdat.insert(tgtdsdat.size()-idx*sizeof(Ds16Item),(char*)&item,sizeof(Ds16Item));
                                totalstepsize++;
                            }

                            break;
                        }
                        ds16Ptr--;
                        idx++;
                    }
                }
            }

            //第一机头偏移
            if(ctrlByte == DATA_OFFSET)
            {
                ddx = ax - actx;
                ddy = ay - acty;
            }

            //第一机头缝纫
            if(ctrlByte == DATA_SEWING)
            {
                ddx = ax - actx;
                ddy = ay - acty;
            }

            //第二机头偏移
            if(ctrlByte == DATA_OFFSET_SEC)
            {
                //                actx2 = ax;
                //                acty2 = ay;

                ddx = ax - actx2;
                ddy = ay - acty2;
            }

            //第二机头缝纫
            if(ctrlByte == DATA_SEWING_R)
            {
                ddx = ax - actx2;
                ddy = ay - acty2;
            }

            ddr = ar - actr;

            if( ctrlByte == DATA_END    ||
                    ctrlByte == DATA_PAUSE  ||
                    ctrlByte == DATA_CHGND  ||
                    ctrlByte == DATA_CUTTRD ||
                    ctrlByte == DATA_SYNC_CUTTER ||
                    ctrlByte == DATA_CUTTER_SEC ||
                    ctrlByte == DATA_ANGLE ||
                    0 )
            {
                if( ctrlByte == DATA_CUTTRD ||
                        ctrlByte == DATA_SYNC_CUTTER ||
                        ctrlByte == DATA_CUTTER_SEC ||
                        0 )
                {
#if(0)
                    //这段代码要注意，因为可能打版就打了剪线码，则这个剪线码就不能去掉
                    int rmFlag = 0;
                    DsAbsItem *  tempPtr = absDataPtr;
                    while(1)
                    {
                        if(tempPtr->ctrl != DATA_CUTTRD && tempPtr->ctrl != DATA_SYNC_CUTTER && tempPtr->ctrl != DATA_CUTTER_SEC)
                        {
                            tempPtr++;
                            if(tempPtr->ctrl != DATA_OFFSET && tempPtr->ctrl != DATA_SECF_OFST &&
                               tempPtr->ctrl != DATA_SYNCOFST && tempPtr->ctrl != DATA_MIRROR_OFT_SEC)
                            {
                                rmFlag = 1;
                            }
                            break;
                        }
                        tempPtr++;
                    }
                    if(rmFlag == 1)
                    {
                        //如果为剪线码，判断距离上一个点是否很接近，如果很接近，就不要把这个剪线码添加到ds16数据中，
                        //因为打版时会有左右机头打断的操作，就会插入剪线码，其实这个地方不需要剪线
                        double xyLen = sqrt((ddx/100.0*ddx/100.0)*10000.0+ (ddy/100.0*ddy/100.0)*10000.0);
                        if(xyLen <= 100)//小于等于1mm
                        {
                            absDataPtr++;
                            continue;
                        }
                    }
#endif
                }

                ddx = 0;
                ddy = 0;
                ddr = 0;
            }

            s32 dx = ddx;
            s32 dy = ddy;
            s32 dr = ddr;

            if(ctrlByte != DATA_OFFSET_SEC && ctrlByte != DATA_SEWING_R)
                //            if(ctrlByte == DATA_SEWING || ctrlByte == DATA_OFFSET ||
                //                    ctrlByte == DATA_SYNCOFST || ctrlByte == DATA_MIRROR_SEC ||
                //                    ctrlByte == DATA_MIRROR_OFT_SEC || ctrlByte == DATA_SYNCSEW)//左机头
            {
                actx += ddx;
                acty += ddy;
                actr += ddr;
            }

            if(ctrlByte != DATA_OFFSET && ctrlByte != DATA_SEWING)
                //            if(ctrlByte == DATA_SEWING_R || ctrlByte == DATA_OFFSET_SEC ||
                //                    ctrlByte == DATA_SYNCOFST || ctrlByte == DATA_MIRROR_SEC ||
                //                    ctrlByte == DATA_MIRROR_OFT_SEC || ctrlByte == DATA_SYNCSEW)//右机头
            {
                if(ctrlByte == DATA_MIRROR_SEC || ctrlByte == DATA_MIRROR_OFT_SEC)
                {
                    actx2 -= ddx;
                }
                else
                {
                    actx2 += ddx;
                }
                acty2 += ddy;
            }

            while (dr < -PI10000)
            {
                dr += PI20000;
            }
            while (dr > PI10000)
            {
                dr -= PI20000;
            }

            //如果为偏移针步，dx和dy都接近于0，则ds16数据不添加此针步
            if(ctrlByte == DATA_OFFSET || ctrlByte == DATA_OFFSET_SEC)
            {
                double xyLen = sqrt((dx/100.0*dx/100.0)*10000.0+ (dy/100.0*dy/100.0)*10000.0);
                if(xyLen <= m_oftNeedleSize)//小于等于
                {
                    absDataPtr++;
                    continue;
                }
            }

            //剪线码必须有-判断前一针不为剪线码时才加剪线码
            if (ctrlByte == DATA_END || ctrlByte == DATA_NULL)
            {
                absDataPtr--;
                u8 preCtrlByte = absDataPtr->ctrl;
                if(g_emMacType == MACHINE_DOUBLEHEADQUI || g_emMacType == MACHINE_FOURHEADQUI)
                {
                    if(preCtrlByte != DATA_SYNC_CUTTER)
                    {
                        dx = dy = dr = len = 0;
                        // 增加剪线
                        ds16Item.ctrl = DATA_SYNC_CUTTER;
                        ds16Item.attr = 0;
                        ds16Item.action[0] = 0;
                        ds16Item.action[1] = 0;
                        ds16Item.dx = 0;
                        ds16Item.dy = 0;
                        ds16Item.dr = 0;
                        ds16Item.len = 0;
                        memset(ds16Item.rev,0,sizeof(ds16Item.rev));

                        tgtdsdat.append((char*)(&ds16Item), sizeof(Ds16Item));
                        totalstepsize++;
                    }
                }
                else
                {
                    if(preCtrlByte != DATA_CUTTRD)
                    {
                        dx = dy = dr = len = 0;
                        // 增加剪线
                        ds16Item.ctrl = DATA_CUTTRD;
                        ds16Item.attr = 0;
                        ds16Item.action[0] = 0;
                        ds16Item.action[1] = 0;
                        ds16Item.dx = 0;
                        ds16Item.dy = 0;
                        ds16Item.dr = 0;
                        ds16Item.len = 0;
                        memset(ds16Item.rev,0,sizeof(ds16Item.rev));

                        tgtdsdat.append((char*)(&ds16Item), sizeof(Ds16Item));
                        totalstepsize++;
                    }
                }
                absDataPtr++;
            }

            //分割针步
            double maxStep = 800.0;
            //如果dx或dy数值太大时，平方会超出double范围，所以先都除以100再乘以10000
            double xyLen = sqrt((dx/100.0*dx/100.0)*10000.0+ (dy/100.0*dy/100.0)*10000.0);
            //if( 0 && xyLen > maxStep && ctrlByte == DATA_SEWING)
            if(xyLen > maxStep)
            {
                int addx{0},addy{0};

                //分割针步
                double splitVal = 400.0;//分割针步为400

                s32 stepNum = xyLen / splitVal;//拆分几步
                double lastStep = (double)((int)xyLen % (int)splitVal);
                double addStep = lastStep / stepNum;

                for(int m = 0; m < stepNum; m++)
                {
                    double stepX = 0;
                    double stepY = 0;
                    double stepDr = 0;
                    memset(&ds16Item,0,sizeof(Ds16Item));//初始化结构体

                    stepX = dx * splitVal / xyLen + dx * addStep / xyLen;
                    stepY = dy * splitVal / xyLen + dy * addStep / xyLen;

                    if(m == 0)
                    {
                        stepDr = dr;
                    }

                    ds16Item.dx = qRound(stepX);//四舍五入
                    ds16Item.dy = qRound(stepY);

                    if (m == stepNum-1)
                    {// 最后一针,消除累计误差
                        ds16Item.dx = dx - addx;
                        ds16Item.dy = dy - addy;
                    }

                    addx += ds16Item.dx;
                    addy += ds16Item.dy;

                    ds16Item.ctrl = ctrlByte;
                    len = sqrt(ds16Item.dx*ds16Item.dx + ds16Item.dy*ds16Item.dy);
                    ds16Item.attr = attrByte;
                    ds16Item.action[0] = 0;
                    ds16Item.action[1] = 0;
                    ds16Item.dr = stepDr;
                    ds16Item.len = len;
                    memset(ds16Item.rev,0,sizeof(ds16Item.rev));
                    tgtdsdat.append((char*)(&ds16Item), sizeof(Ds16Item));
                    totalstepsize++;
                }
            }
            else
            {
                len = sqrt(dx*dx + dy*dy);
                ds16Item.ctrl = ctrlByte;
                ds16Item.attr = attrByte;

                memcpy(ds16Item.action,&actionWord,sizeof(actionWord));

                ds16Item.dx = dx;
                ds16Item.dy = dy;
                ds16Item.dr = dr;
                ds16Item.len = len;
                memset(ds16Item.rev,0,sizeof(ds16Item.rev));

                if(dx == 0 && dy == 0 && ctrlByte == DATA_MILLING)
                {

                }
                else
                {
                    tgtdsdat.append((char*)(&ds16Item), sizeof(Ds16Item));//ds16针步
                    totalstepsize++;
                }
            }

            if (ctrlByte == DATA_CHGND)
            {
                colornum++;
            }

            if (ctrlByte == DATA_OFFSET || ctrlByte == DATA_SYNCOFST)
            {
                jumpNeedleNum++;//跨步总数加1
            }

            //第一机头的属性
            if(ctrlByte == DATA_SEWING || ctrlByte == DATA_OFFSET
                    || ctrlByte == DATA_SYNCSEW || ctrlByte == DATA_SYNCOFST ||
                    ctrlByte == DATA_MIRROR_SEC || ctrlByte == DATA_MIRROR_OFT_SEC || ctrlByte == DATA_SYNC_CUTTER || ctrlByte == DATA_CUTTRD)
            {
                preCtrlLeft = ctrlByte;
            }

            //第二机头的属性
            if(ctrlByte == DATA_SEWING_R || ctrlByte == DATA_OFFSET_SEC
                    || ctrlByte == DATA_SYNCSEW || ctrlByte == DATA_SYNCOFST ||
                    ctrlByte == DATA_MIRROR_SEC || ctrlByte == DATA_MIRROR_OFT_SEC || ctrlByte == DATA_SYNC_CUTTER || ctrlByte == DATA_CUTTER_SEC)
            {
                preCtrlRight = ctrlByte;
            }

            absDataPtr++;
        }

        // 针数
        int newstepnum = tgtdsdat.size() / sizeof(Ds16Item);

        if (newstepnum > 0)
        {
            // 修改文件头
            int namelen = name.size();
            if (namelen > HEAD_NAME_STR_LEN)
            {
                namelen = HEAD_NAME_STR_LEN;
            }

            QByteArray array = name.toLocal8Bit().data();
            int asize = array.length();
            memcpy(m_pEmbDs16Head->fileName, array, asize);   // 文件名称
            m_pEmbDs16Head->dataSize = newstepnum*sizeof(Ds16Item);    // 数据字节数
            m_pEmbDs16Head->itemNums = newstepnum;                    // 数据项个数
            m_pEmbDs16Head->bytesPerItem = sizeof(Ds16Item);           // 每项占的字节数
            m_pEmbDs16Head->bytesPerBlk = MAX_EXDP_LEN;               // 数据内容划分块大小
            m_pEmbDs16Head->dataChecksum = calcCheckSum32((u8 *)(tgtdsdat.data()) , m_pEmbDs16Head->dataSize);	// 数据累加校验和
            m_pEmbDs16Head->checkCrc = calcCrc16((u8 *)(m_pEmbDs16Head), HEAD_FIX_INFO_LEN); // 前面6个字段的CRC校验，（6个字段分别为：文件名称，字节数，项个数，每项字节数，每块字节数，数据累加和的CRC校验值）
            m_pEmbDs16Head->fileid = m_pEmbDs16Head->checkCrc;

            m_pEmbDs16Head->anchorX = pDsHead->anchorX;            // 定位点坐标X
            m_pEmbDs16Head->anchorY = pDsHead->anchorY;            // 定位点坐标Y, 设置为0，作为基准
            m_pEmbDs16Head->beginX  = pDsHead->beginX;              // 数据起点坐标X
            m_pEmbDs16Head->beginY  = pDsHead->beginY;              // 数据起点坐标Y
            m_pEmbDs16Head->beginR  = pDsHead->beginR;              // 数据起点坐标R
            m_pEmbDs16Head->beginX2  = pDsHead->beginX2;              // 数据起点坐标X
            m_pEmbDs16Head->beginY2  = pDsHead->beginY2;              // 数据起点坐标Y
            m_pEmbDs16Head->beginR2  = pDsHead->beginR2;              // 数据起点坐标R

            // 添加文件头
            m_embDs16Data.append((char*)m_pEmbDs16Head, sizeof(DataDs16FileHead));//ds16头文件存在ds16中
            // 添加文件数据
            m_embDs16Data.append(tgtdsdat);
        }

        //求边界范围
        calRange();

        //重新计算角度
        //求dr
        Ds16Item * ds16DataPtr;
        Ds16Item * pDsData = (Ds16Item *)(tgtdsdat.data());
        ds16DataPtr = pDsData;
        int dx,dy;
        double tar,ar;
        ar = 0;
        QList<double> arList;
        arList.clear();
        for (int i = 0; i < newstepnum; i++)
        {
            dx = ds16DataPtr->dx;
            dy = ds16DataPtr->dy;

            if(dx == 0 && dy == 0)
            {
                arList.append(ar);
            }
            else
            {
                tar = atan2(dy,dx);
                ar = (tar*10000+0.5*(tar>0?1:-1));
                arList.append(ar);
            }

            ds16DataPtr++;
        }

        double ar2,ar1;
        ar2 = ar1 = 0;
        ds16DataPtr = pDsData;
        for (int i = 0; i < newstepnum; i++)
        {
            ar2 = arList[i];
            if(i >= 1)
            {
                ar1 = arList[i-1];
            }

            if(i == 0)
            {
                ds16DataPtr->dr = ar2;
            }
            else
            {
                ds16DataPtr->dr = ar2-ar1;
            }

            if(ds16DataPtr->dx == 0 && ds16DataPtr->dy == 0)
            {
                ds16DataPtr->dr = 0;
            }

            while (ds16DataPtr->dr < -PI10000)
            {
                ds16DataPtr->dr += PI20000;
            }
            while (ds16DataPtr->dr > PI10000)
            {
                ds16DataPtr->dr -= PI20000;
            }

            ds16DataPtr++;
        }

        m_pEmbDs16Head->maxX = m_maxX;
        m_pEmbDs16Head->minX = m_minX;
        m_pEmbDs16Head->maxY = m_maxY;
        m_pEmbDs16Head->minY = m_minY;
        m_embDs16Data.clear();
        m_embDs16Data.append((char*)m_pEmbDs16Head, sizeof(DataDs16FileHead));//ds16头文件存在ds16中
        m_embDs16Data.append(tgtdsdat);

#if(1)
        if(m_filePath.length() > 0)
        {
            //保存成ds16文件
            QString ds16FilePath = m_filePath + ".ds16";
            QFile file(ds16FilePath);

            if(file.exists())//存在ds16文件
            {
                QFile::remove(ds16FilePath);
            }

            if(!file.open(QIODevice::WriteOnly | QIODevice::Truncate))
            {
                qDebug() << "open file fail when wirte, path =" << m_filePath;
                return -1;
            }
            else
            {
                file.write(m_embDs16Data);
                file.close();
            }
        }
#endif
    }

    m_editedflag = 0;

    return 0;
}

void EmbData::calRange()
{
    //求最大最小值范围
    m_minX = S32_MAX;
    m_maxX = S32_MIN;
    m_minY = S32_MAX;
    m_maxY = S32_MIN;

    const QByteArray & arry = m_embDs16Data;
    int size = arry.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("16 data less then head size");
        return;
    }
    DataDs16FileHead *pDsHead = (DataDs16FileHead *)(arry.data());
    int datasize = size - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        qDebug("dat dataBegin err");
        return;
    }
    int stepsize = datasize/sizeof(Ds16Item);
    if (stepsize <= 0)
    {
        qDebug("ds16 data size err");
        return;
    }

    Ds16Item * ds16DataPtr;
    Ds16Item * pDsData = (Ds16Item *)(arry.data() + sizeof(DataDs16FileHead));
    ds16DataPtr = pDsData;

    int secOftX = pDsHead->beginX2 - pDsHead->beginX;
    int secOftY = pDsHead->beginY2 - pDsHead->beginY;

    u8 ctrl = 0;
    double ax,ay,ax2,ay2;
    ax = ay = 0;
    ax2 = secOftX;
    ay2 = 0 - secOftY;//因为双头组合机型Y数据方向取反了，所以这里用减

    for (int i = 0; i < stepsize; i++)
    {
        ctrl = ds16DataPtr->ctrl;

        if(ctrl == DATA_NULL)
        {
            break;
        }

        if(ctrl != DATA_OFFSET_SEC && ctrl != DATA_SEWING_R)
        {
            ax += ds16DataPtr->dx;
            ay += ds16DataPtr->dy;
        }

        if(ctrl != DATA_OFFSET && ctrl != DATA_SEWING)
        {
            if(ctrl == DATA_MIRROR_SEC || ctrl == DATA_MIRROR_OFT_SEC)
            {
                ax2 = ax2 + (ds16DataPtr->dx * -1);
                ay2 += ds16DataPtr->dy;
            }
            else
            {
                ax2 += ds16DataPtr->dx;
                ay2 += ds16DataPtr->dy;
            }
        }

        if (m_minX > ax) { m_minX = ax; }
        if (m_maxX < ax) { m_maxX = ax; }
        if (m_minX > ax2) { m_minX = ax2; }
        if (m_maxX < ax2) { m_maxX = ax2; }

        if (m_minY > ay) { m_minY = ay; }
        if (m_maxY < ay) { m_maxY = ay; }
        if (m_minY > ay2) { m_minY = ay2; }
        if (m_maxY < ay2) { m_maxY = ay2; }

        ds16DataPtr++;
    }
}

int EmbData::reCalcDataChecksum()
{
    return 0;
}

//绘制针数索引的跟踪笔
void EmbData::drawNeedleIdxPen(int x, int y, QPainter &painter)
{
    //贴图的xy和画笔的xy值相同
    m_penX = x;
    m_penY = y;

    m_penPix = m_canvas.copy(x-20,y-30,40,40);//复制画笔区域未绘制笔之前的图像

    QPen pen;
    QColor color;

    //绘制深灰色画笔
    pen.setWidth(2);
    color.setRgb(60,60,60);//深灰色
    pen.setColor(color);
    painter.setPen(pen);

    painter.drawLine(x-4, y-28, x-4, y-8);//画左"|"
    painter.drawLine(x+4, y-28, x+4, y-8); //画右"|"
    painter.drawEllipse(x-1, y-10, 2, 2);//画中心"°"
    painter.drawLine(x-4, y-8, x, y);//画左"\"(笔尖)
    painter.drawLine(x+4, y-8, x, y); //画右"/"(笔尖)

    //绘制深红色画笔
    pen.setWidth(1);
    color.setRgb(174,60,64);//深红色
    pen.setColor(color);
    painter.setPen(pen);

    painter.drawLine(x-3, y-28, x-3, y-8);//画左"|"
    painter.drawLine(x+5, y-28, x+5, y-8); //画右"|"
    painter.drawEllipse(x-2, y-12, 3, 3);//画中心"°"
    painter.drawLine(x-3, y-8, x, y);//画左"\"(笔尖)
    painter.drawLine(x+5, y-8, x, y); //画右"/"(笔尖)
}

void EmbData::drawFork(int x, int y, QPainter &painter)
{
    //贴图的xy和画笔的xy值相同
    m_penX = x;
    m_penY = y;

    m_penPix = m_canvas.copy(x-20,y-30,40,40);//复制画笔区域未绘制笔之前的图像

    QPen pen;
    QColor color;

    //绘制深灰色画笔
    pen.setWidth(2);
    color.setRgb(228,42,48);
    pen.setColor(color);
    painter.setPen(pen);

    painter.drawLine(x-8, y-8, x-3, y-3);//   \上一半
    painter.drawLine(x+8, y-8, x+3, y-3);//   /上一半

    painter.drawLine(x+3, y+3, x+8, y+8);
    painter.drawLine(x-3, y+3, x-8, y+8);
}

/**
 * @brief 绘制多头机的跟踪标致
 */
void EmbData::drawFork(int x, int y, QPainter &painter, int index)
{
    m_penPoint[index].setX(x);
    m_penPoint[index].setY(y);

    m_penHeadPix[index] = m_canvas.copy(x-20,y-30,40,40);//复制画笔区域未绘制笔之前的图像

    QPen pen;
    QColor color;

    //绘制深灰色画笔
    pen.setWidth(2);
    color.setRgb(228,42,48);
    pen.setColor(color);
    painter.setPen(pen);

    painter.drawLine(x-8, y-8, x-3, y-3);//   \上一半
    painter.drawLine(x+8, y-8, x+3, y-3);//   /上一半

    painter.drawLine(x+3, y+3, x+8, y+8);
    painter.drawLine(x-3, y+3, x-8, y+8);
}

void EmbData::drawForkDoubleHead(int x, int y, int x2, int y2, QPainter &painter)
{
    //贴图的xy和画笔的xy值相同
    m_penX = x;
    m_penY = y;

    m_penXY2.setX(x2);
    m_penXY2.setY(y2);

    m_penPix = m_canvas.copy(x-20,y-30,40,40);//复制画笔区域未绘制笔之前的图像
    m_penPix2 = m_canvas.copy(x2-20,y2-30,40,40);//复制画笔区域未绘制笔之前的图像

    QPen pen;
    QColor color;

    //绘制深灰色画笔
    pen.setWidth(2);
    color.setRgb(228,42,48);
    pen.setColor(color);
    painter.setPen(pen);

    painter.drawLine(x-8, y-8, x-3, y-3);//   \上一半
    painter.drawLine(x+8, y-8, x+3, y-3);//   /上一半

    painter.drawLine(x+3, y+3, x+8, y+8);
    painter.drawLine(x-3, y+3, x-8, y+8);

    painter.drawLine(x2-8, y2-8, x2-3, y2-3);//   \上一半
    painter.drawLine(x2+8, y2-8, x2+3, y2-3);//   /上一半

    painter.drawLine(x2+3, y2+3, x2+8, y2+8);
    painter.drawLine(x2-3, y2+3, x2-8, y2+8);
}

//擦除针数索引的跟踪笔
void EmbData::eraseNeedleIdxPen(QPainter &painter)
{
    //贴图的xy和画笔的xy值相同
    painter.drawPixmap(m_penX-20,m_penY-30,m_penPix);
}

void EmbData::eraseNeedleIdxPen(QPainter &painter, int index)
{
    painter.drawPixmap(m_penPoint[index].x()-20,m_penPoint[index].y()-30,m_penHeadPix[index]);
}

void EmbData::eraseNeedleIdxPenDoubleHead(QPainter &painter)
{
    //贴图的xy和画笔的xy值相同
    painter.drawPixmap(m_penX-20,m_penY-30,m_penPix);
    painter.drawPixmap(m_penXY2.x()-20,m_penXY2.y()-30,m_penPix2);
}

bool EmbData::isFlipDispYMac()
{
    if(g_emMacType == MACHINE_THICK_WIRING     ||
            g_emMacType == MACHINE_FLYSHUTTLE       ||
            g_emMacType == MACHINE_GLASSFIBRE       ||
            g_emMacType == MACHINE_DOUBLE_LAYERED   ||
            g_emMacType == MACHINE_L2000_MULTI      ||
            g_emMacType == MACHINE_AutoDoubleDoor   ||
            g_emMacType == MACHINE_FULLYAUTOMATIC   ||
            g_emMacType == MACHINE_HIGHSPEEDSINGLEQUI ||
            g_emMacType == MACHINE_DOUBLEHEADQUI ||
            g_emMacType == MACHINE_CUTTINGWALK ||
            g_emMacType == MACHINE_FOURHEADQUI)
        return true;
    else
        return false;
}

bool EmbData::isFlipDispXMac()
{
    return false;
}

void EmbData::getCurvePointFillLine(QList<DsAbsItem> &inList, double indRunLen, QList<DsAbsItem> &outList)
{
    DsAbsItem dPoint1, dPoint2, dPoint3;
    double dTatol, dLen1, dLen2, dSpace;
    long lSum, lCount;

    //计算总的线段长
    int iCountPoint = inList.size();
    if(iCountPoint <= 0)
    {
        return;
    }

    getTotalDistanceFillLine(&inList, dTatol);
    if(dTatol == 0)
        return;

    lSum = (long)round(dTatol / indRunLen + 0.1667);
    dSpace = dTatol / (double)lSum;
    if(lSum == 0)
        lSum = 1;

    dPoint1 = inList[0];
    outList.append(dPoint1);//添加第一个点
    dPoint2 = dPoint1;

    dLen1 = dSpace;
    dLen2 = 0;
    int i = 0;
    for(lCount = 0; lCount < lSum; lCount++)
    {
        while(i < inList.size()-1 && dLen2 < dLen1)
        {
            dLen1 -= dLen2;
            dPoint1 = dPoint2;
            i++;
            dPoint2 = inList[i];
            dLen2 = sqrt((dPoint1.ax - dPoint2.ax) * (dPoint1.ax - dPoint2.ax) + (dPoint1.ay - dPoint2.ay) * (dPoint1.ay - dPoint2.ay));
            if(dPoint2.ctrl == DATA_CUTTRD || dPoint2.ctrl == DATA_SYNC_CUTTER || dPoint2.ctrl == DATA_CUTTER_SEC)
            {
                //为剪线码时退出并添加此针步
                break;
            }
        }
        if(dLen1 < dLen2)
        {
            getPointInSectFillLine(dPoint1, dPoint2, dLen1, dPoint3);
        }
        else
        {
            dPoint3 = dPoint2;
        }
        outList.append(dPoint3);
        dLen2 -= dLen1;
        dLen1 = dSpace;
        dPoint1 = dPoint3;
    }
}

int EmbData::getTotalDistanceFillLine(QList<DsAbsItem> *pPointList, double &dTotal)
{
    DsAbsItem dPoint, dNext;
    double d;
    dTotal = 0;
    int i = 0;
    long lSum = (long)pPointList->count();
    if(lSum > 1)
    {
        while(i < pPointList->size())
        {
            dPoint = pPointList->at(i);
            i++;
            if(i < pPointList->size())
            {
                dNext = pPointList->at(i);
                d =  sqrt((dPoint.ax - dNext.ax) * (dPoint.ax - dNext.ax) + (dPoint.ay- dNext.ay) * (dPoint.ay- dNext.ay));
                dTotal += d;
            }
            else
            {
                break;
            }
        }
    }
    return 0;
}

bool EmbData::getPointInSectFillLine(const DsAbsItem &p1, const DsAbsItem &p2, const double &d, DsAbsItem &outp)
{
    bool bRes;
    DsAbsItem dpoint[3];

    dpoint[0] = p1;
    dpoint[1] = p2;
    dpoint[2] = outp;
    outp = dpoint[1];

    bRes = getPointAtSect(dpoint[0], dpoint[1], d, dpoint[2]);
    outp.ax = dpoint[2].ax;
    outp.ay = dpoint[2].ay;

    return bRes;
}

bool EmbData::getPointAtSect(const DsAbsItem &p1, const DsAbsItem &p2, const double &d, DsAbsItem &outp)
{
    double s = sqrt((p1.ax - p2.ax) * (p1.ax - p2.ax) + (p1.ay - p2.ay) * (p1.ay - p2.ay));
    if(fabs(s) < ZERO)
    {
        if(d < ZERO)
        {
            outp.ax = p1.ax;
            outp.ay = p1.ay;
        }
        return false;
    }
    outp.ax = (p2.ax - p1.ax) * d / s + p1.ax;
    outp.ay = (p2.ay - p1.ay) * d / s + p1.ay;

    return true;
}

bool EmbData::checkData(int size)
{
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("ary data less then head size");
        return false;
    }
    int datasize = size - sizeof(DataDs16FileHead);
    int stepsize = datasize/sizeof(DsAbsItem);
    if (stepsize <= 0)
    {
        qDebug("dat data size err");
        return false;
    }
    return true;
}

//设置视图尺寸(透明背景)
int EmbData::setViewInfo(int width, int height)
{
    //    if (m_viewWidth != width ||
    //        m_viewHight != height)
    {
        if (width <= EMB_PREVIEW_SIDE*2 || height <= EMB_PREVIEW_SIDE*2)
        {
            return -1;
        }
        m_viewWidth = width;
        m_viewHight = height;
        m_canvas = QPixmap(m_viewWidth, m_viewHight);
        m_canvas.fill(Qt::transparent);//用透明色填充
        //memset(m_canvas.bits(), 0x00, m_canvas.byteCount());
    }
    return 0;
}

//设置视图(带背景图片背景)
void EmbData::setViewInfo(QPixmap pix)
{
    m_canvas = pix;
}

//重置数据
void EmbData::setEmbData(int type, int redraw)
{
    m_type = type;
    createDispFromEmbDs16Dat(m_embDs16Data);
    if (redraw != 0)
    {
        drawImageByDispFile();
    }
}

void EmbData::setDispMode(EmbData::DISP_MODE dispmode, int redraw)
{
    m_dispMode = dispmode;
    if(redraw != 0)
    {
        drawImageByDispFile();
    }
}

void EmbData::setDrawMode(EmbData::DRAW_MODE drawmode)
{
    m_drawMode = drawmode;
}

//设置进度显示数据
void EmbData::setExecIndex(int index)
{
    m_stitchIndex = index;

    if(g_emMacType == MACHINE_FLYSHUTTLE || g_emMacType == MACHINE_L2000_MULTI)
    {
        //实时刷新最后一个图形
        int num = m_dispDat.size() / sizeof(DispItem);
        num -= m_pEmbDs16Head->itemNums;
        num += index;
        m_stitchIndex = num;
    }

    if (m_dispMode == DISP_EXECING)
    {
        drawImageByDispFile();
    }
}

void EmbData::reDraw()
{
    drawImageByDispFile();
}

//创建显示用的数据（为了快速显示）
int EmbData::createDispFromEmbDs16Dat(QByteArray &ds16dat)
{
    if(m_type == MACHINE_FIVEHEADPRECISIONSEWING)
        return createDispFromEmbDs16DatForHeadInfo(ds16dat);

    if(m_type == MACHINE_DOUBLEHEADQUI || g_emMacType == MACHINE_FOURHEADQUI)
        return createDispFromEmbDs16DatDoubleHeadComb(ds16dat);

    DispItem dispItem;
    m_dispDat.clear();//显示绘图用的数据（需要转换）

    //    DsAbsItem absItem;//用于轮廓提取的绝对坐标值
    //    m_ds16ToAbsDat.clear();//用于轮廓提取的绝对坐标值

    m_stitchIndex = 0;
    m_dispIndex = 0;

    // ds16数据
    int size = ds16dat.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("16 data less then head size");
        return -1;
    }
    DataDs16FileHead * pDsHead = (DataDs16FileHead *)(ds16dat.data());
    int datasize = size - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        qDebug("dat dataBegin err");
        return -1;
    }
    int stepsize = datasize/sizeof(Ds16Item);
    if (stepsize <= 0)
    {
        qDebug("ds16 data size err");
        return -1;
    }

    Ds16Item * ds16DataPtr;
    Ds16Item * pData = (Ds16Item *)(ds16dat.data() + sizeof(DataDs16FileHead));
    ds16DataPtr = pData;

    // 图形显示区域
    int width = m_canvas.width();//留4个像素的边
    int height = m_canvas.height();//留4个像素的边

    if (width <= EMB_PREVIEW_SIDE*2 || height <= EMB_PREVIEW_SIDE*2)
    {
        qDebug("preview img too small");
        return -1;
    }

    //留边(否则实时跟踪笔会画出界)
    int viewSide = EMB_PREVIEW_SIDE;
    if(m_drawMode == DRAW_PREVIEW)
    {
        viewSide = 20;//预览模式时整区域留20像素绘制(原色显示)
    }
    int dpminx = viewSide;
    int dpmaxx = width - viewSide;
    int dpminy = viewSide;
    int dpmaxy = height - viewSide;

    //1:1显示无需留边
    //    int dpminx = 0;
    //    int dpmaxx = width;
    //    int dpminy = 0;
    //    int dpmaxy = height;

    // 计算缩放系数
    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);      // 按框尺寸y计算的缩放系数

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

    m_factor = factor;

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

    // 显示花样图形
    u8 ctrlByte;
    u8 attrByte;
    int dx;
    int dy;
    int dr;

    double datposx, datposy, datposr;
    int curx, cury, curr, prex, prey;
    curx = cury = curr = prex = prey = 0;

    datposx = pDsHead->beginX;
    datposy = pDsHead->beginY;
    datposr = pDsHead->beginR;

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

    if(isFlipDispYMac())
    {
        emb_showDirY = -1;
    }

    if(isFlipDispXMac())
    {
        emb_showDirX = -1;
    }

    if (emb_showDirX == -1)
    {
        curx = width - curx;
    }
    if (emb_showDirY == -1)
    {
        cury = height - cury;
    }

    for (int i = 0; i < stepsize; i++)
    {
        prex = curx;
        prey = cury;

        // 读入一个针步数据
        ctrlByte = ds16DataPtr->ctrl;
        attrByte = ds16DataPtr->attr;
        dx = ds16DataPtr->dx;
        dy = ds16DataPtr->dy;
        dr = ds16DataPtr->dr;

        datposx += dx;
        datposy += dy;
        datposr += dr;

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

        if (emb_showDirX == -1)
        {
            curx = width - curx;
        }
        if (emb_showDirY == -1)
        {
            cury = height - cury;
        }

        while(datposr >= PI10000)
        {
            datposr -= (PI20000-1);
        }
        while(datposr <= -PI10000)
        {
            datposr += (PI20000-1);
        }

        dispItem.ctrl = ctrlByte;
        dispItem.attr = attrByte;
        dispItem.bx = prex;
        dispItem.by = prey;
        dispItem.ex = curx;
        dispItem.ey = cury;
        dispItem.ar = curr;

        if(g_emMacType == MACHINE_CUTTINGWALK)
        {
            //边走边裁
            if(ctrlByte ==DATA_OFFSET) //跨步(偏移)针步另一种颜色显示
                dispItem.rgb = Qt::transparent;
            if(ctrlByte ==DATA_DRAWING) //画笔
                dispItem.rgb = qRgb(240,155,89);
            else if(ctrlByte ==DATA_RKNIFE)//圆刀
                dispItem.rgb = qRgb(0,128,255);
            else if(ctrlByte ==DATA_SKNIFE)//震刀
                dispItem.rgb = qRgb(0x35,0xC0,0x5C);
        }
        else
        {
            if(ctrlByte == DATA_OFFSET) //跨步(偏移)针步另一种颜色显示
                dispItem.rgb = getJumpedColour();
            else
                dispItem.rgb = getSewedColour();
        }

        memcpy(&dispItem.action,ds16DataPtr->action,sizeof(dispItem.action));

        m_dispDat.append((char*)(&dispItem), sizeof(DispItem));

        ds16DataPtr++;
    }

    qDebug("CreateDispFromEmbDs16, stepsize=%d", m_dispDat.size() / sizeof(DispItem));

    return 0;
}

/**
 * @brief EmbData::五头机创建绘图数据
 * @param ds16dat
 * @return
 */
int EmbData::createDispFromEmbDs16DatForHeadInfo(QByteArray &ds16dat)
{
    m_headDispDate.clear();

    DataFileDsr dsr;//可能引起栈内存溢出的问题
    dsr.initFile(m_filePath);
    dsr.convertDataToEmbAbs();
    DsrHeadEx62 head = dsr.get62ExHead();
    int StepNum = dsr.getStepNums();
    int maxHSP = findMaxSpHead(head,StepNum);

    Disp_HeadItem dispItem;
    m_dispDat.clear();//显示绘图用的数据（需要转换）

    m_stitchIndex = 0;
    m_dispIndex = 0;

    // ds16数据
    int size = ds16dat.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("16 data less then head size");
        return -1;
    }
    DataDs16FileHead * pDsHead = (DataDs16FileHead *)(ds16dat.data());
    int datasize = size - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        qDebug("dat dataBegin err");
        return -1;
    }
    int stepsize = datasize/sizeof(Ds16Item);
    if (stepsize <= 0)
    {
        qDebug("ds16 data size err");
        return -1;
    }

    Ds16Item * ds16DataPtr;
    Ds16Item * pData = (Ds16Item *)(ds16dat.data() + sizeof(DataDs16FileHead));
    ds16DataPtr = pData;

    // 图形显示区域
    int width = m_canvas.width();//留4个像素的边
    int height = m_canvas.height();//留4个像素的边
    if (width <= EMB_PREVIEW_SIDE*2 || height <= EMB_PREVIEW_SIDE*2)
    {
        qDebug("preview img too small");
        return -1;
    }

    //留边(否则实时跟踪笔会画出界)
    int viewSide = EMB_PREVIEW_SIDE;
    if(m_drawMode == DRAW_PREVIEW)
    {
        viewSide = 20;//预览模式时整区域留20像素绘制(原色显示)
    }
    int dpminx = viewSide;
    int dpmaxx = width - viewSide;
    int dpminy = viewSide;
    int dpmaxy = height - viewSide;

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

    factor = (double)(fabs(m_maxX+(maxHSP*10)-m_minX)) / (dpmaxx - dpminx);      // 按框尺寸x计算的缩放系数 五头机加上一个最大值保证绘图不越界
    temp =   (double)(fabs(m_maxY-m_minY)) / (dpmaxy - dpminy);      // 按框尺寸y计算的缩放系数
    // 使用较大的缩放系数
    factor = temp >= factor?temp:factor;
    m_factor = factor;

    // 计算显示参数，按照图形的实际位置显示（数据坐标零点对应图形中心）
    int dpx = (int)((dpminx+dpmaxx)/2 - ((m_maxX+m_minX+(maxHSP*10))/factor)/2);//最大x需要 五头机加上一个最大值保证绘图不越界
    int dpy = (int)((dpminy+dpmaxy)/2 - ((m_maxY+m_minY)/factor)/2);

    // 显示花样图形

    double datposx = pDsHead->beginX;
    double datposy = pDsHead->beginY;

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

    if (emb_showDirX == -1)
    {
        curx = width - curx;
    }
    if (emb_showDirY == -1)
    {
        cury = height - cury;
    }

    for (int i = 0; i < stepsize; i++)
    {
        int prex = curx;
        int prey = cury;

        // 读入一个针步数据
        int dx = ds16DataPtr->dx;
        int dy = ds16DataPtr->dy;
        unsigned short int headSpHndex = ds16DataPtr->action[1] & 0xFF;

        datposx += dx;
        datposy += dy;

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

        if (emb_showDirX == -1)
        {
            curx = width - curx;
        }
        if (emb_showDirY == -1)
        {
            cury = height - cury;
        }

        dispItem.ctrl = ds16DataPtr->ctrl;
        dispItem.attr = ds16DataPtr->attr;
        dispItem.bx = prex;
        dispItem.by = prey;
        dispItem.ex = curx;
        dispItem.ey = cury;
        dispItem.ar = ds16DataPtr->dr;
        memcpy(&dispItem.action,ds16DataPtr->action,2);
        dispItem.headtable.iswork = head.headEnableSpacing[headSpHndex].iswork;
        dispItem.headtable.distance1_2 = head.headEnableSpacing[headSpHndex].distance1_2;
        dispItem.headtable.distance1_3 = head.headEnableSpacing[headSpHndex].distance1_3;
        dispItem.headtable.distance1_4 = head.headEnableSpacing[headSpHndex].distance1_4;
        dispItem.headtable.distance1_5 = head.headEnableSpacing[headSpHndex].distance1_5;
        dispItem.headtable.distance1_6 = head.headEnableSpacing[headSpHndex].distance1_6;
        dispItem.headtable.distance1_7 = head.headEnableSpacing[headSpHndex].distance1_7;
        dispItem.headtable.distance1_8 = head.headEnableSpacing[headSpHndex].distance1_8;
        if(ds16DataPtr->ctrl ==DATA_OFFSET) //跨步(偏移)针步另一钟颜色显示
            dispItem.rgb = getNoJumpColour();
        else
            dispItem.rgb = getNoSewColour();

        m_headDispDate.append(dispItem);

        ds16DataPtr++;
    }

    qDebug() << "createDispFromEmbDs16DatForHeadInfo"<< "CreateDispFromEmbDs16, stepsize="<< m_headDispDate.size();

    return 0;
}

int EmbData::createDispFromEmbDs16DatDoubleHeadComb(QByteArray &ds16dat)
{
    DispItem dispItem;
    m_dispDat.clear();//显示绘图用的数据（需要转换）

    //    DsAbsItem absItem;//用于轮廓提取的绝对坐标值
    //    m_ds16ToAbsDat.clear();//用于轮廓提取的绝对坐标值

    m_stitchIndex = 0;
    m_dispIndex = 0;

    // ds16数据
    int size = ds16dat.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("16 data less then head size");
        return -1;
    }
    DataDs16FileHead * pDsHead = (DataDs16FileHead *)(ds16dat.data());
    int datasize = size - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        qDebug("dat dataBegin err");
        return -1;
    }
    int stepsize = datasize/sizeof(Ds16Item);
    if (stepsize <= 0)
    {
        qDebug("ds16 data size err");
        return -1;
    }

    Ds16Item * ds16DataPtr;
    Ds16Item * pData = (Ds16Item *)(ds16dat.data() + sizeof(DataDs16FileHead));
    ds16DataPtr = pData;

    // 图形显示区域
    int width = m_canvas.width();//留4个像素的边
    int height = m_canvas.height();//留4个像素的边

    if (width <= EMB_PREVIEW_SIDE*2 || height <= EMB_PREVIEW_SIDE*2)
    {
        qDebug("preview img too small");
        return -1;
    }

    //留边(否则实时跟踪笔会画出界)
    int viewSide = EMB_PREVIEW_SIDE;
    if(m_drawMode == DRAW_PREVIEW)
    {
        viewSide = 20;//预览模式时整区域留20像素绘制(原色显示)
    }
    int dpminx = viewSide;
    int dpmaxx = width - viewSide;
    int dpminy = viewSide;
    int dpmaxy = height - viewSide;

    //1:1显示无需留边
    //    int dpminx = 0;
    //    int dpmaxx = width;
    //    int dpminy = 0;
    //    int dpmaxy = height;

    // 计算缩放系数
    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);      // 按框尺寸y计算的缩放系数

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

    m_factor = factor;

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

    if(isFlipDispYMac())
    {
        emb_showDirY = -1;
    }

    if(isFlipDispXMac())
    {
        emb_showDirX = -1;
    }

    double secOftX = pDsHead->beginX2 - pDsHead->beginX;
    double secOftY = pDsHead->beginY2 - pDsHead->beginY;

    qDebug()<<"secOftX"<<secOftX<<"secOftY"<<secOftY;

    // 显示花样图形
    u8 ctrlByte;
    u8 attrByte;
    int dx;
    int dy;
    int dr;

    double datposx, datposy, datposx2, datposy2, datposr;
    int curx, cury, curr, prex, prey;
    curx = cury = curr = prex = prey = 0;
    int curx2, cury2, prex2, prey2;
    curx2 = cury2 = prex2 = prey2 = 0;

    datposx = 0;
    datposy = 0;

    datposx2 = secOftX*emb_showDirX;
    datposy2 = secOftY*emb_showDirY;

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

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

    if (emb_showDirX == -1)
    {
        curx = width - curx;
        curx2 = width - curx2;
    }
    if (emb_showDirY == -1)
    {
        cury = height - cury;
        cury2 = height - cury2;
    }

    prex = curx;
    prey = cury;

    prex2 = curx2;
    prey2 = cury2;

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

        if(ctrlByte != DATA_OFFSET_SEC && ctrlByte != DATA_SEWING_R)//非右机头偏移和缝纫
        {
            prex = curx;
            prey = cury;

            dx = ds16DataPtr->dx;
            dy = ds16DataPtr->dy;

            datposx += dx;
            datposy += dy;
            datposr += dr;

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

            if (emb_showDirX == -1)
            {
                curx = width - curx;
            }
            if (emb_showDirY == -1)
            {
                cury = height - cury;
            }
        }

        if(ctrlByte != DATA_OFFSET && ctrlByte != DATA_SEWING)//非左机头偏移
        {
            prex2 = curx2;
            prey2 = cury2;

            dx = ds16DataPtr->dx;
            dy = ds16DataPtr->dy;

            if(ctrlByte == DATA_MIRROR_SEC || ctrlByte == DATA_MIRROR_OFT_SEC)
            {
                datposx2 = datposx2 + dx*-1;
                datposy2 += dy;
            }
            else
            {
                datposx2 += dx;
                datposy2 += dy;
            }

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

            if (emb_showDirX == -1)
            {
                curx2 = width - curx2;
            }
            if (emb_showDirY == -1)
            {
                cury2 = height - cury2;
            }
        }

#if(0)
        while(datposr >= PI10000)
        {
            datposr -= (PI20000-1);
        }
        while(datposr <= -PI10000)
        {
            datposr += (PI20000-1);
        }
#endif

        dispItem.ctrl = ctrlByte;
        dispItem.attr = attrByte;
        dispItem.bx = prex;
        dispItem.by = prey;
        dispItem.ex = curx;
        dispItem.ey = cury;
        dispItem.bx2 = prex2;
        dispItem.by2 = prey2;
        dispItem.ex2 = curx2;
        dispItem.ey2 = cury2;
        dispItem.ar = curr;

        if(dispItem.ctrl == DATA_NULL)
        {
            dispItem.ex = dispItem.bx;
            dispItem.ey = dispItem.by;
            dispItem.ex2 = dispItem.bx2;
            dispItem.ey2 = dispItem.by2;
        }

        if(ctrlByte == DATA_OFFSET || ctrlByte == DATA_OFFSET_SEC || ctrlByte == DATA_SYNCOFST || ctrlByte == DATA_MIRROR_OFT_SEC) //跨步(偏移)针步另一钟颜色显示
            dispItem.rgb = getJumpedColour();
        else
            dispItem.rgb = getSewedColour();

        memcpy(&dispItem.action,ds16DataPtr->action,sizeof(dispItem.action));
        m_dispDat.append((char*)(&dispItem), sizeof(DispItem));

        ds16DataPtr++;
    }

    qDebug("CreateDispFromEmbDs16, stepsize=%d", m_dispDat.size() / sizeof(DispItem));

    return 0;
}

void EmbData::resetLayoutDispDat(unsigned char *arrayNeedle1, unsigned char *arrayNeedle2, unsigned char *arrayNeedle3, int leftRightNeedleSpace,int needlesSpace,int needleLayoutSpace12,int needleLayoutSpace23,int reDat)
{
    m_dispDat.clear();//显示绘图用的数据（需要转换）
    int stepsize = m_oneDispDat.size() / sizeof(DispItem);

    s16 lastNum = 6;//最后一排的循环次数
    int circleNum = 0;//循环次数
    circleNum = (needleLayoutSpace12+needleLayoutSpace23+ (m_maxY - m_minY)*(lastNum+1)) / (m_maxY - m_minY);

    int circleNumMiddle = 0;//循环次数
    circleNumMiddle = (needleLayoutSpace23 + (m_maxY - m_minY)*(lastNum+1)) / (m_maxY - m_minY);

    //根据前中后排的设置，再添加绘制数据
    if(reDat == 0 || reDat == 1)
    {
        //根据前中后排的设置，重置前排数据
        char frontSet[LAYOUTNEEDLENUM*2];
        memset((char*)frontSet,0,sizeof(frontSet));
        for(int i = 0; i < LAYOUTNEEDLENUM; i++)//12个针位设置，对应24根镇，一个针位上有2根针，每根针之间间距为1/2英寸
        {
            unsigned char val = *(arrayNeedle1+i);
            if(val == NEEDLELEFT)
            {
                frontSet[0+2*i] = 1;
                frontSet[1+2*i] = 0;
            }
            else if(val == NEEDLERIGHT)
            {
                frontSet[0+2*i] = 0;
                frontSet[1+2*i] = 1;
            }
            else if(val == NEEDLEDOUBLE)
            {
                frontSet[0+2*i] = 1;
                frontSet[1+2*i] = 1;
            }
            else if(val == NEEDLENONE)
            {
                frontSet[0+2*i] = 0;
                frontSet[1+2*i] = 0;
            }
        }

        m_dispDatFront.clear();
        DispItem dispItemFront;
        double frontSpace = 0;
        double frontYSpace = 0;
        for(unsigned int i = 0; i < sizeof(frontSet); i++)//12个针位设置，对应24根镇，一个针位上有2根针，每根针之间间距为1/2英寸
        {
            DispItem * pData = (DispItem *)(m_oneDispDat.data());
            char val = frontSet[i];

            if(val == 1)
            {
                for (int j = 0; j < stepsize; j++)
                {
                    dispItemFront = *pData;
                    dispItemFront.bx += frontSpace;
                    dispItemFront.ex += frontSpace;

                    if (m_dispMinX > dispItemFront.bx) { m_dispMinX = dispItemFront.bx; }
                    if (m_dispMinX > dispItemFront.ex) { m_dispMinX = dispItemFront.ex; }
                    if (m_dispMaxX < dispItemFront.bx) { m_dispMaxX = dispItemFront.bx; }
                    if (m_dispMaxX < dispItemFront.ex) { m_dispMaxX = dispItemFront.ex; }
                    //中排和后排无数据时
                    if(m_dispDatMiddle.size() <= 0 && m_dispDatBehind.size() <= 0)
                    {
                        if (m_dispMinY > dispItemFront.by) { m_dispMinY = dispItemFront.by; }
                        if (m_dispMinY > dispItemFront.ey) { m_dispMinY = dispItemFront.ey; }
                        if (m_dispMaxY < dispItemFront.by) { m_dispMaxY = dispItemFront.by; }
                        if (m_dispMaxY < dispItemFront.ey) { m_dispMaxY = dispItemFront.ey; }
                    }

                    m_dispDatFront.append((char*)(&dispItemFront), sizeof(DispItem));
                    pData++;
                }

                //Y方向再循环多次
                for(int m = 0; m < circleNum; m++)
                {
                    DispItem * pData = (DispItem *)(m_oneDispDat.data());
                    frontYSpace = m * (m_maxY - m_minY) + (m_maxY - m_minY);
                    for (int j = 0; j < stepsize; j++)
                    {
                        dispItemFront = *pData;
                        dispItemFront.bx += frontSpace;
                        dispItemFront.ex += frontSpace;
                        dispItemFront.by -= frontYSpace;
                        dispItemFront.ey -= frontYSpace;

                        if (m_dispMinX > dispItemFront.bx) { m_dispMinX = dispItemFront.bx; }
                        if (m_dispMinX > dispItemFront.ex) { m_dispMinX = dispItemFront.ex; }
                        if (m_dispMaxX < dispItemFront.bx) { m_dispMaxX = dispItemFront.bx; }
                        if (m_dispMaxX < dispItemFront.ex) { m_dispMaxX = dispItemFront.ex; }
                        //中排和后排无数据时
                        if(m_dispDatMiddle.size() <= 0 && m_dispDatBehind.size() <= 0)
                        {
                            if (m_dispMinY > dispItemFront.by) { m_dispMinY = dispItemFront.by; }
                            if (m_dispMinY > dispItemFront.ey) { m_dispMinY = dispItemFront.ey; }
                            if (m_dispMaxY < dispItemFront.by) { m_dispMaxY = dispItemFront.by; }
                            if (m_dispMaxY < dispItemFront.ey) { m_dispMaxY = dispItemFront.ey; }
                        }

                        m_dispDatFront.append((char*)(&dispItemFront), sizeof(DispItem));
                        pData++;
                    }
                }
            }
            if(i % 2 == 0)
            {
                frontSpace += leftRightNeedleSpace;
            }
            else
            {
                //frontSpace += leftRightNeedleSpace*3;
                frontSpace = (i-i/2)*needlesSpace;
            }
        }
    }

    if(reDat == 0 || reDat == 2)
    {
        double dispMinY = S32_MAX;
        double dispMaxY = S32_MIN;

        //根据前中后排的设置，重置中排数据
        char middleSet[LAYOUTNEEDLENUM*2];
        memset((char*)middleSet,0,sizeof(middleSet));
        for(int i = 0; i < LAYOUTNEEDLENUM; i++)//12个针位设置，对应24根镇，一个针位上有2根针，每根针之间间距为1/2英寸
        {
            unsigned char val = *(arrayNeedle2+i);
            if(val == NEEDLELEFT)
            {
                middleSet[0+2*i] = 1;
                middleSet[1+2*i] = 0;
            }
            else if(val == NEEDLERIGHT)
            {
                middleSet[0+2*i] = 0;
                middleSet[1+2*i] = 1;
            }
            else if(val == NEEDLEDOUBLE)
            {
                middleSet[0+2*i] = 1;
                middleSet[1+2*i] = 1;
            }
            else if(val == NEEDLENONE)
            {
                middleSet[0+2*i] = 0;
                middleSet[1+2*i] = 0;
            }
        }

        m_dispDatMiddle.clear();
        DispItem dispItemMiddle;
        double middleSpace = 0;
        double middleYSpace = 0;
        double ySpace = needleLayoutSpace12;

        for(unsigned int i = 0; i < sizeof(middleSet); i++)//12个针位设置，对应24根镇，一个针位上有2根针，每根针之间间距为1/2英寸
        {
            DispItem * pData = (DispItem *)(m_oneDispDat.data());
            char val = middleSet[i];

            if(val == 1)
            {
                for (int j = 0; j < stepsize; j++)
                {
                    dispItemMiddle = *pData;
                    dispItemMiddle.bx += middleSpace;
                    dispItemMiddle.ex += middleSpace;
                    dispItemMiddle.by -= ySpace;
                    dispItemMiddle.ey -= ySpace;

                    if (m_dispMinX > dispItemMiddle.bx) { m_dispMinX = dispItemMiddle.bx; }
                    if (m_dispMinX > dispItemMiddle.ex) { m_dispMinX = dispItemMiddle.ex; }
                    if (m_dispMaxX < dispItemMiddle.bx) { m_dispMaxX = dispItemMiddle.bx; }
                    if (m_dispMaxX < dispItemMiddle.ex) { m_dispMaxX = dispItemMiddle.ex; }
                    //后排无数据时
                    if(m_dispDatBehind.size() <= 0)
                    {
                        if (dispMinY > dispItemMiddle.by) { dispMinY = dispItemMiddle.by; }
                        if (dispMinY > dispItemMiddle.ey) { dispMinY = dispItemMiddle.ey; }
                        if (dispMaxY < dispItemMiddle.by) { dispMaxY = dispItemMiddle.by; }
                        if (dispMaxY < dispItemMiddle.ey) { dispMaxY = dispItemMiddle.ey; }
                        m_dispMinY = dispMinY;
                        m_dispMaxY = dispMaxY;
                    }

                    m_dispDatMiddle.append((char*)(&dispItemMiddle), sizeof(DispItem));
                    pData++;
                }

                //Y方向再循环多次
                for(int m = 0; m < circleNumMiddle; m++)
                {
                    DispItem * pData = (DispItem *)(m_oneDispDat.data());
                    middleYSpace = m * (m_maxY - m_minY) + (m_maxY - m_minY);
                    for (int j = 0; j < stepsize; j++)
                    {
                        dispItemMiddle = *pData;
                        dispItemMiddle.bx += middleSpace;
                        dispItemMiddle.ex += middleSpace;
                        dispItemMiddle.by -= (ySpace+middleYSpace);
                        dispItemMiddle.ey -= (ySpace+middleYSpace);

                        if (m_dispMinX > dispItemMiddle.bx) { m_dispMinX = dispItemMiddle.bx; }
                        if (m_dispMinX > dispItemMiddle.ex) { m_dispMinX = dispItemMiddle.ex; }
                        if (m_dispMaxX < dispItemMiddle.bx) { m_dispMaxX = dispItemMiddle.bx; }
                        if (m_dispMaxX < dispItemMiddle.ex) { m_dispMaxX = dispItemMiddle.ex; }
                        //后排无数据时
                        if(m_dispDatBehind.size() <= 0)
                        {
                            if (dispMinY > dispItemMiddle.by) { dispMinY = dispItemMiddle.by; }
                            if (dispMinY > dispItemMiddle.ey) { dispMinY = dispItemMiddle.ey; }
                            if (dispMaxY < dispItemMiddle.by) { dispMaxY = dispItemMiddle.by; }
                            if (dispMaxY < dispItemMiddle.ey) { dispMaxY = dispItemMiddle.ey; }
                            m_dispMinY = dispMinY;
                            m_dispMaxY = dispMaxY;
                        }

                        m_dispDatMiddle.append((char*)(&dispItemMiddle), sizeof(DispItem));
                        pData++;
                    }
                }
            }
            if(i % 2 == 0)
            {
                middleSpace += leftRightNeedleSpace;
            }
            else
            {
                //middleSpace += leftRightNeedleSpace*3;
                middleSpace = (i-i/2)*needlesSpace;
            }
        }
    }

    if(reDat == 0 || reDat == 3)
    {
        double dispMinY = S32_MAX;
        double dispMaxY = S32_MIN;

        //根据前中后排的设置，重置后排数据
        char behindSet[LAYOUTNEEDLENUM*2];
        memset((char*)behindSet,0,sizeof(behindSet));
        for(int i = 0; i < LAYOUTNEEDLENUM; i++)//12个针位设置，对应24根镇，一个针位上有2根针，每根针之间间距为1/2英寸
        {
            unsigned char val = *(arrayNeedle3+i);
            if(val == NEEDLELEFT)
            {
                behindSet[0+2*i] = 1;
                behindSet[1+2*i] = 0;
            }
            else if(val == NEEDLERIGHT)
            {
                behindSet[0+2*i] = 0;
                behindSet[1+2*i] = 1;
            }
            else if(val == NEEDLEDOUBLE)
            {
                behindSet[0+2*i] = 1;
                behindSet[1+2*i] = 1;
            }
            else if(val == NEEDLENONE)
            {
                behindSet[0+2*i] = 0;
                behindSet[1+2*i] = 0;
            }
        }

        m_dispDatBehind.clear();
        DispItem dispItemBehind;
        double behindSpace = 0;
        double behindYSpace = 0;
        double ySpace = needleLayoutSpace12+needleLayoutSpace23;
        for(unsigned int i = 0; i < sizeof(behindSet); i++)//12个针位设置，对应24根镇，一个针位上有2根针，每根针之间间距为1/2英寸
        {
            DispItem * pData = (DispItem *)(m_oneDispDat.data());
            char val = behindSet[i];

            if(val == 1)
            {
                for (int j = 0; j < stepsize; j++)
                {
                    dispItemBehind = *pData;
                    dispItemBehind.bx += behindSpace;
                    dispItemBehind.ex += behindSpace;
                    dispItemBehind.by -= ySpace;
                    dispItemBehind.ey -= ySpace;

                    if (m_dispMinX > dispItemBehind.bx) { m_dispMinX = dispItemBehind.bx; }
                    if (m_dispMinX > dispItemBehind.ex) { m_dispMinX = dispItemBehind.ex; }
                    if (m_dispMaxX < dispItemBehind.bx) { m_dispMaxX = dispItemBehind.bx; }
                    if (m_dispMaxX < dispItemBehind.ex) { m_dispMaxX = dispItemBehind.ex; }
                    if (dispMinY > dispItemBehind.by) { dispMinY = dispItemBehind.by; }
                    if (dispMinY > dispItemBehind.ey) { dispMinY = dispItemBehind.ey; }
                    if (dispMaxY < dispItemBehind.by) { dispMaxY = dispItemBehind.by; }
                    if (dispMaxY < dispItemBehind.ey) { dispMaxY = dispItemBehind.ey; }

                    m_dispDatBehind.append((char*)(&dispItemBehind), sizeof(DispItem));
                    pData++;
                }

                //Y方向再循环多次
                for(int m = 0; m < lastNum; m++)
                {
                    DispItem * pData = (DispItem *)(m_oneDispDat.data());
                    behindYSpace = m * (m_maxY - m_minY) + (m_maxY - m_minY);
                    for (int j = 0; j < stepsize; j++)
                    {
                        dispItemBehind = *pData;
                        dispItemBehind.bx += behindSpace;
                        dispItemBehind.ex += behindSpace;
                        dispItemBehind.by -= (ySpace+behindYSpace);
                        dispItemBehind.ey -= (ySpace+behindYSpace);

                        if (m_dispMinX > dispItemBehind.bx) { m_dispMinX = dispItemBehind.bx; }
                        if (m_dispMinX > dispItemBehind.ex) { m_dispMinX = dispItemBehind.ex; }
                        if (m_dispMaxX < dispItemBehind.bx) { m_dispMaxX = dispItemBehind.bx; }
                        if (m_dispMaxX < dispItemBehind.ex) { m_dispMaxX = dispItemBehind.ex; }
                        if (dispMinY > dispItemBehind.by) { dispMinY = dispItemBehind.by; }
                        if (dispMinY > dispItemBehind.ey) { dispMinY = dispItemBehind.ey; }
                        if (dispMaxY < dispItemBehind.by) { dispMaxY = dispItemBehind.by; }
                        if (dispMaxY < dispItemBehind.ey) { dispMaxY = dispItemBehind.ey; }

                        m_dispDatBehind.append((char*)(&dispItemBehind), sizeof(DispItem));
                        pData++;
                    }
                }
                m_dispMinY = dispMinY;
                m_dispMaxY = dispMaxY;
            }
            if(i % 2 == 0)
            {
                behindSpace += leftRightNeedleSpace;
            }
            else
            {
                //behindSpace += leftRightNeedleSpace*3;
                behindSpace = (i-i/2)*needlesSpace;
            }
        }
    }

    m_dispDat.clear();
    m_dispDat.append(m_dispDatFront);
    m_dispDat.append(m_dispDatMiddle);
    m_dispDat.append(m_dispDatBehind);

    if(m_dispDat.size() <= 0)
    {
        m_dispDat.append(m_oneDispDat);
        m_dispMaxX = m_maxX;
        m_dispMinX = m_minX;
        m_dispMaxY = m_maxY;
        m_dispMinY = m_minY;
    }
}

int EmbData::createDispFromEmbDs16DatForFlyShuttle(int initFlag)
{
    if(initFlag != 0)
    {
        if(m_dispDatFront.size() > 0 || m_dispDatMiddle.size() > 0 || m_dispDatBehind.size() > 0)
        {
            m_dispDat.clear();
            m_dispDat.append(m_dispDatFront);
            m_dispDat.append(m_dispDatMiddle);
            m_dispDat.append(m_dispDatBehind);
        }
        else
        {
            m_dispDat.clear();
            m_dispDat.append(m_oneDispDat);
        }
    }

    m_stitchIndex = 0;
    m_dispIndex = 0;

    // 图形显示区域
    int width = m_canvas.width();//留4个像素的边
    int height = m_canvas.height();//留4个像素的边

    if (width <= EMB_PREVIEW_SIDE*2 || height <= EMB_PREVIEW_SIDE*2)
    {
        qDebug("preview img too small");
        return -1;
    }

    //留边(否则实时跟踪笔会画出界)
    int viewSide = EMB_PREVIEW_SIDE;
    if(m_drawMode == DRAW_PREVIEW)
    {
        viewSide = 20;//预览模式时整区域留20像素绘制(原色显示)
    }
    int dpminx = viewSide;
    int dpmaxx = width - viewSide;
    int dpminy = viewSide;
    int dpmaxy = height - viewSide;

    //1:1显示无需留边
    //    int dpminx = 0;
    //    int dpmaxx = width;
    //    int dpminy = 0;
    //    int dpmaxy = height;

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

    factor = (double)(fabs(m_dispMaxX-m_dispMinX)) / (dpmaxx - dpminx);      // 按框尺寸x计算的缩放系数
    temp =   (double)(fabs(m_dispMaxY-m_dispMinY)) / (dpmaxy - dpminy);      // 按框尺寸y计算的缩放系数

    if(g_emResolut == resolution1910)
    {
        temp += 0.1;
    }

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

    m_factor = factor;

    // 计算显示参数，按照图形的实际位置显示（数据坐标零点对应图形中心）
    int dpx = (int)((dpminx+dpmaxx)/2 - ((m_dispMaxX+m_dispMinX)/factor)/2);
    //int dpy = (int)((dpminy+dpmaxy)/2 - ((m_dispMaxY+m_dispMinY)/factor)/2);
    int dpy = (int)((dpmaxy) - ((m_dispMaxY)/factor));//多针机不居中，顶端对齐

    if(g_emMacType == MACHINE_FLYSHUTTLE || g_emMacType == MACHINE_L2000_MULTI)
    {
        emb_showDirY = -1;
    }

    int dispstepsize = m_dispDat.size()/sizeof(DispItem);
    if (dispstepsize <= 0)
    {
        return -1;
    }

    DispItem * pDispData = (DispItem *)(m_dispDat.data());
    for (int i = 0; i < dispstepsize; i++)
    {
        pDispData->bx = pDispData->bx / factor + dpx;
        pDispData->by = pDispData->by / factor + dpy;
        pDispData->ex = pDispData->ex / factor + dpx;
        pDispData->ey = pDispData->ey / factor + dpy;

        if (emb_showDirX == -1)
        {
            pDispData->bx = width - pDispData->bx;
            pDispData->ex = width - pDispData->ex;
        }
        if (emb_showDirY == -1)
        {
            pDispData->by = height - pDispData->by;
            pDispData->ey = height - pDispData->ey;

            if(g_emMacType == MACHINE_FLYSHUTTLE || g_emMacType == MACHINE_L2000_MULTI)
            {
                double upSide = (height - dpmaxy);
                double dnSide = dpmaxy;

                if ((int)pDispData->by < upSide || (int)pDispData->by > dnSide)
                {
                    pDispData->rgb = qRgba(0,0,0,0);//设置透明色
                }

                if ((int)pDispData->ey < upSide || (int)pDispData->ey > dnSide)
                {
                    pDispData->rgb = qRgba(0,0,0,0);//设置透明色
                }
            }
        }

        pDispData++;
    }

    return 0;
}

#define DRAWDR 0

int EmbData::drawImageByDispFile()
{
    if(m_type == MACHINE_FIVEHEADPRECISIONSEWING)
        return drawImageByOneStepLotLine();

    if(m_type == MACHINE_DOUBLEHEADQUI || g_emMacType == MACHINE_FOURHEADQUI)
        return drawImageByDispFileDoubleHeadComb();

    double bx, by, ex, ey, ar;
    bx = by = ex = ey = ar = 0;
    int i;
    DispItem * pDispBuff = (DispItem *)m_dispDat.data();

    int size = m_dispDat.size();
    int stitchCount = size/sizeof(DispItem);

    if (stitchCount <= 0)
    {
        stitchCount = 0;
    }
    if (m_stitchIndex >= stitchCount)
    {
        m_stitchIndex = stitchCount - 1;
    }
    if (m_stitchIndex < 0)
    {
        m_stitchIndex = 0;
    }

    DISP_MODE dispmode = m_dispMode;

    QPainter painter(&m_canvas);
    QPen pen;

    //笔宽
    pen.setWidth(1);

    if (dispmode == DISP_ALL_NORMAL || dispmode == DISP_ALL_EXEC)
    {
        int tenThousand = 0;
        for (i = 0; i < stitchCount; i++)
        {
            tenThousand++;
            if(tenThousand == TENTHOUSANDNEEDLE)
            {
                tenThousand = 0;
                int idx = i / TENTHOUSANDNEEDLE;
                //每十万针主界面加载图片的进度条走一格
                emit siDrawNeedleIdx(idx);
            }

            bx = pDispBuff[i].bx;
            by = pDispBuff[i].by;
            ex = pDispBuff[i].ex;
            ey = pDispBuff[i].ey;

            // 从开始到 m_stitchIndex 显示正常颜色的线迹（执行过），从 m_stitchIndex 结束显示未缝纫颜色线迹（未执行）
            if ((dispmode == DISP_ALL_EXEC) && (i >= m_stitchIndex))
            {
                if(0 == pDispBuff[i].rgb || pDispBuff[i].ctrl == DATA_OFFSET)
                {
                    pen.setColor(Qt::transparent);
                }
                else
                {
                    pen.setColor(pDispBuff[i].rgb);
                }
            }
            else
            {//排针预览颜色
                pen.setColor(Qt::cyan);
            }
            painter.setPen(pen);
            painter.drawLine(bx, by, ex, ey);

#if(DRAWDR)
            double len = sqrt((double)(ex-bx)*(double)(ex-bx)+ (double)(ey-by)*(double)(ey-by));

            int mx = len * cos((PI10000-ar)/10000.0);
            int my = len * sin((PI10000-ar)/10000.0);
            QColor color = QColor(Qt::green);
            QPen pen;
            pen.setColor(color);
            painter.setPen(pen);
            painter.drawLine(bx, by, bx+mx, by+my);
            pen.setColor(QColor(Qt::red));
            painter.setPen(pen);
            painter.drawEllipse(bx+mx, by+my,2,2);
#endif
        }
        if (dispmode == DISP_ALL_EXEC && m_stitchIndex < stitchCount)
        {
            //飞梭机将跟踪笔画到最后一个循环开始处
            if(g_emMacType == MACHINE_FLYSHUTTLE || g_emMacType == MACHINE_L2000_MULTI)
            {
                int num = m_dispDat.size() / sizeof(DispItem);
                num -= m_pEmbDs16Head->itemNums;
                i = num + m_stitchIndex;
            }
            else
            {
                i = m_stitchIndex;
            }

            bx = pDispBuff[i].bx;
            by = pDispBuff[i].by;
            drawFork(bx, by, painter);//绘制准星
            m_dispIndex = m_stitchIndex;            // 移动显示指针
        }
    }
    else if (dispmode == DISP_EXECING)   // 刷新部分线迹（缝纫中进度显示）
    {
        if (m_stitchIndex != m_dispIndex)
        {
            eraseNeedleIdxPen(painter);//擦除跟踪笔

            if(g_emMacType == MACHINE_FLYSHUTTLE || g_emMacType == MACHINE_L2000_MULTI)
            {
                //实时刷新最后一个循环图形
                int num = m_dispDat.size() / sizeof(DispItem);
                num -= m_pEmbDs16Head->itemNums;
                m_dispIndex += num;
            }

            //增加针数
            if (m_stitchIndex > m_dispIndex && m_stitchIndex < stitchCount)
            {
                i = m_dispIndex;

                while(i < m_stitchIndex)
                {
                    bx = pDispBuff[i].bx;
                    by = pDispBuff[i].by;
                    ex = pDispBuff[i].ex;
                    ey = pDispBuff[i].ey;
                    if(0 == pDispBuff[i].rgb || pDispBuff[i].ctrl == DATA_OFFSET)
                    {
                        pen.setColor(Qt::transparent);
                    }
                    else
                    {
                        pen.setColor(Qt::red);
                    }

                    painter.setPen(pen);
                    painter.drawLine(bx, by, ex, ey);
                    i++;
                }
            }
            //减少针数
            else if (m_stitchIndex < m_dispIndex && m_dispIndex < stitchCount)
            {
                i = m_stitchIndex;

                while(i <= m_dispIndex)        // 显示为未缝纫颜色线迹
                {
                    bx = pDispBuff[i].bx;
                    by = pDispBuff[i].by;
                    ex = pDispBuff[i].ex;
                    ey = pDispBuff[i].ey;
                    if(0 == pDispBuff[i].rgb || pDispBuff[i].ctrl == DATA_OFFSET)
                    {
                        pen.setColor(Qt::transparent);
                    }
                    else
                    {
                        pen.setColor(pDispBuff[i].rgb);
                    }

                    painter.setPen(pen);
                    painter.drawLine(bx, by, ex, ey);
                    i++;
                }
            }

            i = m_stitchIndex;

            bx = pDispBuff[i].bx;
            by = pDispBuff[i].by;
            drawFork(bx, by, painter);//绘制跟踪笔

            if(g_emMacType == MACHINE_FLYSHUTTLE || g_emMacType == MACHINE_L2000_MULTI)
            {
                //实时刷新最后一个循环图形
                int num = m_dispDat.size() / sizeof(DispItem);
                num -= m_pEmbDs16Head->itemNums;
                m_dispIndex = m_stitchIndex - num;
            }
            else
            {
                m_dispIndex = m_stitchIndex; // 移动显示指针
            }
        }
    }
    return 0;
}


using namespace std;
/**
 * @brief EmbData::drawImageByOneStepLotLine
 * @return
 * 五头机绘图函数 根据机头间距表信息单步画多条线
 */
int EmbData::drawImageByOneStepLotLine()
{
    int stitchCount = m_headDispDate.size();
    //限制针步数 否则访问溢出
    if (stitchCount <= 0)
    {
        stitchCount = 0;
    }
    if (m_stitchIndex >= stitchCount)
    {
        m_stitchIndex = stitchCount - 1;
    }
    if (m_stitchIndex < 0)
    {
        m_stitchIndex = 0;
    }

    QPainter painter(&m_canvas);
    QRgb rgb;
    QPen pen;

    //笔宽
    pen.setWidth(1);

    if (m_dispMode == DISP_ALL_NORMAL ||        // 显示所有线迹（原色显示）
            m_dispMode == DISP_ALL_EXEC   ||        // 显示所有线迹（执行过的显示原色，其余显示灰色）
            0)
    {
        int tenThousand = 0;
        for (int i = 0; i < stitchCount; i++)
        {
            tenThousand++;
            if(tenThousand == TENTHOUSANDNEEDLE)
            {
                tenThousand = 0;
                int idx = i / TENTHOUSANDNEEDLE;
                //每十万针主界面加载图片的进度条走一格
                emit siDrawNeedleIdx(idx);
            }

            // 从开始到 m_stitchIndex 显示正常颜色的线迹（执行过），从 m_stitchIndex 结束显示未缝纫颜色线迹（未执行）
            rgb = m_headDispDate[i].rgb;

            if ((m_dispMode == DISP_ALL_EXEC) && (i >= m_stitchIndex))
            {
                if(m_headDispDate[i].ctrl ==DATA_OFFSET) //跨步(偏移)针步另一钟颜色显示
                    rgb = getNoJumpColour();
                else
                    rgb = getNoSewColour();
            }

            drawMultiLine(painter,pen,rgb,i);///多机头绘线
        }

        if (m_dispMode == DISP_ALL_EXEC && m_stitchIndex < stitchCount)
        {
            drawMultiTrack(painter);///绘制多机头的跟踪图案
            m_dispIndex = m_stitchIndex;            // 移动显示指针
        }
    }
    else if (m_dispMode == DISP_EXECING)   // 刷新部分线迹（缝纫中进度显示）前进回退的时候
    {
        //qDebug()<<"m_stitchIndex"<<m_stitchIndex<<"m_dispIndex"<<m_dispIndex;

        if (m_stitchIndex != m_dispIndex)
        {

            for(int j = 0; j < headNum; j++)
                eraseNeedleIdxPen(painter,j);///擦除跟踪笔

            // 显示针迹改变
            if (m_stitchIndex > m_dispIndex && m_stitchIndex < stitchCount)
            {
                /// 从小针步增加到大针步
                int i = m_dispIndex;

                while(i < m_stitchIndex)        // 显示为原线迹
                {
                    if(m_headDispDate[i].ctrl ==DATA_OFFSET) //跨步(偏移)针步另一钟颜色显示
                        rgb = getJumpedColour();
                    else
                        rgb = getSewedColour();
                    drawMultiLine(painter,pen,rgb,i);///多机头绘线
                    i++;
                }
            }
            else if (m_stitchIndex < m_dispIndex && m_dispIndex < stitchCount)
            {
                /// 从大针步减少到小针步
                int i = m_stitchIndex;

                while(i <= m_dispIndex)        // 显示为未缝纫颜色线迹
                {
                    rgb = m_headDispDate[i].rgb;
                    drawMultiLine(painter,pen,rgb,i);///多机头绘线
                    i++;
                }
            }

            drawMultiTrack(painter);///绘制多机头的跟踪图案
            m_dispIndex = m_stitchIndex;            // 移动显示指针
        }
    }
    return 0;
}

int EmbData::drawImageByDispFileDoubleHeadComb()
{
    double bx, by, bx2, by2, ex, ex2, ey, ey2, ar;
    bx = bx2 = by = by2 = ex = ex2 = ey = ey2 = ar = 0;
    int i;
    DispItem * pDispBuff = (DispItem *)m_dispDat.data();

    int size = m_dispDat.size();
    int stitchCount = size/sizeof(DispItem);

    if (stitchCount <= 0)
    {
        stitchCount = 0;
    }
    if (m_stitchIndex >= stitchCount)
    {
        m_stitchIndex = stitchCount - 1;
    }
    if (m_stitchIndex < 0)
    {
        m_stitchIndex = 0;
    }

    DISP_MODE dispmode = m_dispMode;

    QPainter painter(&m_canvas);
    QPen pen;

    //笔宽
    pen.setWidth(1);

    if (dispmode == DISP_ALL_NORMAL || dispmode == DISP_ALL_EXEC)
    {
        int tenThousand = 0;
        for (i = 0; i < stitchCount; i++)
        {
            tenThousand++;
            if(tenThousand == TENTHOUSANDNEEDLE)
            {
                tenThousand = 0;
                int idx = i / TENTHOUSANDNEEDLE;
                //每十万针主界面加载图片的进度条走一格
                emit siDrawNeedleIdx(idx);
            }

            bx = pDispBuff[i].bx;
            by = pDispBuff[i].by;
            ex = pDispBuff[i].ex;
            ey = pDispBuff[i].ey;

            bx2 = pDispBuff[i].bx2;
            by2 = pDispBuff[i].by2;
            ex2 = pDispBuff[i].ex2;
            ey2 = pDispBuff[i].ey2;

            // 从开始到 m_stitchIndex 显示正常颜色的线迹（执行过），从 m_stitchIndex 结束显示未缝纫颜色线迹（未执行）
            if ((dispmode == DISP_ALL_EXEC) && (i >= m_stitchIndex))
            {
                if(0 == pDispBuff[i].rgb || pDispBuff[i].ctrl == DATA_OFFSET || pDispBuff[i].ctrl == DATA_OFFSET_SEC || pDispBuff[i].ctrl == DATA_SYNCOFST || pDispBuff[i].ctrl == DATA_MIRROR_OFT_SEC)
                {
                    pen.setColor(Qt::transparent);
                }
                else
                {
                    pen.setColor(pDispBuff[i].rgb);
                }
            }
            else
            {//排针预览颜色
                pen.setColor(Qt::cyan);
            }
            painter.setPen(pen);
            painter.drawLine(bx, by, ex, ey);

            //第二机头用绿色，非偏移数据
            if(pen.color() != Qt::transparent)
            {
                pen.setColor(Qt::green);
            }
            painter.setPen(pen);
            painter.drawLine(bx2, by2, ex2, ey2);
        }
        if (dispmode == DISP_ALL_EXEC && m_stitchIndex < stitchCount)
        {
            i = m_stitchIndex;
            bx = pDispBuff[i].bx;
            by = pDispBuff[i].by;
            bx2 = pDispBuff[i].bx2;
            by2 = pDispBuff[i].by2;
            drawForkDoubleHead(bx, by, bx2, by2, painter);//绘制准星
            m_dispIndex = m_stitchIndex;            // 移动显示指针
        }
    }
    else if (dispmode == DISP_EXECING)   // 刷新部分线迹（缝纫中进度显示）
    {
        if (m_stitchIndex != m_dispIndex)
        {
            eraseNeedleIdxPenDoubleHead(painter);//擦除跟踪笔

            //增加针数
            if (m_stitchIndex > m_dispIndex && m_stitchIndex < stitchCount)
            {
                i = m_dispIndex;

                while(i < m_stitchIndex)
                {
                    bx = pDispBuff[i].bx;
                    by = pDispBuff[i].by;
                    ex = pDispBuff[i].ex;
                    ey = pDispBuff[i].ey;

                    bx2 = pDispBuff[i].bx2;
                    by2 = pDispBuff[i].by2;
                    ex2 = pDispBuff[i].ex2;
                    ey2 = pDispBuff[i].ey2;

                    if(0 == pDispBuff[i].rgb || pDispBuff[i].ctrl == DATA_OFFSET || pDispBuff[i].ctrl == DATA_OFFSET_SEC || pDispBuff[i].ctrl == DATA_SYNCOFST|| pDispBuff[i].ctrl == DATA_MIRROR_OFT_SEC)
                    {
                        pen.setColor(Qt::transparent);
                    }
                    else
                    {
                        pen.setColor(Qt::red);
                    }

                    painter.setPen(pen);
                    painter.drawLine(bx, by, ex, ey);
                    painter.drawLine(bx2, by2, ex2, ey2);
                    i++;
                }
            }
            //减少针数
            else if (m_stitchIndex < m_dispIndex && m_dispIndex < stitchCount)
            {
                i = m_stitchIndex;

                while(i <= m_dispIndex)        // 显示为未缝纫颜色线迹
                {
                    bx = pDispBuff[i].bx;
                    by = pDispBuff[i].by;
                    ex = pDispBuff[i].ex;
                    ey = pDispBuff[i].ey;

                    bx2 = pDispBuff[i].bx2;
                    by2 = pDispBuff[i].by2;
                    ex2 = pDispBuff[i].ex2;
                    ey2 = pDispBuff[i].ey2;

                    if(0 == pDispBuff[i].rgb || pDispBuff[i].ctrl == DATA_OFFSET || pDispBuff[i].ctrl == DATA_OFFSET_SEC || pDispBuff[i].ctrl == DATA_SYNCOFST || pDispBuff[i].ctrl == DATA_MIRROR_OFT_SEC)
                    {
                        pen.setColor(Qt::transparent);
                    }
                    else
                    {
                        pen.setColor(pDispBuff[i].rgb);
                    }

                    painter.setPen(pen);
                    painter.drawLine(bx, by, ex, ey);

                    //第二机头用绿色，非偏移数据
                    if(pen.color() != Qt::transparent)
                    {
                        pen.setColor(Qt::green);
                    }
                    painter.setPen(pen);
                    painter.drawLine(bx2, by2, ex2, ey2);
                    i++;
                }
            }

            i = m_stitchIndex;

            bx = pDispBuff[i].bx;
            by = pDispBuff[i].by;
            bx2 = pDispBuff[i].bx2;
            by2 = pDispBuff[i].by2;
            drawForkDoubleHead(bx, by, bx2, by2, painter);//绘制跟踪笔
            m_dispIndex = m_stitchIndex; // 移动显示指针
        }
    }
    return 0;
}

/**
 * @brief EmbData::findMaxSpHead
 * @param head 机头间距表
 * @param StepNum 跨步数
 * @return 返回机头间距表中用到的最大偏移值
 */
int EmbData::findMaxSpHead(DsrHeadEx62 &head,int StepNum)
{
    int max = 0;
    for(int i = 0 ; i < StepNum;i++){
        bitset<8> iswork(head.headEnableSpacing[i].iswork);
        for(int j = 1; j < headNum; j++)
        {
            if(!iswork.test(j)) // test(i)为0返回false
                continue;
            unsigned short int* row = (unsigned short int*)&head.headEnableSpacing[i];
            unsigned short int space = *(row + j); //向后偏移得到具体大小
            max = max > space ? max : space;
        }
    }
    return max;
}

///
/// \brief 根据机头间距表的iswork字段 选择性的绘制跟踪画笔
///
void EmbData::drawMultiTrack(QPainter &painter)
{
    int bx = m_headDispDate[m_stitchIndex].bx;
    int by = m_headDispDate[m_stitchIndex].by;
    bitset<8> iswork(m_headDispDate[m_stitchIndex].headtable.iswork);

    for(int j = 0; j < headNum; j++){
        if(j==0)//第一个机头不需要偏移
            drawFork(bx, by, painter, j);
        else if(iswork.test(j))///不是第一针，需要计算偏移量
        {
            unsigned short int* row = (unsigned short int*)&m_headDispDate[m_stitchIndex].headtable; // 取到结构体的初始地址
            unsigned short int space = *(row + j); //向后偏移得到具体大小
            space = (space*10)/m_factor; //从实际距离转换为像素，得到最终的偏移像素
            drawFork(bx + space, by, painter, j);
        }
        else
        {
            ///如果下一针不缝了 不需要画跟踪标志，也不需要还原上一针的图像
            ///所以此处将上一针的图像缓存重置，以免把画好的线迹擦除
            m_penHeadPix[j] = QPixmap();
        }

    }
}

///
/// \brief 五头机函数，根据机头间距表信息多机头同时画线
/// \param painter
/// \param pen
/// \param rgb
/// \param index
///
void EmbData::drawMultiLine(QPainter &painter, QPen &pen, QRgb rgb, int index)
{
    int bx = m_headDispDate[index].bx;//begin
    int by = m_headDispDate[index].by;
    int ex = m_headDispDate[index].ex;//end
    int ey = m_headDispDate[index].ey;

    pen.setColor(rgb);
    painter.setPen(pen);
    bitset<8> iswork(m_headDispDate[index].headtable.iswork);


    for(int j = 0; j < headNum; j++){
        if(!iswork.test(j)) // test(i)为0，表示机头不工作，跳过循环
        {
            if(j == 0){//如果是一机头不工作，那么使用黄色线段画出
                painter.save();
                painter.setPen(getNoJumpColour());
                painter.drawLine(bx, by, ex, ey); //机头1 缝纫数据 和原数据一致
                painter.restore();
            }
            continue;
        }

        //缝纫数据
        if(m_headDispDate[index].ctrl ==DATA_SEWING)
        {
            if(j == 0){//机头1
                painter.drawLine(bx, by, ex, ey); //机头1 缝纫数据 和原数据一致
            }
            else
            {
                unsigned short int* row = (unsigned short int*)&m_headDispDate[index].headtable; // 取到结构体的初始地址
                unsigned short int space = *(row + j); //向后偏移得到具体大小
                space = (space*10)/m_factor; //从实际距离转换为像素
                painter.drawLine(bx+space, by, ex+space, ey); //不是机头1的画线时需要偏移
            }
        }
        else{
            painter.drawLine(bx, by, ex, ey);
        }

    }
}

void EmbData::getOneDispDat(QByteArray &ds16dat)
{
    DispItem dispItem;
    // ds16数据
    int size = ds16dat.size();
    if (size <= (int)sizeof(DataDs16FileHead))
    {
        qDebug("16 data less then head size");
        return;
    }
    DataDs16FileHead * pDsHead = (DataDs16FileHead *)(ds16dat.data());
    int datasize = size - sizeof(DataDs16FileHead);
    if (datasize <= 0)
    {
        qDebug("dat dataBegin err");
        return;
    }
    int stepsize = datasize/sizeof(Ds16Item);
    if (stepsize <= 0)
    {
        qDebug("ds16 data size err");
        return;
    }

    Ds16Item * ds16DataPtr;
    Ds16Item * pData = (Ds16Item *)(ds16dat.data() + sizeof(DataDs16FileHead));
    ds16DataPtr = pData;

    double datposx, datposy, datposr;
    int curx, cury, curr, prex, prey;
    curx = cury = curr = prex = prey = 0;

    // 显示花样图形
    u8 ctrlByte;
    u8 attrByte;
    int dx;
    int dy;
    int dr;
    m_oneDispDat.clear();

    m_dispMinX = S32_MAX;
    m_dispMaxX = S32_MIN;
    m_dispMinY = S32_MAX;
    m_dispMaxY = S32_MIN;

    datposx = pDsHead->beginX;
    datposy = pDsHead->beginY;
    datposr = pDsHead->beginR;

    curx = datposx;
    cury = datposy;

    //先得到一个完整的绘制数据
    for (int i = 0; i < stepsize; i++)
    {
        prex = curx;
        prey = cury;

        // 读入一个针步数据
        ctrlByte = ds16DataPtr->ctrl;
        attrByte = ds16DataPtr->attr;
        dx = ds16DataPtr->dx;
        dy = ds16DataPtr->dy;
        dr = ds16DataPtr->dr;

        datposx += dx;
        datposy += dy;
        datposr += dr;

        curx = datposx;
        cury = datposy;

        while(datposr >= PI10000)
        {
            datposr -= (PI20000-1);
        }
        while(datposr <= -PI10000)
        {
            datposr += (PI20000-1);
        }

        dispItem.ctrl = ctrlByte;
        dispItem.attr = attrByte;
        dispItem.bx = prex;
        dispItem.by = prey;
        dispItem.ex = curx;
        dispItem.ey = cury;
        dispItem.ar = curr;

        if (m_dispMinX > dispItem.bx) { m_dispMinX = dispItem.bx; }
        if (m_dispMinX > dispItem.ex) { m_dispMinX = dispItem.ex; }
        if (m_dispMaxX < dispItem.bx) { m_dispMaxX = dispItem.bx; }
        if (m_dispMaxX < dispItem.ex) { m_dispMaxX = dispItem.ex; }
        if (m_dispMinY > dispItem.by) { m_dispMinY = dispItem.by; }
        if (m_dispMinY > dispItem.ey) { m_dispMinY = dispItem.ey; }
        if (m_dispMaxY < dispItem.by) { m_dispMaxY = dispItem.by; }
        if (m_dispMaxY < dispItem.ey) { m_dispMaxY = dispItem.ey; }

        if(ctrlByte == DATA_OFFSET) //跨步(偏移)针步另一钟颜色显示
            dispItem.rgb = getJumpedColour();
        else
            dispItem.rgb = getSewedColour();

        memcpy(&dispItem.action,ds16DataPtr->action,sizeof(dispItem.action));
        m_oneDispDat.append((char*)(&dispItem), sizeof(DispItem));

        ds16DataPtr++;
    }
    return;
}