PunchHMI/datafile/embdata.cpp

#include "embdata.h"

EmbData::EmbData()
{
    m_pDs16Head = new DataDs16FileHead();
    m_tabelColorNum = 0;
    m_pColor = NULL;
    memset(m_needleColorTable,0,sizeof(m_needleColorTable));
    clear();
}

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

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

    m_greyColorBeg = 0;
    m_greyColorEnd = 0;

    m_spaceX = 0;
    m_spaceY = 0;

    m_factor = 0;

    m_penX = 0;
    m_penY = 0;
    m_stitchSplitLength = 0;

    m_dataAbsList.clear();
    m_ds16Data.clear();

    m_editedflag = 0;
    m_filePath.clear();

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

void EmbData::setNeedleColorTable(int colorIdx, int colorvalue)
{
    if(colorIdx > TOTAL_NEEDLE_NUM - 1)
    {
        return;
    }
    m_needleColorTable[colorIdx] = colorvalue;
}

void EmbData::initColor(int cnum, QRgb *pColor)
{
    m_tabelColorNum = cnum;
    m_pColor = pColor;
}

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

    return m_ds16Data;
}

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


// 添加锁针针步
int EmbData::addLockStitchs(int locktimes, int locksteps, int lockstepsize)
{
    if (locktimes <= 0 || locksteps <= 0 || lockstepsize <= 0)
    {
        return -1;
    }

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

    QByteArray tgtdsdat;    // 添加后的绝对坐标数据
    tgtdsdat.clear();

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

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

    tgtdsdat.append((char*)pHead, sizeof(DataDs16FileHead));
    //pHead = (DataDs16FileHead *)(tgtdsdat.data());

    int runflag = 0;
    for (int j = 0; j < stepsize; j++)
    {
        if (absDataPtr->ctrl == DATA_CHGND)
        {
            runflag = 10;
        }
        else if (absDataPtr->ctrl == DATA_JUMP)
        {
            runflag++;
        }
        else if (absDataPtr->ctrl == DATA_EMB || absDataPtr->ctrl == DATA_SEWING)
        {
            if ((runflag == 0 || runflag > 3))
            {
                // 添加锁针
                int findnext = 0;
                if (j > 0)
                {
                    DsAbsItem * prePtr = absDataPtr-1;     // 上一个点
                    if (prePtr->ctrl != DATA_EMB)
                    {
                        double dx = absDataPtr->ax - prePtr->ax;
                        double dy = absDataPtr->ay - prePtr->ay;
                        double len = sqrt(dx*dx + dy*dy);
                        if (len <= 0)
                        {
                            findnext = 1;
                        }
                        else
                        {
                            int thislocktimes = locktimes;
                            int thislocksteps = locksteps;
                            int thislockstepsize = lockstepsize;
                            while (thislockstepsize * thislocksteps > len)
                            {
                                thislocksteps--;
                            }
                            if (thislocksteps == 0)
                            {
                                thislocktimes = 1;
                                thislocksteps = 1;
                                thislockstepsize = len;
                            }
                            DsAbsItem nitem;
                            memset(&nitem,0,sizeof(DsAbsItem));

                            u8 ctrl = absDataPtr->ctrl;
                            u8 attr = 0;    // absDataPtr->attr;
                            double axbase = prePtr->ax;
                            double aybase = prePtr->ay;
                            double arbase = absDataPtr->ar;

                            double adx = thislockstepsize * dx / len;
                            double ady = thislockstepsize * dy / len;
                            int addfst = 1;
                            int addlast = 1;
                            thislocktimes= (thislocktimes+1) / 2;
                            for (int k = 0; k < thislocktimes; k++)
                            {
                                if (k == thislocktimes-1)
                                {
                                    addlast = 0;
                                }
                                for (int s = addfst; s <= thislocksteps; s++)
                                {
                                    nitem.ctrl = ctrl;
                                    nitem.attr = attr;
                                    nitem.ax = axbase + adx*s;
                                    nitem.ay = aybase + ady*s;
                                    nitem.ar = arbase;
                                    tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
                                }
                                for (int s = thislocksteps-1; s >= addlast; s--)
                                {
                                    nitem.ctrl = ctrl;
                                    nitem.attr = attr;
                                    nitem.ax = axbase + adx*s;
                                    nitem.ay = aybase + ady*s;
                                    nitem.ar = arbase;
                                    tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
                                }
                                addfst = 0;
                            }
                        }
                    }
                }
                else
                {
                    findnext = 1;
                }

                if (findnext != 0)
                {
                    int nst = 1;
                    do
                    {
                        if (j+nst < stepsize)
                        {
                            DsAbsItem * nextPtr = absDataPtr+nst;     // 下一个点
                            if (nextPtr->ctrl == DATA_EMB)
                            {
                                int thislocktimes = locktimes;
                                int thislocksteps = locksteps;
                                int thislockstepsize = lockstepsize;
                                DsAbsItem nitem;
                                memset(&nitem,0,sizeof(DsAbsItem));

                                double dx = nextPtr->ax - absDataPtr->ax;
                                double dy = nextPtr->ay - absDataPtr->ay;
                                double len = sqrt(dx*dx + dy*dy);
                                if (len <= 0)
                                {
                                    nst++;
                                    continue;
                                }
                                while (thislockstepsize * thislocksteps > len)
                                {
                                    thislocksteps--;
                                }
                                if (thislocksteps == 0)
                                {
                                    thislocktimes = 1;
                                    thislocksteps = 1;
                                    thislockstepsize = len;
                                }
                                u8 ctrl = absDataPtr->ctrl;
                                u8 attr = 0;    // absDataPtr->attr;
                                double axbase = absDataPtr->ax;
                                double aybase = absDataPtr->ay;
                                double arbase = absDataPtr->ar;
                                double adx = thislockstepsize * dx / len;
                                double ady = thislockstepsize * dy / len;
                                thislocktimes= (thislocktimes+1) / 2;
                                for (int k = 0; k < thislocktimes; k++)
                                {
                                    for (int s = 0; s <= thislocksteps; s++)
                                    {
                                        nitem.ctrl = ctrl;
                                        nitem.attr = attr;
                                        nitem.ax = axbase + adx*s;
                                        nitem.ay = aybase + ady*s;
                                        nitem.ar = arbase;
                                        tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
                                    }
                                    for (int s = thislocksteps-1; s > 0; s--)
                                    {
                                        nitem.ctrl = ctrl;
                                        nitem.attr = attr;
                                        nitem.ax = axbase + adx*s;
                                        nitem.ay = aybase + ady*s;
                                        nitem.ar = arbase;
                                        tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
                                    }
                                }
                                break;
                            }
                            else
                            {
                                break;
                            }
                        }
                    }while(1);
                }
            }
            runflag = 1;
        }
        else if (absDataPtr->ctrl == DATA_CUTTRD)
        {
            runflag = 10;
        }
        else
        {
            runflag = 0;//混合绣时需要改这里
        }

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

        absDataPtr++;
    }

    m_absData.clear();
    m_absData = tgtdsdat;

    m_editedflag = 1;
    return 0;
}

