1298 lines
35 KiB
C++
1298 lines
35 KiB
C++
#include "datafilequix.h"
|
||
|
||
|
||
DataFileQuix::DataFileQuix()
|
||
{
|
||
clear();
|
||
}
|
||
|
||
void DataFileQuix::convertDataToEmbAbs(s16 flag)
|
||
{
|
||
m_absData.clear();
|
||
getQuixMinMax();
|
||
|
||
QuixFileHead head;
|
||
|
||
// 图形数据
|
||
u32 i, datasize, idx;
|
||
unsigned char ctrl, tmpls;
|
||
|
||
u8 c1, c2, c3, c4;
|
||
u32 lsdata;
|
||
double deltx1, delty1, deltx2, delty2;
|
||
double threex[4], threey[4];
|
||
s16 nmstep;
|
||
|
||
double factorx, factory, unitmuti;
|
||
memcpy(&head, m_fileData.data(), sizeof(QuixFileHead));
|
||
unitmuti = getMutiUnit(0);
|
||
|
||
double scanx = head.scanX * unitmuti; // 宽度
|
||
double scany = head.scanY * unitmuti; // 长度
|
||
|
||
if (scanx < 1)
|
||
{
|
||
scanx = 1;
|
||
}
|
||
if (scany < 1)
|
||
{
|
||
scany = 1;
|
||
}
|
||
|
||
// 计算缩放系数
|
||
factorx = (double)((m_maxX-m_minX) / (scanx));
|
||
factory = (double)((m_maxY-m_minY) / (scany));
|
||
|
||
if(factorx == 0){factorx = 1;}
|
||
if(factory == 0){factory = 1;}
|
||
// factorx = 1;
|
||
// factory = 1;
|
||
|
||
if(flag != 1)
|
||
{
|
||
factorx = 1;
|
||
factory = 1;
|
||
}
|
||
|
||
nmstep = head.normalStep * unitmuti;
|
||
if(nmstep == 0)
|
||
{
|
||
nmstep = 200; //单位0.01mm（2mm）
|
||
}
|
||
|
||
i = sizeof(QuixFileHead);
|
||
datasize = m_fileData.size();
|
||
|
||
DsAbsItem absItem;
|
||
memset(&absItem,0,sizeof(DsAbsItem));
|
||
|
||
//将第一个点加进来
|
||
absItem.ctrl = m_firstPoint.ctrl;
|
||
absItem.ax = m_firstPoint.x / factorx;
|
||
absItem.ay = m_firstPoint.y / factory;
|
||
m_absData.append((char*)&absItem,sizeof(DsAbsItem));
|
||
|
||
while(i < datasize)
|
||
{
|
||
// 功能控制字
|
||
if (i >= datasize){break;}
|
||
ctrl = m_fileData.at(i++);
|
||
|
||
// 图元类型
|
||
if (i >= datasize){break;}
|
||
tmpls = m_fileData.at(i++);
|
||
|
||
// 附加控制字
|
||
if (i >= datasize){break;}
|
||
m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
m_fileData.at(i++);
|
||
|
||
if(ctrl == 0x00) // 结束
|
||
{
|
||
break;
|
||
}
|
||
|
||
switch(tmpls)
|
||
{
|
||
case QUI_TYPE_LINE: // 直线
|
||
case QUI_TYPE_STEP: // 跨步
|
||
case QUI_TYPE_HSTEP: // 翻头跨步
|
||
{
|
||
//增加剪线
|
||
if(tmpls == QUI_TYPE_STEP || tmpls == QUI_TYPE_HSTEP)
|
||
{
|
||
if((u32)m_absData.size() >= sizeof(DsAbsItem))
|
||
{
|
||
memcpy((char*)&absItem,m_absData.data()+m_absData.size()-sizeof(DsAbsItem),sizeof(DsAbsItem));
|
||
absItem.ctrl = DATA_CUTTRD;
|
||
m_absData.append((char*)&absItem,sizeof(DsAbsItem));
|
||
}
|
||
}
|
||
|
||
// 点个数
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
|
||
if (lsdata > 1)
|
||
{
|
||
// 第一个点
|
||
//点x
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
double x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
deltx2 = x/factorx;
|
||
|
||
//点y
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
double y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
delty2 = y/factory;
|
||
|
||
for(idx = 1; idx < lsdata; idx++) // 其余的点
|
||
{
|
||
deltx1 = deltx2;
|
||
delty1 = delty2;
|
||
|
||
//点x
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
deltx2 = x/factorx;
|
||
|
||
//点y
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
delty2 = y/factory;
|
||
|
||
// 处理直线
|
||
calcLine(deltx1, delty1, deltx2, delty2, nmstep, m_absData, tmpls);
|
||
}
|
||
|
||
if (idx != lsdata)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case QUI_TYPE_ARC: // 三点圆弧
|
||
{
|
||
// 点个数
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
if(lsdata != 3)
|
||
{
|
||
break;
|
||
}
|
||
|
||
for (idx = 0; idx < lsdata; idx++)
|
||
{
|
||
//点x
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
double x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
threex[idx] = x/factorx;
|
||
|
||
//点y
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
double y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
threey[idx] = y/factory;
|
||
}
|
||
|
||
calcCurve(threex, threey, nmstep, m_absData);
|
||
|
||
if (idx != 3)
|
||
{
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
case QUI_TYPE_BES: // 贝塞尔曲线
|
||
{
|
||
// 点个数
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
if(lsdata != 4)
|
||
{
|
||
break;
|
||
}
|
||
|
||
for (idx = 0; idx < lsdata; idx++)
|
||
{
|
||
//点x
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
double x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
threex[idx] = x/factorx;
|
||
|
||
//点y
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
double y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
threey[idx] = y/factory;
|
||
}
|
||
|
||
// 处理贝塞尔曲线
|
||
QList<QPointF> splineListXY;//拟合后的点
|
||
splineListXY.clear();
|
||
getBezierPointList(threex, threey, nmstep,splineListXY);
|
||
|
||
QList<QPointF> splitListXY;//均分后的点
|
||
splitListXY.clear();
|
||
if(splineListXY.size() > 0)
|
||
{
|
||
getCurvePointFillLine(splineListXY,nmstep,splitListXY,0,OBJECT_STITCHLEN_NEW_SAMALL);
|
||
}
|
||
|
||
//添加贝塞尔曲线数据点
|
||
for(int i = 0; i < splitListXY.size(); i++)
|
||
{
|
||
memset(&absItem,0,sizeof(DsAbsItem));
|
||
|
||
deltx1 = splitListXY[i].x();
|
||
delty1 = splitListXY[i].y();
|
||
|
||
absItem.ctrl = DATA_SEWING;
|
||
absItem.ax = deltx1;
|
||
absItem.ay = delty1;
|
||
m_absData.append((char*)&absItem,sizeof(DsAbsItem));
|
||
}
|
||
//calcBezier(threex, threey, nmstep, m_absData);
|
||
|
||
if (idx != 4)
|
||
{
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
case QUI_TYPE_SPLINE: // 样条
|
||
{
|
||
QList<QPointF> quiListPoint;//样条拟合前的点集合
|
||
quiListPoint.clear();
|
||
|
||
// 点个数
|
||
if (i >= datasize){break;}
|
||
unsigned char c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
unsigned char c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
unsigned char c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
unsigned char c4 = m_fileData.at(i++);
|
||
lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
|
||
for(idx = 0; idx < lsdata; idx++) // 点
|
||
{
|
||
//点x
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
double x = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
deltx1 = x/factorx;
|
||
|
||
//点y
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
double y = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
delty1 = y/factory;
|
||
|
||
QPointF point(deltx1,delty1);
|
||
quiListPoint.append(point);
|
||
}
|
||
|
||
QList<QPointF> splineListXY;//拟合后的点
|
||
splineListXY.clear();
|
||
if(quiListPoint.size() <= 0)
|
||
{
|
||
break;
|
||
}
|
||
getSplineNew(quiListPoint,splineListXY);
|
||
|
||
// 均分
|
||
QList<QPointF> splitListXY;//均分后的点
|
||
splitListXY.clear();
|
||
if(splineListXY.size() > 0)
|
||
{
|
||
getCurvePointFillLine(splineListXY,nmstep,splitListXY,0,OBJECT_STITCHLEN_NEW_SAMALL);
|
||
}
|
||
|
||
//添加样条曲线数据点
|
||
for(int i = 0; i < splitListXY.size(); i++)
|
||
{
|
||
memset(&absItem,0,sizeof(DsAbsItem));
|
||
|
||
deltx1 = splitListXY[i].x();
|
||
delty1 = splitListXY[i].y();
|
||
|
||
absItem.ctrl = DATA_SEWING;
|
||
absItem.ax = deltx1;
|
||
absItem.ay = delty1;
|
||
m_absData.append((char*)&absItem,sizeof(DsAbsItem));
|
||
}
|
||
|
||
if(idx != lsdata)
|
||
{
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
//生成绝对坐标数据的文件头
|
||
creatAbsHeadAndAr();
|
||
}
|
||
|
||
void DataFileQuix::creatAbsHeadAndAr()
|
||
{
|
||
DataDs16FileHead dhead;
|
||
memset(&dhead, 0, sizeof(DataDs16FileHead));
|
||
|
||
int stepSize = m_absData.size()/sizeof(DsAbsItem);
|
||
if(stepSize <= 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
DsAbsItem * absDataPtr = (DsAbsItem *)(m_absData.data());
|
||
|
||
double minX, maxX, minY, maxY;
|
||
minX = S32_MAX;
|
||
maxX = S32_MIN;
|
||
minY = S32_MAX;
|
||
maxY = S32_MIN;
|
||
|
||
double prex,prey,curx,cury,dx,dy,ar;
|
||
prex = prey = curx = cury = dx = dy = ar = 0;
|
||
|
||
//取反并求最大最小值
|
||
for (int i = 0; i < stepSize; i++)
|
||
{
|
||
absDataPtr->ax *= QUIX_DATADIRX;
|
||
absDataPtr->ay *= QUIX_DATADIRY;
|
||
|
||
curx = absDataPtr->ax;
|
||
cury = absDataPtr->ay;
|
||
|
||
if(curx > maxX)
|
||
{
|
||
maxX = curx;
|
||
}
|
||
if(curx < minX)
|
||
{
|
||
minX = curx;
|
||
}
|
||
|
||
if(cury > maxY)
|
||
{
|
||
maxY = cury;
|
||
}
|
||
if(cury < minY)
|
||
{
|
||
minY = cury;
|
||
}
|
||
|
||
absDataPtr++;
|
||
}
|
||
|
||
absDataPtr = (DsAbsItem *)(m_absData.data());
|
||
double begX = absDataPtr->ax;//起始点
|
||
double begY = absDataPtr->ay;
|
||
int begR = 0;
|
||
|
||
//求dr并将每点坐标都减去第一点坐标
|
||
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;
|
||
|
||
prex = curx;
|
||
prey = cury;
|
||
|
||
//将每个坐标都减去起始点坐标
|
||
absDataPtr->ax -= begX;
|
||
absDataPtr->ay -= begY;
|
||
absDataPtr->ar -= begR;
|
||
|
||
absDataPtr++;
|
||
}
|
||
|
||
//增加结束码
|
||
if((u32)m_absData.size() >= sizeof(DsAbsItem))
|
||
{
|
||
DsAbsItem absItem;
|
||
memset(&absItem,0,sizeof(DsAbsItem));
|
||
memcpy((char*)&absItem,m_absData.data()+m_absData.size()-sizeof(DsAbsItem),sizeof(DsAbsItem));
|
||
absItem.ctrl = DATA_NULL;
|
||
m_absData.append((char*)&absItem,sizeof(DsAbsItem));
|
||
stepSize++;
|
||
}
|
||
|
||
m_maxX = maxX-begX;
|
||
m_minX = minX-begX;
|
||
m_maxY = maxY-begY;
|
||
m_minY = minY-begY;
|
||
|
||
//生成文件头
|
||
dhead.maxX = maxX;
|
||
dhead.maxY = maxY;
|
||
dhead.minX = minX;
|
||
dhead.minY = minY;
|
||
dhead.beginX = begX-minX;//起始点减去最小值
|
||
dhead.beginY = begY-minY;//起始点减去最小值
|
||
dhead.beginR = begR;
|
||
dhead.anchorX = 0;
|
||
dhead.anchorY = 0;
|
||
dhead.itemNums = stepSize;
|
||
dhead.dataSize = stepSize*sizeof(DsAbsItem); // 数据字节数
|
||
dhead.bytesPerItem = sizeof(DsAbsItem); // 每项占的字节数
|
||
dhead.dataChecksum = calcCheckSum32((u8 *)(m_absData.data()) , dhead.dataSize);; // 数据累加校验和
|
||
dhead.checkCrc = calcCrc16((u8 *)(&dhead), HEAD_FIX_INFO_LEN); // 前面6个字段的CRC校验，（6个字段分别为：文件名称，字节数，项个数，每项字节数，每块字节数，数据累加和的CRC校验值）
|
||
dhead.fileid = dhead.checkCrc;
|
||
m_absData.insert(0,(char*)&dhead,sizeof(DataDs16FileHead));
|
||
}
|
||
|
||
void DataFileQuix::getQuixMinMax()
|
||
{
|
||
QuixFileHead head;
|
||
memcpy(&head, m_fileData.data(), sizeof(QuixFileHead));
|
||
|
||
u32 i, idx, datasize;
|
||
unsigned char ctrl, tmpls;
|
||
u8 c1, c2, c3, c4;
|
||
u32 lsdata;
|
||
double deltx, delty;
|
||
double threex[4], threey[4];
|
||
|
||
int first = 0;
|
||
double minx, maxx, miny, maxy;
|
||
|
||
minx = S32_MAX;
|
||
maxx = S32_MIN;
|
||
miny = S32_MAX;
|
||
maxy = S32_MIN;
|
||
|
||
i = sizeof(QuixFileHead);
|
||
datasize = m_fileData.size();
|
||
while(i < datasize)
|
||
{
|
||
// 功能控制字
|
||
if (i >= datasize){break;}
|
||
ctrl = m_fileData.at(i++);
|
||
|
||
// 图元类型
|
||
if (i >= datasize){break;}
|
||
tmpls = m_fileData.at(i++);
|
||
|
||
// 附加控制字
|
||
if (i >= datasize){break;}
|
||
m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
m_fileData.at(i++);
|
||
|
||
if(ctrl == 0x00) // 结束
|
||
{
|
||
break;
|
||
}
|
||
|
||
switch(tmpls)
|
||
{
|
||
case QUI_TYPE_LINE: // 直线(折线)
|
||
case QUI_TYPE_STEP: // 跨步
|
||
case QUI_TYPE_HSTEP: // 翻头跨步
|
||
{
|
||
// 点个数
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
|
||
if (lsdata > 1)
|
||
{
|
||
for(idx = 0; idx < lsdata; idx++) // 点
|
||
{
|
||
//点x
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
deltx = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
|
||
//点y
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
delty = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
|
||
if (first == 0)
|
||
{
|
||
m_firstPoint.x = deltx;
|
||
m_firstPoint.y = delty;
|
||
m_firstPoint.ctrl = ctrl;
|
||
first = 1;
|
||
}
|
||
|
||
if(deltx > maxx)
|
||
{
|
||
maxx = deltx;
|
||
}
|
||
if(deltx < minx)
|
||
{
|
||
minx = deltx;
|
||
}
|
||
|
||
if(delty > maxy)
|
||
{
|
||
maxy = delty;
|
||
}
|
||
if(delty < miny)
|
||
{
|
||
miny = delty;
|
||
}
|
||
}
|
||
if (idx != lsdata)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case QUI_TYPE_ARC: // 三点圆弧
|
||
{
|
||
// 点个数
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
if(lsdata != 3)
|
||
{
|
||
break;
|
||
}
|
||
|
||
for (idx = 0; idx < lsdata; idx++)
|
||
{
|
||
//点x
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
threex[idx] = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
|
||
//点y
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
threey[idx] = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
|
||
if (first == 0)
|
||
{
|
||
m_firstPoint.x = threex[0];
|
||
m_firstPoint.y = threey[0];
|
||
m_firstPoint.ctrl = ctrl;
|
||
first = 1;
|
||
}
|
||
}
|
||
if (idx != 3)
|
||
{
|
||
break;
|
||
}
|
||
|
||
if(isThreePointOnALine(threex, threey) >= 1) // 3点共线
|
||
{
|
||
// printf("three point on a line\n");
|
||
if(threex[0] > maxx) maxx = threex[0];
|
||
if(threex[1] > maxx) maxx = threex[1];
|
||
if(threex[2] > maxx) maxx = threex[2];
|
||
if(threex[0] < minx) minx = threex[0];
|
||
if(threex[1] < minx) minx = threex[1];
|
||
if(threex[2] < minx) minx = threex[2];
|
||
|
||
if(threey[0] > maxy) maxy = threey[0];
|
||
if(threey[1] > maxy) maxy = threey[1];
|
||
if(threey[2] > maxy) maxy = threey[2];
|
||
if(threey[0] < miny) miny = threey[0];
|
||
if(threey[1] < miny) miny = threey[1];
|
||
if(threey[2] < miny) miny = threey[2];
|
||
}
|
||
else
|
||
{
|
||
// printf("before GetArcMinMax\n");
|
||
// printf("minx=%.2f,maxx=%.2f,miny=%.2f,maxy=%.2f\n", minx, maxx, miny, maxy);
|
||
getArcMinMax(threex, threey, &minx, &maxx, &miny, &maxy);
|
||
// printf("after GetArcMinMax\n");
|
||
// printf("minx=%.2f,maxx=%.2f,miny=%.2f,maxy=%.2f\n", minx, maxx, miny, maxy);
|
||
}
|
||
}
|
||
break;
|
||
case QUI_TYPE_BES: // 贝塞尔曲线
|
||
{
|
||
// 点个数
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
if(lsdata != 4)
|
||
{
|
||
break;
|
||
}
|
||
|
||
for (idx = 0; idx < lsdata; idx++)
|
||
{
|
||
//点x
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
threex[idx] = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
|
||
//点y
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
threey[idx] = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
|
||
if (first == 0)
|
||
{
|
||
m_firstPoint.x = threex[0];
|
||
m_firstPoint.y = threey[0];
|
||
m_firstPoint.ctrl = ctrl;
|
||
first = 1;
|
||
}
|
||
}
|
||
if (idx != 4)
|
||
{
|
||
break;
|
||
}
|
||
|
||
getBezierMinMax(threex, threey, &minx, &maxx, &miny, &maxy);
|
||
}
|
||
break;
|
||
case QUI_TYPE_SPLINE: // 样条
|
||
{
|
||
QList<QPointF> quiListPoint;//样条拟合前的点集合
|
||
quiListPoint.clear();
|
||
|
||
// 点个数
|
||
if (i >= datasize){break;}
|
||
unsigned char c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
unsigned char c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
unsigned char c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
unsigned char c4 = m_fileData.at(i++);
|
||
lsdata = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
|
||
for(idx = 0; idx < lsdata; idx++) // 点
|
||
{
|
||
//点x
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
deltx = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
|
||
//点y
|
||
if (i >= datasize){break;}
|
||
c1 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c2 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c3 = m_fileData.at(i++);
|
||
if (i >= datasize){break;}
|
||
c4 = m_fileData.at(i++);
|
||
delty = (c4 << 24) + (c3 << 16) + (c2 << 8) + (c1);
|
||
|
||
QPointF point(deltx,delty);
|
||
quiListPoint.append(point);
|
||
|
||
if (first == 0)
|
||
{
|
||
m_firstPoint.x = deltx;
|
||
m_firstPoint.y = delty;
|
||
m_firstPoint.ctrl = ctrl;
|
||
first = 1;
|
||
}
|
||
}
|
||
getSplineMinMax(quiListPoint, &minx, &maxx, &miny, &maxy);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (first == 0)
|
||
{
|
||
minx = 0;
|
||
maxx = 0;
|
||
miny = 0;
|
||
maxy = 0;
|
||
|
||
m_firstPoint.x = 0;
|
||
m_firstPoint.y = 0;
|
||
m_firstPoint.ctrl = 0;
|
||
}
|
||
|
||
m_minX = minx;
|
||
m_maxX = maxx;
|
||
m_minY = miny;
|
||
m_maxY = maxy;
|
||
|
||
return;
|
||
}
|
||
|
||
int DataFileQuix::checkFileHead()
|
||
{
|
||
if (m_fileData.size() >= (int)sizeof(QuixFileHead))
|
||
{
|
||
QuixFileHead * pHead;
|
||
pHead = (QuixFileHead *)(m_fileData.data());
|
||
|
||
if (pHead->normalStep < 1)
|
||
{
|
||
pHead->normalStep = 40;
|
||
}
|
||
|
||
if (pHead->scanX < 1)
|
||
{
|
||
pHead->scanX = m_maxX - m_minX;
|
||
}
|
||
|
||
if (pHead->scanY < 1)
|
||
{
|
||
pHead->scanY = m_maxY - m_minY;
|
||
}
|
||
|
||
QFile wrfile(m_fileFullPathName);
|
||
if(!wrfile.open(QIODevice::WriteOnly | QIODevice::Truncate))
|
||
{
|
||
return -1;
|
||
}
|
||
else
|
||
{
|
||
wrfile.write(m_fileData);
|
||
wrfile.close();
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
double DataFileQuix::getMutiUnit(int unit)
|
||
{
|
||
double unitmuti;
|
||
if (unit == 0x00) // 0x00: 0.1mm;
|
||
{
|
||
unitmuti = 10;
|
||
}
|
||
else if (unit == 0x01) // 0x01: 1/1000inch;
|
||
{
|
||
unitmuti = 2.54;
|
||
}
|
||
else if (unit == 0x02) // 0x02: 0.04mm
|
||
{
|
||
unitmuti = 10;
|
||
}
|
||
else
|
||
{
|
||
unitmuti = 1;
|
||
}
|
||
return unitmuti;
|
||
}
|
||
|
||
void DataFileQuix::initFile(const QString &fullPathName)
|
||
{
|
||
clear();
|
||
QFileInfo file(fullPathName);
|
||
if (file.exists() && file.isFile())
|
||
{
|
||
m_fileFullPathName = fullPathName;
|
||
}
|
||
else
|
||
{
|
||
qDebug() << "Init file failed path =" << m_fileFullPathName;
|
||
}
|
||
loadFile();
|
||
}
|
||
|
||
void DataFileQuix::clear()
|
||
{
|
||
m_firstPoint.x = 0;
|
||
m_firstPoint.y = 0;
|
||
m_firstPoint.ctrl = 0;
|
||
|
||
m_minX = INT32_MAX;
|
||
m_maxX = INT32_MIN;
|
||
m_minY = INT32_MAX;
|
||
m_maxY = INT32_MIN;
|
||
|
||
m_fileFullPathName.clear(); // 文件路径
|
||
m_fileData.clear(); // 文件数据内容
|
||
m_absData.clear(); // 转换后的数据
|
||
}
|
||
|
||
void DataFileQuix::loadFile()
|
||
{
|
||
QFile rdfile(m_fileFullPathName);
|
||
if(!rdfile.open(QIODevice::ReadOnly))
|
||
{
|
||
qDebug() << "open file fail when read, path =" << m_fileFullPathName;
|
||
return;
|
||
}
|
||
|
||
m_fileData = rdfile.readAll();
|
||
rdfile.close();
|
||
}
|
||
|
||
int DataFileQuix::createPreviewImage(QImage *pImg, int saveflag, int penwidth, int reDraw)
|
||
{
|
||
#if(1)
|
||
s16 existFlag = 1;
|
||
|
||
if(reDraw == 0)//图片存在则不重画
|
||
{
|
||
existFlag = 0;
|
||
// 图片是否存在，存在则返回
|
||
QString previewPath = getFileFullPathName() + ".preview.png";
|
||
QFile imageFile(previewPath);
|
||
if (imageFile.exists())
|
||
{
|
||
return 0;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
int newimgflag = 0;
|
||
QImage * pImage;
|
||
int width, height;
|
||
if (pImg == NULL)
|
||
{
|
||
width = QUIX_PREVIEW_WIDTH;
|
||
height = QUIX_PREVIEW_HEIGHT;
|
||
pImage = new QImage(width, height, IMAGE_TYPE);
|
||
newimgflag = 1;
|
||
}
|
||
else
|
||
{
|
||
pImage = pImg;
|
||
}
|
||
|
||
width = pImage->width();
|
||
height = pImage->height();
|
||
if (width <= QUIX_PREVIEW_SIDE*2 || height <= QUIX_PREVIEW_SIDE*2)
|
||
{
|
||
if (pImage != NULL && newimgflag == 1)
|
||
{
|
||
delete pImage;
|
||
}
|
||
qDebug("preview img too small");
|
||
return -1;
|
||
}
|
||
|
||
memset(pImage->bits(), 0x00, pImage->byteCount());
|
||
|
||
QPainter painter(pImage);
|
||
QColor backcolor(255, 255, 255, 0); // 透明背景
|
||
// 背景
|
||
QPen pen;
|
||
pen.setWidth(penwidth);
|
||
pen.setColor(backcolor);
|
||
painter.setPen(pen);
|
||
painter.setBrush(backcolor);
|
||
painter.drawRect(0, 0, width, height);
|
||
|
||
// 图形
|
||
//qDebug()<<"convertDataToAbs defore";
|
||
convertDataToEmbAbs(existFlag); // 转换为绝对坐标数据
|
||
//qDebug()<<"convertDataToAbs end";
|
||
|
||
// absdat数据
|
||
int size = m_absData.size();
|
||
if (size <= (int)sizeof(DataDs16FileHead))
|
||
{
|
||
qDebug("2 data less then head size");
|
||
return -1;
|
||
}
|
||
DataDs16FileHead * pAbsHead = (DataDs16FileHead *)(m_absData.data());
|
||
int datasize = size - sizeof(DataDs16FileHead);
|
||
if (datasize <= 0)
|
||
{
|
||
qDebug("absdat dataBegin err");
|
||
return -1;
|
||
}
|
||
int stepsize = datasize/sizeof(DsAbsItem);
|
||
if (stepsize <= 0)
|
||
{
|
||
qDebug("absdat data size err");
|
||
return -1;
|
||
}
|
||
DsAbsItem * pData = (DsAbsItem *)(m_absData.data() + sizeof(DataDs16FileHead));
|
||
DsAbsItem * absDataPtr = pData;
|
||
//--------
|
||
|
||
// 图形显示区域
|
||
int dpminx = QUIX_PREVIEW_SIDE;
|
||
int dpmaxx = width - QUIX_PREVIEW_SIDE;
|
||
int dpminy = QUIX_PREVIEW_SIDE;
|
||
int dpmaxy = height - QUIX_PREVIEW_SIDE;
|
||
|
||
// 计算缩放系数
|
||
double factor, temp;
|
||
if ((dpmaxx - dpminx) <= 0 || (dpmaxy - dpminy) <= 0)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
factor = (double)(fabs(m_maxX - m_minX)) / (dpmaxx - dpminx); // 按x计算的缩放系数
|
||
temp = (double)(fabs(m_maxY - m_minY)) / (dpmaxy - dpminy); // 按x计算的缩放系数
|
||
|
||
if (temp >= factor) // 使用较大的缩放系数
|
||
{
|
||
factor = temp;
|
||
}
|
||
|
||
// 计算显示参数，按照图形的实际位置显示（数据坐标零点对应图形中心）
|
||
double dpx = (double)((dpminx+dpmaxx)/2 - ((m_maxX+m_minX)/factor)/2);
|
||
double dpy = (double)((dpminy+dpmaxy)/2 - ((m_maxY+m_minY)/factor)/2);
|
||
|
||
// 显示花样图形
|
||
u8 ctrlByte;
|
||
double dx;
|
||
double dy;
|
||
|
||
double datposx, datposy;
|
||
datposx = datposy = 0.;
|
||
double curx, cury, prex, prey;
|
||
curx = cury = prex = prey = 0;
|
||
|
||
datposx = pAbsHead->beginX;
|
||
datposy = pAbsHead->beginY;
|
||
|
||
curx = (datposx) / factor + dpx;
|
||
cury = (datposy) / factor + dpy;
|
||
|
||
if (QUIX_SHOWDIRX == -1)
|
||
{
|
||
curx = (width)-curx;
|
||
}
|
||
if (QUIX_SHOWDIRY == -1)
|
||
{
|
||
cury = (height)-cury;
|
||
}
|
||
|
||
absDataPtr = pData;
|
||
|
||
QColor color = QColor(Qt::green);
|
||
pen.setColor(color);
|
||
painter.setPen(pen);
|
||
|
||
for (int i = 0; i < stepsize; i++)
|
||
{
|
||
// 读入一个针步数据
|
||
ctrlByte = absDataPtr->ctrl;
|
||
|
||
prex = curx;
|
||
prey = cury;
|
||
|
||
dx = absDataPtr->ax;
|
||
dy = absDataPtr->ay;
|
||
|
||
datposx = dx;
|
||
datposy = dy;
|
||
|
||
curx = (datposx) / factor + dpx;
|
||
cury = (datposy) / factor + dpy;
|
||
|
||
if (QUIX_SHOWDIRX == -1)
|
||
{
|
||
curx = (width)-curx;
|
||
}
|
||
if (QUIX_SHOWDIRY == -1)
|
||
{
|
||
cury = (height)-cury;
|
||
}
|
||
|
||
if(i == 0)
|
||
{
|
||
absDataPtr++;
|
||
continue;
|
||
}
|
||
|
||
if (ctrlByte == DATA_SEWING)
|
||
{
|
||
painter.drawLine(prex, prey, curx, cury);
|
||
}
|
||
else
|
||
{
|
||
//painter.drawLine(prex, prey, curx, cury);
|
||
//qDebug("other type=0x%x", ctrlByte);
|
||
}
|
||
|
||
absDataPtr++;
|
||
}
|
||
|
||
// 保存成文件
|
||
QString preview = getFileFullPathName();
|
||
if (saveflag != 0 && preview.isEmpty() == false)
|
||
{
|
||
#if (1)
|
||
preview += ".preview.png";
|
||
pImage->save(preview, "png");
|
||
#endif
|
||
}
|
||
|
||
if (pImage != NULL && newimgflag == 1)
|
||
{
|
||
delete pImage;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
QuixFileHead *DataFileQuix::getQuixHead()
|
||
{
|
||
if(m_fileData.size() <= 0)
|
||
{
|
||
loadFile();
|
||
}
|
||
|
||
QuixFileHead *head = NULL;
|
||
|
||
int size = m_fileData.size();
|
||
if (size <= (int)(sizeof(QuixFileHead)))
|
||
{
|
||
return head;
|
||
}
|
||
|
||
head = (QuixFileHead *)(m_fileData.data());
|
||
return head;
|
||
}
|
||
|
||
void DataFileQuix::writePatternParaToFile(QuixFileHead *head)
|
||
{
|
||
if(m_fileData.size() <= 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
memcpy(m_fileData.data(),(char*)head,sizeof(QuixFileHead));
|
||
|
||
QFile wfile(m_fileFullPathName);
|
||
if(!wfile.open(QIODevice::WriteOnly | QIODevice::Truncate))
|
||
{
|
||
qDebug() << "open file fail when read, path =" << m_fileFullPathName;
|
||
return;
|
||
}
|
||
|
||
wfile.write(m_fileData);
|
||
wfile.close();
|
||
}
|
||
|
||
void DataFileQuix::moveDataBeginPonit(s32 left, s32 front)
|
||
{
|
||
if((u32)m_absData.size() > sizeof(DataDs16FileHead))
|
||
{
|
||
DataDs16FileHead *dhead = (DataDs16FileHead *)( m_absData.data());
|
||
dhead->beginX += left;
|
||
dhead->beginY += front;
|
||
dhead->maxX += left;
|
||
dhead->minX += left;
|
||
dhead->maxY += front;
|
||
dhead->minY += front;
|
||
}
|
||
}
|
||
|
||
int DataFileQuix::getStitchNums()
|
||
{
|
||
if(m_absData.size() <= 0)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
DataDs16FileHead * pHead = (DataDs16FileHead *)((m_absData.data()));
|
||
return pHead->itemNums;
|
||
}
|
||
|
||
int DataFileQuix::getDatWidth()
|
||
{
|
||
if(m_absData.size() <= 0)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
DataDs16FileHead * pHead = (DataDs16FileHead *)((m_absData.data()));
|
||
return (pHead->maxX - pHead->minX);
|
||
}
|
||
|
||
int DataFileQuix::getDatHeight()
|
||
{
|
||
if(m_absData.size() <= 0)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
DataDs16FileHead * pHead = (DataDs16FileHead *)((m_absData.data()));
|
||
return (pHead->maxY - pHead->minY);
|
||
}
|
||
|
||
int DataFileQuix::getMaxX()
|
||
{
|
||
if(m_absData.size() <= 0)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
DataDs16FileHead * pHead = (DataDs16FileHead *)((m_absData.data()));
|
||
return pHead->maxX;
|
||
}
|
||
|
||
int DataFileQuix::getMinX()
|
||
{
|
||
if(m_absData.size() <= 0)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
DataDs16FileHead * pHead = (DataDs16FileHead *)((m_absData.data()));
|
||
return pHead->minX;
|
||
}
|
||
|
||
int DataFileQuix::getMaxY()
|
||
{
|
||
if(m_absData.size() <= 0)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
DataDs16FileHead * pHead = (DataDs16FileHead *)((m_absData.data()));
|
||
return pHead->maxY;
|
||
}
|
||
|
||
int DataFileQuix::getMinY()
|
||
{
|
||
if(m_absData.size() <= 0)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
DataDs16FileHead * pHead = (DataDs16FileHead *)((m_absData.data()));
|
||
return pHead->minY;
|
||
}
|