huahaiyan/QuiltingHMI
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
22d25edf54
QuiltingHMI/datafile/embdata.cpp

3801 lines
108 KiB
C++
Raw Normal View History

第一次提交
2024-02-06 07:10:48 +00:00
#include "embdata.h"
#include "main.h"
const QColor sewcolorGreen = QColor(0x35,0xC0,0x5C);//绿色
u32 rgbColorGreen = qRgb(sewcolorGreen.red(),sewcolorGreen.green(),sewcolorGreen.blue());
const QColor sewcolorYel = QColor(Qt::darkYellow);//黄色
u32 rgbColorYel = qRgb(sewcolorYel.red(),sewcolorYel.green(),sewcolorYel.blue());
const QColor sewcolorblue = QColor(Qt::blue);//蓝色
u32 rgbColorBlue = qRgb(sewcolorblue.red(),sewcolorblue.green(),sewcolorblue.blue());
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;
memset(m_pEmbDs16Head,0,sizeof(DataDs16FileHead));
}
QByteArray & EmbData::getDsDat()
{
//qDebug()<<"m_editedflag"<<m_editedflag;
if(m_editedflag != 0)
{
createEmbDs16FromAbs();
}
return m_embDs16Data;
}
//设置数据区文件头的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");
}
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;
//-----
int begx = pDsHead->beginX;
int begy = pDsHead->beginY;
minx = S32_MAX;
maxx = S32_MIN;
miny = S32_MAX;
maxy = S32_MIN;
// 数据区
for (int j = 0; j < stepsize; j++)
{
ax = absDataPtr->ax + begx;
ay = absDataPtr->ay + begy;
// 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; }
}
// 添加锁针针步
int EmbData::addLockStitchs(u8 mode, u8 needles, u8 num)
{
if (needles <= 0)
{
return -1;
}
int size = m_embAbsData.size();
if (size <= 0)
{
return -1;
}
int lockNum = num;//锁针次数
int lockNeedles = needles;//锁针针数
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_embAbsData.data());
DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.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_SEWING)//包括起针和剪线后加锁针
{
if ((runflag == 0 || runflag > 3))
{
// 添加锁针
int nst = 0;
if(mode == MODE_LOCK)//锁针方式
{
if(lockNum%2 == 0)//偶数
{
nst = 1;
}
else//奇数
{
nst = needles;
}
do
{
if(j+nst < stepsize)
{
DsAbsItem * nextPtr = absDataPtr+nst; // 要加锁针的点
if (nextPtr->ctrl == DATA_SEWING)
{
DsAbsItem nitem;
memset(&nitem,0,sizeof(DsAbsItem));
u8 ctrl = absDataPtr->ctrl;
u8 attr = 0; // absDataPtr->attr;
double arbase = absDataPtr->ar;
if(lockNum%2 == 0)//偶数锁针
{
nextPtr--;
for (int k = 0; k < lockNum; k++)
{
if(k%2 == 0)
{
for (int s = 0; s < lockNeedles; s++)
{
nextPtr++;
double axbase = nextPtr->ax;
double aybase = nextPtr->ay;
nitem.ctrl = ctrl;
nitem.attr = attr;
nitem.ax = axbase;
nitem.ay = aybase;
nitem.ar = arbase;
tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
}
}
if(k > 0 && k%2 != 0)
{
for (int s = lockNeedles; s > 0; s--)
{
nextPtr--;
double axbase = nextPtr->ax;
double aybase = nextPtr->ay;
if(k == lockNum-1 && s == 1)
{
continue;//最后一次锁针的最后一步不添加
}
nitem.ctrl = ctrl;
nitem.attr = attr;
nitem.ax = axbase;
nitem.ay = aybase;
nitem.ar = arbase;
tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
}
}
}
}
else//奇数锁针
{
nextPtr++;
for (int k = 0; k < lockNum; k++)
{
if(k%2 == 0)
{
for (int s = lockNeedles; s > 0; s--)
{
nextPtr--;
double axbase = nextPtr->ax;
double aybase = nextPtr->ay;
if(k == 0 && s == lockNeedles)
{
nitem.ctrl = DATA_OFFSET;//第一针步转换为跨步
}
else
{
nitem.ctrl = ctrl;
}
nitem.attr = attr;
nitem.ax = axbase;
nitem.ay = aybase;
nitem.ar = arbase;
tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
}
nextPtr--;
}
if(k > 0 && k%2 != 0)
{
for (int s = 0; s < lockNeedles; s++)
{
double axbase = nextPtr->ax;
double aybase = nextPtr->ay;
nitem.ctrl = ctrl;
nitem.attr = attr;
nitem.ax = axbase;
nitem.ay = aybase;
nitem.ar = arbase;
tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
nextPtr++;
}
nextPtr++;
}
}
}
break;
}
else
{
break;
}
}
}while(1);
}
else if(mode == MODE_THICKEN)//密针方式
{
tgtdsdat.append((char*)absDataPtr, sizeof(DsAbsItem));
nst = 1;
s16 nNum = 0;
if(lockNum == 0)//如果锁针次数为0时，第一针锁针次数就是锁针针数
{
nNum = lockNeedles+1;
}
else
{
nNum = lockNum+1;
}
do
{
if(j+nst < stepsize)
{
DsAbsItem * nextPtr = absDataPtr+nst; // 下一个点
if (nextPtr->ctrl == DATA_SEWING)
{
DsAbsItem nitem;
memset(&nitem,0,sizeof(DsAbsItem));
DsAbsItem * prePtr = absDataPtr;
u8 ctrl = absDataPtr->ctrl;
u8 attr = 0; // absDataPtr->attr;
double arbase = absDataPtr->ar;
for (int s = 0; s < lockNeedles; 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++;
lockNeedles++;
continue;
}
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 = ctrl;
nitem.attr = attr;
nitem.ax = nax;
nitem.ay = nay;
nitem.ar = arbase;
tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
axbase = nax;
aybase = nay;
}
if(lockNum == 0)
{
nNum--;
}
prePtr = nextPtr;
nextPtr++;
}
break;
}
else
{
break;
}
}
}while(1);
for (int s = 0; s <= lockNeedles; s++)//跳到不加锁针的那一针
{
absDataPtr++;
j++;
}
}
runflag = 1;
}
}
else if (absDataPtr->ctrl == DATA_CUTTRD)
{
runflag = 10;
}
else
{
runflag = 0;
}
//结束前或剪线前加锁针
if (absDataPtr->ctrl == DATA_END ||
absDataPtr->ctrl == DATA_NULL ||
j == stepsize-1 ||
absDataPtr->ctrl == DATA_CUTTRD)
{
int m = 1;
//结束前或剪线前加锁针
DsAbsItem * prePtr = absDataPtr-1; // 上一个点
u8 ctl = prePtr->ctrl;
while(ctl != DATA_SEWING)
{
prePtr--;
m++;
ctl = prePtr->ctrl;
if(prePtr == pData)//起始地址
{
return -1;
}
}
// 添加锁针
int nst = 1;
if(mode == MODE_LOCK)//锁针方式
{
do
{
if(j-m-nst > 0)
{
DsAbsItem * lockPtr = prePtr; // 要加锁针的点
if (lockPtr->ctrl == DATA_SEWING)
{
DsAbsItem nitem;
memset(&nitem,0,sizeof(DsAbsItem));
u8 ctrl = prePtr->ctrl;
u8 attr = 0; // absDataPtr->attr;
double arbase = prePtr->ar;
for (int k = 0; k < lockNum; k++)
{
if(k%2 == 0)
{
for (int s = lockNeedles; s > 0; s--)
{
lockPtr--;
double axbase = lockPtr->ax;
double aybase = lockPtr->ay;
nitem.ctrl = ctrl;
nitem.attr = attr;
nitem.ax = axbase;
nitem.ay = aybase;
nitem.ar = arbase;
tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
}
}
if(k > 0 && k%2 != 0)
{
for (int s = 0; s < lockNeedles; s++)
{
lockPtr++;
double axbase = lockPtr->ax;
double aybase = lockPtr->ay;
nitem.ctrl = ctrl;
nitem.attr = attr;
nitem.ax = axbase;
nitem.ay = aybase;
nitem.ar = arbase;
tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
}
}
}
break;
}
else
{
break;
}
}
}while(1);
}
else if(mode == MODE_THICKEN)//密针方式
{
nst = needles;
//去除要加密针的已添加的针步
tgtdsdat.remove(tgtdsdat.size()-needles*sizeof(DsAbsItem),needles*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; // 加锁针点
if (lockPtr->ctrl == DATA_SEWING)
{
DsAbsItem nitem;
memset(&nitem,0,sizeof(DsAbsItem));
u8 ctrl = prePtr->ctrl;
u8 attr = 0; // absDataPtr->attr;
double arbase = prePtr->ar;
for (int s = 0; s < lockNeedles; s++)
{
DsAbsItem * nextPtr = lockPtr+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++;
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;
nitem.ctrl = ctrl;
nitem.attr = attr;
nitem.ax = nax;
nitem.ay = nay;
nitem.ar = arbase;
tgtdsdat.append((char*)(&nitem), sizeof(DsAbsItem));
axbase = nax;
aybase = nay;
}
if(lockNum == 0)
{
nNum--;
}
lockPtr++;
}
break;
}
else
{
break;
}
}
}while(1);
}
}
tgtdsdat.append((char*)absDataPtr, sizeof(DsAbsItem));
absDataPtr++;
}
m_embAbsData.clear();
m_embAbsData = tgtdsdat;
m_editedflag = 1;
return 0;
}
//角度修正
int EmbData::angleCorrection(s16 oft)
{
if (oft != 0)
{
s32 dx, dy, dr;
double ax, ay, ar;
int 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; //中间数据针步
double addx,addy;
addx = addy = 0;
double s = 0;
// 数据区
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;
}
//判断夹角是否大于60度
if(dr >= ANGLECORR || dr <= -ANGLECORR)
{
s = sqrt(bdx*bdx + bdy*bdy);
if(s == 0)
{
addx = 0;
addy = 0;
}
else
{
addx = bdx*oft/s;
addy = bdy*oft/s;
}
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++;
}
}
return 0;
}
int EmbData::angleCorrectionXY(s32 px, s32 nx, s32 py, s32 ny)
{
if(px == 0 && nx == 0 && py == 0 && ny == 0)
{
return -1;
}
s32 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;
}
DsAbsItem * pData = (DsAbsItem *)(m_embAbsData.data() + sizeof(DataDs16FileHead));
DsAbsItem * absDataPtr = pData; //中间数据针步
double addx,addy;
addx = addy = 0;
// 数据区
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;
}
//判断夹角是否大于60度
if(dr >= ANGLECORR || dr <= -ANGLECORR)
{
if(dx > 0)
{
addx = px;
}
else if(dx == 0)
{
DsAbsItem * prePtr = absDataPtr-1;
double prex = prePtr ->ax;
while(prex == absDataPtr->ax)
{
prePtr--;
prex = prePtr->ax;
if(prePtr == pData)
{
break;
}
}
s32 cx = prex - absDataPtr->ax;
if(cx < 0)
{
addx = px;
}
else
{
addx = 0 - nx;
}
}
else
{
addx = 0 - nx;
}
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;
}
}
s32 cy = prey - absDataPtr->ay;
if(cy < 0)
{
addy = py;
}
else
{
addy = 0 - ny;
}
}
else
{
addy = 0 - ny;
}
absDataPtr--;
if(absDataPtr->ctrl == DATA_SEWING)
{
absDataPtr->ax += addx;
absDataPtr->ay += addy;
}
absDataPtr++;
}
ax = absDataPtr->ax;
ay = absDataPtr->ay;
ar = absDataPtr->ar;
absDataPtr++;
}
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_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));
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,ar;
prex = prey = curx = cury = dx = dy = ar = 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);
ar = (tar*10000+0.5*(tar>0?1:-1));
absDataPtr->ar = 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;
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);
}
//移动起始点，左边，前边
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;
m_maxX += left;
m_minX += left;
m_maxY += front;
m_minY += front;
memcpy(m_embDs16Data.data(),(char*)m_pEmbDs16Head,sizeof(DataDs16FileHead));
return 0;
}
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)
{
if (m_editedflag != 0)
{
createEmbDs16FromAbs();
}
posx = 0;
posy = 0;
colorIdx = 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;
colorIdx = 1;
if (stitchIdx <= 0)
{
return 0;
}
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;
if (ctrl == DATA_CHGND)
{
colorIdx++;
}
if ((attr&0x80) != 0)
{
dx *= -1;
}
if ((attr&0x40) != 0)
{
dy *= -1;
}
posx += dx;
posy += dy;
ds16DataPtr++;
}
return 0;
}
//设置起始点
void EmbData::setStartPosition(int x, int y)
{
if(m_pEmbDs16Head == NULL){return;}
if(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;
//修复偶尔点击中间按钮花样消失的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::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(int mirror)
{
if (mirror == 0) // 0, 无镜像; 1, 水平镜像; 2, 垂直镜像; 3, 水平和垂直镜像
{
return 0;
}
int mirrorx = 1; //x轴
int mirrory = 1; //y轴
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;
}
// 文件头
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());
//在最大最小xy中 对起始点进行镜像处理
int bx = pDsHead->beginX;
int by = pDsHead->beginY;
if(mirrorx == -1)
pDsHead->beginX = pDsHead->maxX - (bx - pDsHead->minX);
if(mirrory == -1)
pDsHead->beginY = pDsHead->maxY - (by - pDsHead->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;
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;
}
//flag :true代表顺时针方向
int EmbData::setRotate90(bool flag)
{
// 文件头
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());
int maxX = pDsHead->maxX;
int maxY = pDsHead->maxY;
int bx = pDsHead->beginX;
int by = pDsHead->beginY;
if(flag){ //正向旋转90
pDsHead->beginX = maxY - by;
pDsHead->beginY = bx;
}
else{
pDsHead->beginX = by;
pDsHead->beginY = maxX - bx;
}
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;
int rx, ry;
if(flag){ //正向旋转90
rx = -ay;
ry = ax;
}else{
rx = ay;
ry = -ax;
}
absDataPtr->ax = rx;
absDataPtr->ay = ry;
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;
}
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(0)
QString ds16FilePath = m_filePath + ".ds16";
QFile file(ds16FilePath);
if(file.exists())//存在ds16文件
{
if(!file.open(QIODevice::ReadOnly))
{
qDebug() << "open file fail when read, path =" << m_filePath;
return -1;
}
m_embDs16Data = file.readAll();
file.close();
if(m_embDs16Data.size() <= 0)
{
return -1;
}
memcpy(m_pEmbDs16Head, m_embDs16Data.data(), sizeof(DataDs16FileHead)); // 文件名称
m_minX = m_pEmbDs16Head->minX;
m_maxX = m_pEmbDs16Head->maxX;
m_minY = m_pEmbDs16Head->minY;
m_maxY = m_pEmbDs16Head->maxY;
m_beginX = m_pEmbDs16Head->beginX;
m_beginY = m_pEmbDs16Head->beginY;
m_editedflag = 0;
return 0;
}
#endif
if (m_editedflag != 0)
{
m_minX = S32_MAX;
m_maxX = S32_MIN;
m_minY = S32_MAX;
m_maxY = S32_MIN;
m_embDs16Data.clear();
QString name;
QByteArray tgtdsdat;
tgtdsdat.clear();
u8 ctrlByte;
u8 attrByte;
WORD actionWord; //附加动作
s32 dx, dy, dr;
u16 len;
double ax, ay, ar;
int actx, acty, actr;
int ddx, ddy,ddr;
int beginx, beginy, beginr, anchorx, anchory;
int minx, miny, maxx, maxy;
int colornum = 1;
int jumpNeedleNum = 0;//跳针数
actx = 0;
acty = 0;
actr =0;
beginx = 0;
beginy = 0;
beginr = 0;
anchorx = anchory = 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());
//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;
// 数据区
qDebug()<<"stepsize:"<<stepsize;
for (int j = 0; j < stepsize; j++)
{
Ds16Item ds16Item;
memset(&ds16Item,0,sizeof(Ds16Item));//清空ds16针步
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 (j == 0)//第一针
{
beginx = ax;
beginy = ay;
beginr = ar;
actx = ax;
acty = ay;
actr = ar;
anchorx = pDsHead->anchorX;
anchory = pDsHead->anchorY;
ddx = 0;
ddy = 0;
//让ddr等于0，因为在datafiledsr中将beginR置为0而非第一针的角度，所以不应该用 absDataPtr->ar - pDsHead->beginR
//如果beginR等于第一针的角度，那么第一针的ddr就应该是0
ddr = 0;
//过滤掉空针
if(ddx== 0 && ddy == 0)
{
actx += ddx;
acty += ddy;
actr += ddr;
absDataPtr++;
continue;
}
}
else
{
ddx = ax - actx;
ddy = ay - acty;
ddr = ar -actr;
}
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 && (ctrlByte == DATA_END || ctrlByte == DATA_NULL))
{
qDebug()<< "增加剪线" <<j;
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++;
}
//分割针步
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)
{
s16 addx,addy;
addx = addy = 0;
//分割针步
double splitVal = 400.0;//分割针步为400
s32 stepNum = xyLen / splitVal;//拆分几步
double lastStep = (double)((int)xyLen % (int)splitVal);
double addStep = lastStep / stepNum;
double stepX = 0;
double stepY = 0;
double stepDr = 0;
for(int m = 0; m < stepNum; m++)
{
stepX = 0;
stepY = 0;
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;
}
else
{
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));
tgtdsdat.append((char*)(&ds16Item), sizeof(Ds16Item));//ds16针步
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);
qDebug()<< "newstepnum" <<newstepnum;
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 = anchorx; // 定位点坐标X
m_pEmbDs16Head->anchorY = anchory; // 定位点坐标Y, 设置为0，作为基准
m_pEmbDs16Head->beginX = beginx; // 数据起点坐标X
m_pEmbDs16Head->beginY = beginy; // 数据起点坐标Y
m_pEmbDs16Head->beginR = beginr; // 数据起点坐标R //-rq
m_pEmbDs16Head->minX = m_minX;
m_pEmbDs16Head->maxX = m_maxX;
m_pEmbDs16Head->minY = m_minY;
m_pEmbDs16Head->maxY = m_maxY; // 轮廓范围，使用重新计算之后的值
//中间数据的文件头
// 添加文件头
m_embDs16Data.append((char*)m_pEmbDs16Head, sizeof(DataDs16FileHead));//ds16头文件存在ds16中
// 添加文件数据
m_embDs16Data.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_embDs16Data);
file.close();
}
#endif
}
m_editedflag = 0;
return 0;
}
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);
}
void EmbData::drawFork(int x, int y, QPainter &painter, int index, bool isDraw)
{
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;
if(isDraw){
//绘制深灰色画笔
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::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::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(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;
}
//设置视图尺寸(透明背景)
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 (m_dispMode == DISP_EXECING)
{
drawImageByDispFile();
}
}
void EmbData::reDraw()
{
drawImageByDispFile();
}
//创建显示用的数据（为了快速显示）
int EmbData::createDispFromEmbDs16Dat(QByteArray &ds16dat)
{
if(m_type == MACHINE_FIVEHEADPRECISIONSEWING)
return createDispFromEmbDs16DatForHeadInfo(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 (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(ctrlByte ==DATA_OFFSET) //跨步(偏移)针步另一钟颜色显示
dispItem.rgb = rgbColorYel;
else
dispItem.rgb = rgbColorBlue;
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;
}
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 = rgbColorYel;
else
dispItem.rgb = rgbColorGreen;
m_headDispDate.append(dispItem);
ds16DataPtr++;
}
qDebug("CreateDispFromEmbDs16, stepsize=%d", m_headDispDate.size());
return 0;
}
#define DRAWDR 0
int EmbData::drawImageByDispFile()
{
if(m_type == MACHINE_FIVEHEADPRECISIONSEWING)
return drawImageByOneStepLotLine();
int bx, by, ex, ey, ar;
bx = by = ex = ey = ar = 0;
int i;
u8 ctrlByte;
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);
QRgb rgb;
QPen pen;
//笔宽
pen.setWidth(1);
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);
}
bx = pDispBuff[i].bx;
by = pDispBuff[i].by;
ex = pDispBuff[i].ex;
ey = pDispBuff[i].ey;
rgb = pDispBuff[i].rgb;
ctrlByte = pDispBuff[i].ctrl;
// 从开始到 m_stitchIndex 显示正常颜色的线迹（执行过），从 m_stitchIndex 结束显示未缝纫颜色线迹（未执行）
if ((dispmode == DISP_ALL_EXEC) && (i >= m_stitchIndex))
{
if(ctrlByte ==DATA_OFFSET) //跨步(偏移)针步另一钟颜色显示
rgb = rgbColorYel;
else
rgb = rgbColorGreen;
}
pen.setColor(rgb);
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)
{
i = m_stitchIndex;
bx = pDispBuff[i].bx;
by = pDispBuff[i].by;
drawFork(bx, by, painter);//绘制准星
m_dispIndex = m_stitchIndex; // 移动显示指针
}
}
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) // 显示为原线迹
{
bx = pDispBuff[i].bx;
by = pDispBuff[i].by;
ex = pDispBuff[i].ex;
ey = pDispBuff[i].ey;
rgb = pDispBuff[i].rgb;
pen.setColor(rgb);
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;
rgb = pDispBuff[i].rgb;
ctrlByte = pDispBuff[i].ctrl;
if(ctrlByte ==DATA_OFFSET) //跨步(偏移)针步另一钟颜色显示
rgb = rgbColorYel;
else
rgb = rgbColorGreen;
pen.setColor(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);//绘制跟踪笔
m_dispIndex = m_stitchIndex; // 移动显示指针
}
}
return 0;
}
#include <bitset>
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 = rgbColorYel;
else
rgb = rgbColorGreen;
}
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 = rgbColorYel;
else
rgb = rgbColorBlue;
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;
}
/**
* @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, true);//绘制准星
else
{
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, iswork.test(j));//绘制准星
}
}
}
///
/// \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(rgbColorYel);
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);
}
}
}
Reference in New Issue Copy Permalink