int EmbData::addContinuousRunCompensate(int value, int idx)
{
    int ptnum = 0;
    int index = 0;
    int idxend = 0;

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

    ptnum =  m_dataAbsList.size();
    if (ptnum <= 0)
    {
        return 0;
    }
    if (idx < 0)
    {
        index = 0;
        idxend = ptnum;
    }
    else
    {
        index = idx;
        idxend = idx + 1;
    }

    for (int i = index; i < idxend; i++)
    {
        // 文件头
        const QByteArray & ary = m_dataAbsList.at(i);
        int size = ary.size();
        if (size <= (int)sizeof(DataDs16FileHead))
        {
            qDebug("ary%d data less then head size", i);
            continue;
        }

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

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

        DsAbsItem preStep, curStep, newStep;
        memset(&preStep, 0, sizeof(DsAbsItem));
        memset(&curStep, 0, sizeof(DsAbsItem));
        memset(&newStep, 0, sizeof(DsAbsItem));

        int runflag = 0;
        int cdx, cdy;

        // 数据镜像
        for (int j = 0; j < stepsize; j++)
        {
            memcpy(&preStep, &curStep, sizeof(DsAbsItem));
            memcpy(&curStep, absDataPtr, sizeof(DsAbsItem));
            memcpy(&newStep, &curStep, sizeof(DsAbsItem));

            if (curStep.ctrl != preStep.ctrl)       // 控制字节不同，属于不同的类型，需要停车处理
            {
                if (runflag == 0)   // 停车状态
                {
                    if (curStep.ctrl == DATA_SEWING ||          // 缝纫数据
                            curStep.ctrl == DATA_SEWING_R ||        // 右机头缝纫
                            curStep.ctrl == DATA_SECF_SEW ||        // 第二框缝纫
                            curStep.ctrl == DATA_SECF_SEW_R ||      // 第二框右机头缝纫
                            curStep.ctrl == DATA_SYNCSEW ||         // 同步缝纫数据
                            0)
                    {
                        cdx = 0;
                        cdy = 0;
                        runflag = 1;
                    }
                }
                else if (runflag != 0)
                {
                    runflag = 0;
                }
            }
            else
            {
                if (runflag == 1)
                {
                    cdx = curStep.ax - preStep.ax;
                    cdy = curStep.ay - preStep.ay;

                    newStep.ax += cdx * value / 1000;
                    newStep.ay += cdy * value / 1000;

                    absDataPtr->ax = newStep.ax;
                    absDataPtr->ay = newStep.ay;
                }
            }

            absDataPtr++;
        }
    }
    return 0;
}

QByteArray EmbData::getColorTable()
{
    int colornum = 0;
    QByteArray colortab;
    colortab.clear();

    if (m_editedflag != 0)
    {
        createDs16FromAbs();
    }

    if (m_ds16Data.size() > (int)sizeof(DataFileHead))
    {
        // 文件头
        DataDs16FileHead * pDsHead = (DataDs16FileHead *)(m_ds16Data.data());
        colornum = pDsHead->colorNumber;
        colortab.append((char*)(pDsHead->switchTable), colornum);
    }

    return colortab;
}

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

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

    int ptnum = m_dataAbsList.size();

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

    for (int i = 0; i < ptnum; i++)
    {
        const QByteArray & ary = m_dataAbsList.at(i);
        int size = ary.size();
        if (size <= (int)sizeof(DataFileHead))
        {
            qDebug("ary%d data less then head size", i);
            continue;   // 下一个
        }
        DataDs16FileHead * pDsHead = (DataDs16FileHead *)(ary.data());

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

        pDsHead->minX = minx;
        pDsHead->maxX = maxx;
        pDsHead->minY = miny;
        pDsHead->maxY = maxy;

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

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

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

void EmbData::setDs16ColorOfTable(u8 *table)
{
    if(m_pDs16Head != NULL)
    {
        s16 absNumber = m_dataAbsList.size();

        QByteArray ary = m_dataAbsList.at(0);
        DataDs16FileHead * pDsHead = (DataDs16FileHead *)(ary.data());
        s16 colorNum = pDsHead->colorNumber;

        QByteArray ctable;
        ctable.resize(sizeof(m_pDs16Head->switchTable));
        memset(ctable.data(),0,ctable.size());

        for(s16 i = 0; i < absNumber; i++)
        {
            memcpy(ctable.data()+i*colorNum,table,colorNum);
        }

        memcpy(m_pDs16Head->switchTable,ctable.data(),ctable.size());//将新的色序表重新写入文件头

        if((u32)m_ds16Data.size() > sizeof(m_pDs16Head))
        {
            memcpy(m_ds16Data.data(),(char*)m_pDs16Head, sizeof(DataDs16FileHead));
        }
    }
}

int EmbData::getPosInfoFromNeedleIdx(int stitchIdx, int &posx, int &posy, int & posr,int &colorIdx)
{
    if (m_editedflag != 0)
    {
        createDs16FromAbs();
    }

    posx = 0;
    posy = 0;
    colorIdx = 0;

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

    DataDs16FileHead * pDsHead = (DataDs16FileHead *)(m_ds16Data.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_ds16Data.data() + sizeof(DataDs16FileHead));
    ds16DataPtr = pData;

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

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

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

    int dx, dy, dr;
    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;

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

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

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

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

        ds16DataPtr++;
    }

    return 0;
}

int EmbData::getPosInfoFromColorIdx(int &stitchIdx, int &posx, int &posy, int & posr, int colorIdx)
{
    if (m_editedflag != 0)
    {
        createDs16FromAbs();
    }

    posx = 0;
    posy = 0;
    stitchIdx = 0;
    int cidx = 0;

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

    DataDs16FileHead * pDsHead = (DataDs16FileHead *)(m_ds16Data.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_ds16Data.data() + sizeof(DataDs16FileHead));
    ds16DataPtr = pData;

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

    if (colorIdx <= 0)
    {
        return -1;
    }

    //当前颜色索引大于总的颜色数时，针数索引等于总针数
    if(colorIdx >= ((int)pDsHead->colorNumber))
    {
        stitchIdx = stepsize;
        return 0;
    }

    int dx, dy, dr;
    u8 ctrl, attr;

    cidx = 0;
    for (int i = 0; i < stepsize; i++)
    {
        if (cidx == colorIdx)
        {
            stitchIdx = i;
            break;
        }

        ctrl = ds16DataPtr->ctrl;
        attr = ds16DataPtr->attr;
        dx = ds16DataPtr->dx;
        dy = ds16DataPtr->dy;
        dr = ds16DataPtr->dr;

        if (ctrl == DATA_CHGND)
        {
            cidx++;

            //最后一针为换色码时针数索引等于总针数减1
            if(i == (stepsize - 1))
            {
                stitchIdx = i;
            }
        }

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

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

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

        ds16DataPtr++;
    }

    return 0;
}

int EmbData::getNeedleIdxFromColorIdx(int & needleIdx, int colorIdx, u8 & stepCtrl)
{
    if (m_editedflag != 0)
    {
        createDs16FromAbs();
    }

    needleIdx = 0;
    int cidx = 0;
    s16 flag = 0;

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

    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_ds16Data.data() + sizeof(DataDs16FileHead));
    ds16DataPtr = pData;

    if (colorIdx <= 0)
    {
        return -1;
    }

    u8 ctrl;
    cidx = 1;
    for (int i = 0; i < stepsize; i++)
    {
        ctrl = ds16DataPtr->ctrl;

        if(i == 0)
        {
            stepCtrl = ctrl;
        }

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

        if (cidx == colorIdx)
        {
            if(flag == 0)
            {
                needleIdx = i+1;
            }
            //针步属性等于缝纫、冲孔或绣花
            if(ctrl == DATA_SEWING ||
                    ctrl == DATA_PUNCH ||
                    ctrl == DATA_EMB)
            {
                stepCtrl = ctrl;
                break;
            }
            flag = 1;
        }

        ds16DataPtr++;
    }

    return 0;
}

//设置起始点
void EmbData::setStartPosition(int x, int y)
{
    if(m_pDs16Head == NULL){return;}
    if(m_ds16Data.size() <= 0){return;}

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

    m_pDs16Head->beginX = x;
    m_pDs16Head->beginY = y;
    //    m_pDs16Head->anchorX = x;
    //    m_pDs16Head->anchorY = y;

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

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

    //将最大最小值写入文件头
    m_pDs16Head->maxX = maxX;
    m_pDs16Head->minX = minX;
    m_pDs16Head->maxY = maxY;
    m_pDs16Head->minY = minY;

    //修复偶尔点击中间按钮花样消失的bug
    m_maxX = maxX;
    m_minX = minX;
    m_maxY = maxY;
    m_minY = minY;
    memcpy(m_ds16Data.data(),(char*)m_pDs16Head,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_ds16Data);
        file.close();
    }
#endif
}

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

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

    memcpy(m_ds16Data.data(),(char*)m_pDs16Head,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_ds16Data);
        file.close();
    }
#endif
}

void EmbData::setSplitStitchLength(int length)
{
    m_stitchSplitLength = length;
}

int EmbData::setDatSizeChange(int dsx, int dsy, int idx)
{
    int ptnum = 0;
    int index = 0;
    int idxend = 0;

    if (dsx == 0 && dsy == 0)
    {
        return 0;
    }

    ptnum =  m_dataAbsList.size();
    if (ptnum <= 0)
    {
        return 0;
    }
    if (idx < 0)
    {
        index = 0;
        idxend = ptnum;
    }
    else
    {
        index = idx;
        idxend = idx + 1;
    }

    for (int i = index; i < idxend; i++)
    {
        // 文件头
        const QByteArray & ary = m_dataAbsList.at(i);
        int size = ary.size();
        if (size <= (int)sizeof(DataDs16FileHead))
        {
            qDebug("ary%d data less then head size", i);
            continue;
        }

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

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

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

        int width = 0;
        int height = 0;

        if(idx == -1)   //整体缩放
        {
            width  = m_maxX - m_minX;
            height = m_maxY - m_minY;
        }
        else
        {
            width  = pDsHead->maxX - pDsHead->minX;
            height = pDsHead->maxY - pDsHead->minY;
        }

        double nw = dsx / 100.00 * width;
        double nh = dsy / 100.00 * height;

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

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

        if (idx == -1)   //整体缩放,起始点也要缩放
        {
            double centerx = (m_maxX + m_minX)/2;
            double centery = (m_maxY + m_minY)/2;

            double rx = (pDsHead->beginX - centerx) * factorx;
            double ry = (pDsHead->beginY - centery) * factory;

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

            beginx += (beginx>0?(beginx!=0?1:0):-1) * (0.500001);
            beginy += (beginy>0?(beginy!=0?1:0):-1) * (0.500001);
        }

        // 数据缩放
        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(int mirror, int idx)
{
    int ptnum = 0;
    int index = 0;
    int idxend = 0;

    if (mirror == 0)    // 0, 无镜像; 1, 水平镜像; 2, 垂直镜像; 3, 水平和垂直镜像
    {
        return 0;
    }

    int mirrorx = 1;
    int mirrory = 1;
    int mirrorr = 0;
    int mirrorrdir = 0;

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

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

    ptnum =  m_dataAbsList.size();
    if (ptnum <= 0)
    {
        return 0;
    }
    if (idx < 0)
    {
        index = 0;
        idxend = ptnum;
    }
    else
    {
        index = idx;
        idxend = idx + 1;
    }

    for (int i = index; i < idxend; i++)
    {
        // 文件头
        const QByteArray & ary = m_dataAbsList.at(i);
        int size = ary.size();
        if (size <= (int)sizeof(DataDs16FileHead))
        {
            qDebug("ary%d data less then head size", i);
            continue;
        }

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

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

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

            int rx = ax * mirrorx;
            int ry = ay * mirrory;

            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->ax = rx;
            absDataPtr->ay = ry;
            absDataPtr->ar = ar;

            absDataPtr++;
        }
    }

    m_editedflag = 1;
    return 1;
}

// 旋转机头针尖补偿
// 解决旋转机头缝纫机缝制平行线时,间距不一致的问题.
// 输入:correct 补偿量,单位0.01mm,范围 -2.00mm ~ 2.00mm
int EmbData::setNeedleTipCompensation(s16 correct)
{
    int ptnum = 0;

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

    ptnum =  m_dataAbsList.size();
    if (ptnum <= 0)
    {
        return 0;
    }
    for (int i = 0; i < ptnum; i++)
    {
        // 文件头
        const QByteArray & ary = m_dataAbsList.at(i);
        int size = ary.size();
        if (size <= (int)sizeof(DataDs16FileHead))
        {
            qDebug("ary%d data less then head size", i);
            continue;
        }

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

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

        // 针尖补偿
        for (int j = 0; j < stepsize-1; j++)
        {
            if ((absDataPtr->ctrl == DATA_NULL) || (absDataPtr->ctrl == DATA_END))
            {
                break;
            }

            if ((absDataPtr->ctrl == DATA_SEWING) ||
                    (absDataPtr->ctrl == DATA_SEWING_R) ||
                    (absDataPtr->ctrl == DATA_SECF_SEW) ||
                    (absDataPtr->ctrl == DATA_SECF_SEW_R) ||
                    (absDataPtr->ctrl == DATA_JUMP) ||
                    0 )
            {// 只补偿缝纫/偏移数据
                double len ;
                double r = (absDataPtr->ar) / 10000.0;      // 弧度制
                if (j == 0)
                {
                    r = (absDataPtr->ar) / 10000.0;      // 弧度制
                }
                else
                {
                    absDataPtr--;
                    if ((absDataPtr->ctrl == DATA_SEWING) ||
                            (absDataPtr->ctrl == DATA_SEWING_R) ||
                            (absDataPtr->ctrl == DATA_SECF_SEW) ||
                            (absDataPtr->ctrl == DATA_SECF_SEW_R) ||
                            (absDataPtr->ctrl == DATA_JUMP) ||
                            0 )
                    {// 如果当前针步的前一个针步也是缝纫数据,则按前一个针步的数据角度计算
                        r = (absDataPtr->ar) / 10000.0;      // 弧度制
                    }
                    absDataPtr++;
                }

                if (correct > 0)
                {// 补偿量为当前机头方向逆时针转90°
                    len = correct;
                    r += PI/2;
                }
                else
                {// 补偿量为当前机头方向顺时针转90°
                    len = correct * -1.0;
                    r -= PI/2;
                }

                while (r > 2*PI)
                {
                    r -= 2*PI;
                }

                while (r < -2*PI)
                {
                    r += 2*PI;
                }

                double cosr = (double)qCos(r);
                double sinr = (double)qSin(r);

                double tx = cosr * len;
                double ty = sinr * len;

                absDataPtr->ax += tx;
                absDataPtr->ay += ty;

                m_editedflag = 1;
            }

            absDataPtr++;
        }

    }
    return 0;
}

int EmbData::setRotate(int dr, int idx)
{
    int ptnum = 0;
    int index = 0;
    int idxend = 0;
    double rr = (dr * PI / 180) * 10000;

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

    ptnum =  m_dataAbsList.size();
    if (ptnum <= 0)
    {
        return 0;
    }
    if (idx < 0)
    {
        index = 0;
        idxend = ptnum;
    }
    else
    {
        index = idx;
        idxend = idx + 1;
    }

    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

    for (int i = index; i < idxend; i++)
    {
        // 文件头
        const QByteArray & ary = m_dataAbsList.at(i);
        int size = ary.size();
        if (size <= (int)sizeof(DataDs16FileHead))
        {
            qDebug("ary%d data less then head size", i);
            continue;
        }

        int datasize = size - sizeof(DataDs16FileHead);
        int stepsize = datasize/sizeof(DsAbsItem);
        if (stepsize <= 0)
        {
            qDebug("dat data size err");
            continue;
        }
        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;

        double cx;
        double cy;

        int rx, ry; //这里以前是double类型，因为有的图形旋转后尺寸会加0.1，所以改为int类型
        double rcx, rcy;

        if (idx == -1)  // 整体旋转
        {
            cx = (m_maxX + m_minX)/2.0;
            cy = (m_maxY + m_minY)/2.0;

            rx = (pDsHead->beginX - cx);
            ry = (pDsHead->beginY - cy);
        }
        else
        {
            cx = pDsHead->beginX;
            cy = pDsHead->beginY;

            rx = 0;
            ry = 0;
        }

        rcx = (rx*cosa - ry*sina);
        rcy = (rx*sina + ry*cosa);

        double beginx = (rcx + cx);
        double beginy = (rcy + cy);

        beginx += (beginx>0?(beginx!=0?1:0):-1) * (0.500001);
        beginy += (beginy>0?(beginy!=0?1:0):-1) * (0.500001);

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

        // 数据旋转
        for (int j = 0; j < stepsize; j++)
        {
            // 变换前点坐标
            double ax = absDataPtr->ax + rx;
            double ay = absDataPtr->ay + ry;
            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 - rcx;
            absDataPtr->ay = ray - rcy;
            absDataPtr->ar =  ar;
            absDataPtr++;
        }
    }

    m_editedflag = 1;

    return 1;
}

int EmbData::setToMiddle(int idx)
{
    int ptnum = 0;
    int index = 0;
    int idxend = 0;

    ptnum =  m_dataAbsList.size();
    if (ptnum <= 0)
    {
        return 0;
    }
    if (idx < 0)
    {
        index = 0;
        idxend = ptnum;
    }
    else
    {
        index = idx;
        idxend = idx + 1;
    }

    for (int i = index; i < idxend; i++)
    {
        // 文件头
        const QByteArray & ary = m_dataAbsList.at(i);
        int size = ary.size();
        if (size <= (int)sizeof(DataDs16FileHead))
        {
            qDebug("ary%d data less then head size", i);
            continue;
        }

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

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

        if(idx == -1)
        {
            int centerx = 0 - (m_maxX + m_minX)/2;
            int centery = 0 - (m_maxY + m_minY)/2;

            int beginx = pDsHead->beginX + centerx;
            int beginy = pDsHead->beginY + centery;

            pDsHead->beginX = beginx;
            pDsHead->beginY = beginy;
        }
        else
        {
            pDsHead->beginX = 0;
            pDsHead->beginY = 0;
        }
    }

    m_editedflag = 1;

    return 0;
}

int EmbData::setDatMove(int dx, int dy, int idx)
{
    int ptnum = 0;
    int index = 0;
    int idxend = 0;

    if (dx == 0 && dy == 0)
    {
        return 0;
    }

    ptnum =  m_dataAbsList.size();
    if (ptnum <= 0)
    {
        return 0;
    }
    if (idx < 0)
    {
        index = 0;
        idxend = ptnum;
    }
    else
    {
        index = idx;
        idxend = idx + 1;
    }

    for (int i = index; i < idxend; i++)
    {
        // 文件头
        const QByteArray & ary = m_dataAbsList.at(i);
        int size = ary.size();
        if (size <= (int)sizeof(DataDs16FileHead))
        {
            qDebug("ary%d data less then head size", i);
            continue;
        }

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

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

        int beginx = pDsHead->beginX;
        int beginy = pDsHead->beginY;

        pDsHead->beginX = beginx + dx;
        pDsHead->beginY = beginy + dy;
    }

    m_editedflag = 1;

    return 0;
}

//此函数转换传入的绝对坐标值，是否取镜像及反复时数据之间的间距
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;
}

//花版的定位点为绝对坐标数据点，起始点为相对于定位点的相对坐标点，第一针为相对于起始点的坐标点
//有的花版起始点有偏移量，第一针偏移量为0，有的花版起始点偏移量为0，第一针有偏移量
//所以ds16文件头定位点坐标就是花版中的定位点，起始点坐标为花版中的定位点坐标+起始点坐标+第一针的坐标，同时ds16数据的第一针坐标偏移应置为0
//生成DS16数据
int EmbData::createDs16FromAbs()
{
    if (m_editedflag != 0)
    {
        m_minX = S32_MAX;
        m_maxX = S32_MIN;
        m_minY = S32_MAX;
        m_maxY = S32_MIN;

        int ptnum = m_dataAbsList.size();
        m_ds16Data.clear();

        QString name;
        QByteArray tgtdsdat;
        tgtdsdat.clear();

        u8 ctrlByte;
        u8 attrByte;
        WORD actionWord;	//附加动作
        //s16 dx, dy, dr;
        s32 dx, dy, dr;
        u16 len;
        double ax, ay, ar;
        int actx, acty, actr;
        int ddx, ddy,ddr;
        double x1,y1,x2,y2;
        x1 = y1 = x2 = y2 = 0;

        int beginx, beginy,beginr, anchorx, anchory;
        int minx, miny, maxx, maxy;
        int colornum = 1;// 颜色数
        int punchNum = 0;//冲孔个数
        int first = 1;//第一针
        actx = 0;
        acty = 0;
        actr =0;
        beginx = 0;
        beginy = 0;
        beginr = 0;
        anchorx = 0;
        anchory = 0;

        int totalstepsize = 0;
        memset(m_pDs16Head,0,sizeof(DataDs16FileHead));

        for (int i = 0; i < ptnum; i++)
        {
            const QByteArray & ary = m_dataAbsList.at(i);
            int size = ary.size();
            if (size <= (int)sizeof(DataDs16FileHead))
            {
                qDebug("ary%d data less then head size", i);
                continue;   // 下一个
            }
            DataDs16FileHead * pDsHead = (DataDs16FileHead *)(ary.data());
            //dsr,dst的中间数据
            //fileId = pDsHead->fileid;

            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);
            name = str;
            //str.sprintf("%s", pDsHead->fileName);
            //name += " ";
            //name += str;

            minx = absDataPtr->ax;
            maxx = absDataPtr->ax;
            miny = absDataPtr->ay;
            maxy = absDataPtr->ay;

            // 数据区
            for (int j = 0; j < stepsize; j++)
            {
                Ds16Item ds16Item;
                memset(&ds16Item,0,sizeof(Ds16Item));//清空ds16针步

                if(i != 0 && j == 0)//反复时非第一个花样第一针应是偏移
                {
                    // 添加偏移
                    ctrlByte = DATA_OFFSET;
                }
                else
                {
                    ctrlByte = absDataPtr->ctrl;
                }

                attrByte = absDataPtr->attr;//绝对数据的属性字节
                actionWord = absDataPtr->action;

                ax = absDataPtr->ax;//绝对数据的X位置
                ay = absDataPtr->ay;
                ar = absDataPtr->ar;

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

                if (first != 0)//first = 1第一个图元的第一针
                {
                    beginx = ax;
                    beginy = ay;
                    beginr = pDsHead->beginR;

                    anchorx = pDsHead->anchorX;
                    anchory = pDsHead->anchorY;

                    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(0)
                    //过滤掉空针
                    if(ddx== 0 && ddy == 0)
                    {
                        actx += ddx;
                        acty += ddy;
                        actr += ddr;
                        absDataPtr++;
                        first = 0;//第一个图元的第一针

                        continue;
                    }
#endif
                }
                else
                {
                    ddx = ax - actx;
                    ddy = ay - acty;
                    ddr = ar -actr;
                }

                //画笔转冲孔时，冲孔第一针的ddr置为0
                if(absDataPtr->ctrl == DATA_PUNCH)
                {
                    if(absDataPtr != pData)
                    {
                        absDataPtr--;
                        if(absDataPtr->ctrl == DATA_DRAWING)
                        {
                            ddr = 0;
                        }
                        absDataPtr++;
                    }
                }

                if( ctrlByte == DATA_END    ||
                        ctrlByte == DATA_PAUSE  ||
                        ctrlByte == DATA_CHGND  ||
                        ctrlByte == DATA_CUTTRD ||
                        ctrlByte == DATA_ANGLE ||
                        0 )
                {
                    ddx = 0;
                    ddy = 0;
                    ddr = 0;
                }

                dx = ddx;
                dy = ddy;
                dr = ddr;

                actx += ddx;
                acty += ddy;
                actr += ddr;

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

#if(0)
                //过滤掉运针空针
                if(ddx== 0 && ddy == 0 && ddr == 0 && (ctrlByte == DATA_PUNCH || ctrlByte == DATA_EMB || ctrlByte == DATA_SEWING))
                {
                    absDataPtr++;
                    qDebug()<<"This is a empty needle"<<j<<ddr;
                    continue;
                }
#endif

                if (ctrlByte == DATA_END || ctrlByte == DATA_NULL)
                {
                    if (i == ptnum - 1)     // 最后一个图
                    {
                        dx = dy = dr = len = 0;
                        // 增加剪线
                        ds16Item.ctrl = DATA_CUTTRD;
                        ds16Item.attr = 0;
                        ds16Item.action[0] = 0;
                        ds16Item.action[1] = 0;
                        ds16Item.dx = dx;
                        ds16Item.dy = dy;
                        ds16Item.dr = dr;
                        ds16Item.len = len;
                        memset(ds16Item.rev,0,sizeof(ds16Item.rev));

                        tgtdsdat.append((char*)(&ds16Item), sizeof(Ds16Item));

                        totalstepsize++;
                    }
                    else
                    {
                        ctrlByte = DATA_CUTTRD;     // 改为剪线
                    }
                }

                //分割针步 大于2000，小于-2000进行分割
                //如果dx或dy数值太大时，平方会超出double范围，所以先都除以100再乘以10000
                double xyLen = sqrt(((dx/100.0)*(dx/100.0))*10000.0+ ((dy/100.0)*(dy/100.0))*10000.0);
                double maxStep = 2000.0;
                double splitVal = 500.0;//分割针步为500

                if(m_stitchSplitLength != 0)
                {
                    maxStep = m_stitchSplitLength;
                    if(m_stitchSplitLength < splitVal)
                    {
                        splitVal = m_stitchSplitLength - 100;
                    }
                }

                if(xyLen >= maxStep)
                {
                    s16 addx,addy;

                    x1 = ax;
                    y1 = ay;
                    x2 = ax;
                    y2 = ay;
                    if(j != 0)
                    {
                        absDataPtr--;
                        x1 = absDataPtr->ax;
                        y1 = absDataPtr->ay;
                        absDataPtr++;
                    }

                    double tremainder =fmod(xyLen, splitVal);//取余
                    s16 stepNum = xyLen / splitVal;//拆分几步
                    if(tremainder != 0)
                    {
                        stepNum += 1;
                    }

                    double k = (y2-y1)/(x2-x1);
                    double r = atan(k);
                    double stepX = 0;
                    double stepY = 0;
                    double stepDr = 0;
                    addx = 0;
                    addy = 0;
                    for(int m = 0; m < stepNum; m++)
                    {
                        stepX = 0;
                        stepY = 0;
                        stepDr = 0;
                        memset(&ds16Item,0,sizeof(Ds16Item));//初始化结构体

                        if(m == stepNum-1 && tremainder > 0)//最后一步
                        {
                            splitVal = tremainder;
                        }

                        stepX = splitVal * cos(r);
                        stepY = splitVal * sin(r);

                        //stepX = cos(r) * splitVal;
                        if((dx < 0 && stepX > 0) || (dx > 0 && stepX < 0))
                        {
                            stepX = 0 - stepX;
                        }

                        //stepY = sin(r) * splitVal;
                        if((dy < 0 && stepY > 0) || (dy > 0 && stepY < 0))
                        {
                            stepY = 0 - stepY;
                        }

                        if(m == 0)
                        {
                            //stepDr = temp;
                            stepDr = dr;
                        }

                        //大针步转换为跳针
                        if(ctrlByte == DATA_PUNCH || ctrlByte == DATA_DRAWING)//功能码等于冲孔数据或画笔数据
                        {
                            //                            if(m == stepNum - 1)
                            //                            {
                            //                                ds16Item.ctrl = ctrlByte;
                            //                            }
                            //                            else
                            {
                                ds16Item.ctrl = DATA_JUMP;//跳针
                            }
                        }
                        else
                        {
                            ds16Item.ctrl = ctrlByte;
                        }
                        ds16Item.attr = attrByte;
                        ds16Item.action[0] = 0;
                        ds16Item.action[1] = 0;
                        ds16Item.dx = qRound(stepX);//四舍五入
                        ds16Item.dy = qRound(stepY);

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

                        len = sqrt(ds16Item.dx*ds16Item.dx + ds16Item.dy*ds16Item.dy);
                        ds16Item.dr = stepDr;
                        ds16Item.len = len;
                        memset(ds16Item.rev,0,sizeof(ds16Item.rev));
                        tgtdsdat.append((char*)(&ds16Item), sizeof(Ds16Item));
                        totalstepsize++;

                        //插入空针
                        if(m == stepNum - 1)
                        {
                            memset(&ds16Item,0,sizeof(ds16Item));
                            ds16Item.ctrl = ctrlByte;
                            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));
                    tgtdsdat.append((char*)(&ds16Item), sizeof(Ds16Item));//ds16针步
                    totalstepsize++;
                }

                if(i != 0 && j == 0)//反复时非第一个花样第一针改为偏移后再加换色码和一针正常针步
                {
                    // 添加换色
                    memset(&ds16Item,0,sizeof(Ds16Item));
                    ds16Item.ctrl = DATA_CHGND;
                    tgtdsdat.append((char*)(&ds16Item), sizeof(Ds16Item));
                    totalstepsize++;
                    colornum++;

                    // 添加第一针针步
                    memset(&ds16Item,0,sizeof(Ds16Item));
                    ds16Item.ctrl = absDataPtr->ctrl;
                    tgtdsdat.append((char*)(&ds16Item), sizeof(Ds16Item));
                    totalstepsize++;
                }

                if (ctrlByte == DATA_CHGND)
                {
                    colornum++;
                }

                if (ds16Item.ctrl == DATA_PUNCH)
                {
                    punchNum++;//冲孔总数加1
                }

                absDataPtr++;
                first = 0;//第一针
            }

            // 添加色序表
            int cidx, cnum;
            cnum = colornum;
            if (cnum > BF_SW_ND)
            {
                cnum = BF_SW_ND;
            }

            cidx = m_pDs16Head->colorNumber;
            if (cidx < 0)
            {
                cidx = 0;
            }
            if (cidx > BF_SW_ND)
            {
                cidx = BF_SW_ND;
            }
            if (cidx + cnum > BF_SW_ND)
            {
                cnum = BF_SW_ND - cidx;
            }

            memcpy(&(m_pDs16Head->switchTable[cidx]), pDsHead->switchTable, cnum);

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

            m_pDs16Head->colorNumber = cnum;          // 颜色数增加
        }

        // 针数
        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();
            memcpy(m_pDs16Head->fileName, array, namelen);   // 文件名称
            m_pDs16Head->dataSize = newstepnum*sizeof(Ds16Item);    // 数据字节数
            m_pDs16Head->itemNums = newstepnum;                    // 数据项个数
            m_pDs16Head->bytesPerItem = sizeof(Ds16Item);           // 每项占的字节数
            m_pDs16Head->bytesPerBlk = MAX_EXDP_LEN;               // 数据内容划分块大小
            m_pDs16Head->dataChecksum = calcCheckSum32((u8 *)(tgtdsdat.data()) , m_pDs16Head->dataSize);	// 数据累加校验和
            m_pDs16Head->checkCrc = calcCrc16((u8 *)(m_pDs16Head), HEAD_FIX_INFO_LEN); // 前面6个字段的CRC校验，（6个字段分别为：文件名称，字节数，项个数，每项字节数，每块字节数，数据累加和的CRC校验值）
            m_pDs16Head->fileid = m_pDs16Head->checkCrc;
            m_pDs16Head->anchorX = anchorx;                  // 定位点坐标X
            m_pDs16Head->anchorY = anchory;                  // 定位点坐标Y, 设置为0，作为基准
            m_pDs16Head->beginX = beginx;              // 数据起点坐标X
            m_pDs16Head->beginY = beginy;              // 数据起点坐标Y
            m_pDs16Head->beginR = beginr;              // 数据起点坐标R  //-rq
            m_pDs16Head->minX = m_minX;
            m_pDs16Head->maxX = m_maxX;
            m_pDs16Head->minY = m_minY;
            m_pDs16Head->maxY = m_maxY;                // 轮廓范围，使用重新计算之后的值
            m_pDs16Head->punchNum = punchNum;//冲孔个数
            // 添加文件头
            m_ds16Data.append((char*)m_pDs16Head, sizeof(DataDs16FileHead));//ds16头文件存在ds16中
            // 添加文件数据
            m_ds16Data.append(tgtdsdat);
        }

#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 -1;
        }
        else
        {
            file.write(m_ds16Data);
            file.close();
        }
#endif
    }

    m_editedflag = 0;

    return 0;
}

int EmbData::reCalcDataChecksum()
{
    return 0;
}

QByteArray EmbData::intTo2ByteArray(s16 value)
{
    QByteArray ba;
    ba.resize(2);
    ba[0] = (uchar)(0x000000ff & value);
    ba[1] = (uchar)((0x0000ff00 & value) >> 8);
    return ba;
}

//绘制针数索引的跟踪笔
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::eraseNeedleIdxPen(QPainter &painter)
{
    //贴图的xy和画笔的xy值相同
    painter.drawPixmap(m_penX-20,m_penY-30,m_penPix);
}

//设置视图尺寸(透明背景)
int EmbData::setViewInfo(int width, int height)
{
    //    if (m_viewWidth != width ||
    //        m_viewHight != height)
    {
        if (width <= PREVIEW_SIDE*2 || height <= 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;
}

//重新重置ds16数据(换色点击取消后数据会变为单个图元的原数据，
//若图形经过变换数据会不对，主界面保存了最后的数据，
//若点击换色并取消后恢复为主界面最后保存的数据即可)
void EmbData::reSetEmbData(QByteArray ary)
{
    if(ary.size() <= 0)
    {
        return;
    }
    m_ds16Data.clear();
    m_ds16Data.append(ary);
    //文件头也恢复为默认
    memcpy(m_pDs16Head, m_ds16Data.data(), sizeof(DataDs16FileHead));   // 文件名称
}

void EmbData::reSetEmbDataRange(int maxX, int minX, int maxY, int minY)
{
    m_maxX = maxX;
    m_minX = minX;
    m_maxY = maxY;
    m_minY = minY;
}

//重置数据
void EmbData::setEmbData(int redraw)
{
    createDispFromDs16Dat(m_ds16Data);
    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::setGreyAreaRange(int begin, int end)
{
    m_greyColorBeg = begin;
    m_greyColorEnd = end;
}

//设置区域显示参数
void EmbData::setDispAreaRange(int begin, int end, int redraw)
{
    m_showColorBeg = begin;
    m_showColorEnd = end;

    if (redraw != 0)
    {
        drawImageByDispFile();
    }
}

//设置进度显示数据
void EmbData::setExecIndex(int index)
{
    m_stitchIndex = index;

    if (m_dispMode == DISP_EXECING)
    {
        drawImageByDispFile();
    }
}

void EmbData::reDraw()
{
    drawImageByDispFile();
}

//创建显示用的数据（为了快速显示）
int EmbData::createDispFromDs16Dat(QByteArray &ds16dat)
{
    DispItem 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 <= PREVIEW_SIDE*2 || height <= PREVIEW_SIDE*2)
    {
        qDebug("preview img too small");
        return -1;
    }

    //留边(否则实时跟踪笔会画出界)
    int viewSide = 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;
    int colorIdx,oldcolor;

    double datposx, datposy, datposr;
    int curx, cury, prex, prey;
    curx = cury = prex = prey = 0;

    //用起始点绘制
    datposx = pDsHead->beginX;
    datposy = pDsHead->beginY;
    datposr = pDsHead->beginR;

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

    if (SHOWDIRX == -1)
    {
        curx = width - curx;
    }
    if (SHOWDIRY == -1)
    {
        cury = height - cury;
    }

    colorIdx = 0;
    oldcolor = -1;
    QRgb embcolor = 0;

    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 (SHOWDIRX == -1)
        {
            curx = width - curx;
        }
        if (SHOWDIRY == -1)
        {
            cury = height - cury;
        }

        if (oldcolor != colorIdx)
        {
            //int cidx = pDsHead->switchTable[colorIdx % EMB_BF_SW_ND];
            int nidx = pDsHead->switchTable[colorIdx];

            int cidx;
            if(nidx <= 0)
            {
                cidx = 0;//未设置过色序时颜色索引默认为0
            }
            else
            {
                cidx = m_needleColorTable[nidx - 1] % BF_SW_ND;
            }

            int cnum = m_tabelColorNum;
            cnum /= sizeof(QRgb);
            if (cnum > BF_SW_ND)
            {
                cnum = BF_SW_ND;
            }
            if (cnum != 0)
            {
                cidx %= cnum;
                QRgb * pColor = m_pColor;
                if(pColor != NULL)
                {
                    embcolor = (pColor[cidx]);
                }
                else
                {
                    embcolor = 0;
                }
            }
            else
            {
                embcolor = 0;
            }

            oldcolor = colorIdx;
        }

        if (ctrlByte == DATA_CHGND)    // 换色
        {
            colorIdx++;
        }

        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.rgb = embcolor;
        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;
}

#define DRAWDR 0

int EmbData::drawImageByDispFile()
{
    u8 ctrl;
    int bx, by, ex, ey;
    bx = by = ex = ey = 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;
    }

    if (m_showColorBeg < 0)
    {
        m_showColorBeg = 0;
    }

    if (m_showColorEnd < 0)
    {
        m_showColorEnd = 0;
    }

    DISP_MODE dispmode = m_dispMode;

    QPainter painter(&m_canvas);

    int gary = 0;
    QRgb rgb, oldrgb;
    s16 ar;
    QPen pen;
    QColor color;

    //笔宽
    pen.setWidth(4);
    oldrgb = 0;
    rgb = 0;

    if (dispmode == DISP_ALL_NORMAL ||        // 显示所有线迹（原色显示）
            dispmode == DISP_ALL_EXEC   ||        // 显示所有线迹（执行过的显示原色，其余显示灰色）
            0)
    {
        int tenThousand = 0;
        for (i = 0; i < stitchCount; i++)
        {
            tenThousand++;
            if(tenThousand == TENTHOUSANDNEEDLE)
            {
                tenThousand = 0;
                int idx = i / TENTHOUSANDNEEDLE;
                //每十万针主界面加载图片的进度条走一格
                emit siDrawNeedleIdx(idx);
            }

            ctrl = pDispBuff[i].ctrl;
            bx = pDispBuff[i].bx;
            by = pDispBuff[i].by;
            ex = pDispBuff[i].ex;
            ey = pDispBuff[i].ey;
            ar = pDispBuff[i].ar;
            rgb = pDispBuff[i].rgb;

            if (dispmode == DISP_ALL_EXEC) // 从开始到 m_stitchIndex 显示正常颜色的线迹（执行过），从 m_stitchIndex 结束显示未缝纫颜色线迹（未执行）
            {
                if (i >= m_stitchIndex)
                {
                    gary = qGray(rgb);
                    //gary = gary/3 + 150;    // 颜色变淡
                    gary = COLOR_GREY;//纯灰
                    rgb = qRgb(gary, gary, gary);
                }
            }

            if (oldrgb != rgb)
            {
                color.setRgb(rgb);
                pen.setColor(color);
                painter.setPen(pen);
                oldrgb = rgb;
            }

            if(ctrl == DATA_PUNCH)
            {
                int cr = PUNCHRADIUS / m_factor;
                if(cr <= 0){cr = 1;}
                painter.drawEllipse(ex-cr,ey-cr,cr*2,cr*2);
            }
            else
            {
                painter.drawLine(bx, by, ex, ey);
            }

            if(ar == 0){}//为了去掉编译警告
#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)
        {
            i = m_stitchIndex;

            bx = pDispBuff[i].bx;
            by = pDispBuff[i].by;
            drawNeedleIdxPen(bx, by, painter);//绘制跟踪笔
            m_dispIndex = m_stitchIndex;            // 移动显示指针
        }
    }
    else if ( dispmode == DISP_ALL_AREA )          // 显示所有线迹（有效区域内的显示原色，其余显示灰色）
    {
        //显示为灰色
        for(int j = m_greyColorBeg; j < m_greyColorEnd; j++)
        {
            ctrl = pDispBuff[j].ctrl;
            bx = pDispBuff[j].bx;
            by = pDispBuff[j].by;
            ex = pDispBuff[j].ex;
            ey = pDispBuff[j].ey;
            rgb = pDispBuff[j].rgb;

            gary = qGray(rgb);
            //gary = gary/3 + 150;    // 颜色变淡
            gary = COLOR_GREY;//纯灰
            rgb = qRgb(gary, gary, gary);

            if (oldrgb != rgb)
            {
                color.setRgb(rgb);
                pen.setColor(color);
                painter.setPen(pen);
                oldrgb = rgb;
            }

            if(ctrl == DATA_PUNCH)
            {
                int cr = PUNCHRADIUS / m_factor;
                if(cr <= 0){cr = 1;}
                painter.drawEllipse(ex-cr,ey-cr,cr*2,cr*2);
            }
            else
            {
                painter.drawLine(bx, by, ex, ey);
            }
        }

        //显示为原色
        for(int m = m_showColorBeg; m < m_showColorEnd; m++)
        {
            ctrl = pDispBuff[m].ctrl;
            bx = pDispBuff[m].bx;
            by = pDispBuff[m].by;
            ex = pDispBuff[m].ex;
            ey = pDispBuff[m].ey;
            rgb = pDispBuff[m].rgb;

            color.setRgb(rgb);
            pen.setColor(color);
            painter.setPen(pen);

            if(ctrl == DATA_PUNCH)
            {
                int cr = PUNCHRADIUS / m_factor;
                if(cr <= 0){cr = 1;}
                painter.drawEllipse(ex-cr,ey-cr,cr*2,cr*2);
            }
            else
            {
                painter.drawLine(bx, by, ex, ey);
            }
        }
    }
    else if (dispmode == DISP_EXECING)   // 刷新部分线迹（缝纫中进度显示）
    {
        //qDebug()<<"m_stitchIndex"<<m_stitchIndex<<"m_dispIndex"<<m_dispIndex;

        if (m_stitchIndex != m_dispIndex)
        {
            eraseNeedleIdxPen(painter);//擦除跟踪笔

            // 显示针迹改变
            if (m_stitchIndex > m_dispIndex && m_stitchIndex < stitchCount)
            {
                i = m_dispIndex;

                while(i < m_stitchIndex)        // 显示为原线迹
                {
                    ctrl = pDispBuff[i].ctrl;
                    bx = pDispBuff[i].bx;
                    by = pDispBuff[i].by;
                    ex = pDispBuff[i].ex;
                    ey = pDispBuff[i].ey;
                    rgb = pDispBuff[i].rgb;

                    if (oldrgb != rgb)
                    {
                        color.setRgb(rgb);
                        pen.setColor(color);
                        painter.setPen(pen);
                        oldrgb = rgb;
                    }

                    if(ctrl == DATA_PUNCH)
                    {
                        int cr = PUNCHRADIUS / m_factor;
                        if(cr <= 0){cr = 1;}
                        painter.drawEllipse(ex-cr,ey-cr,cr*2,cr*2);
                    }
                    else
                    {
                        painter.drawLine(bx, by, ex, ey);
                    }
                    i++;
                }
            }
            else if (m_stitchIndex < m_dispIndex && m_dispIndex < stitchCount)
            {
                i = m_stitchIndex;

                while(i <= m_dispIndex)        // 显示为未缝纫颜色线迹
                {
                    ctrl = pDispBuff[i].ctrl;
                    bx = pDispBuff[i].bx;
                    by = pDispBuff[i].by;
                    ex = pDispBuff[i].ex;
                    ey = pDispBuff[i].ey;
                    rgb = pDispBuff[i].rgb;

                    gary = qGray(rgb);
                    //gary = gary/3 + 150;    // 颜色变淡
                    gary = COLOR_GREY;//纯灰
                    rgb = qRgb(gary, gary, gary);

                    if (oldrgb != rgb)
                    {
                        color.setRgb(rgb);
                        pen.setColor(color);
                        painter.setPen(pen);
                        oldrgb = rgb;
                    }

                    if(ctrl == DATA_PUNCH)
                    {
                        int cr = PUNCHRADIUS / m_factor;
                        if(cr <= 0){cr = 1;}
                        painter.drawEllipse(ex-cr,ey-cr,cr*2,cr*2);
                    }
                    else
                    {
                        painter.drawLine(bx, by, ex, ey);
                    }
                    i++;
                }
            }

            i = m_stitchIndex;

            bx = pDispBuff[i].bx;
            by = pDispBuff[i].by;
            drawNeedleIdxPen(bx, by, painter);//绘制跟踪笔
            m_dispIndex = m_stitchIndex;            // 移动显示指针
        }
    }
    return 0;
}