EmbHMI/datafile/datafiledst.cpp

1512 lines
40 KiB
C++
Raw Normal View History

2024-02-06 06:27:07 +00:00
#include "datafiledst.h"
DataFileDst::DataFileDst()
{
m_colorNum = 0;//颜色数
m_pColor = NULL;//颜色rgb值
m_beadSequinTable.clear();
m_beadSequinTable.resize(BEADSEQUINTYPE);
memset(m_beadSequinTable.data(),0,m_beadSequinTable.size());
m_beadSequinMap.clear();
m_beadSequinMap.resize(BEADSEQUINTYPE);
memset(m_beadSequinMap.data(),0,m_beadSequinMap.size());
}
DataFileDst::~DataFileDst()
{
}
void DataFileDst::initColor(int cnum, QRgb *pColor)
{
m_colorNum = cnum;//颜色数
m_pColor = pColor;//颜色rgb值
qDebug()<<"m_colorNum"<<m_colorNum;
}
void DataFileDst::clear()
{
m_fileFullPathName.clear(); // 文件路径
m_fileData.clear(); // 文件数据内容
m_embAbsData.clear(); // 转换后的数据
}
void DataFileDst::initFile(const QString &fullPathName)
{
clear();
QFileInfo file(fullPathName);
if (file.exists() && file.isFile())
{
m_fileFullPathName = fullPathName;
m_fileName = fullPathName;
qDebug()<<"m_fileFullPathName 1"<<m_fileFullPathName;
}
else
{
qDebug() << "Init file failed path =" << m_fileFullPathName;
}
}
void DataFileDst::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();
return;
}
void DataFileDst::saveFile()
{
QFile wrfile(m_fileFullPathName);
if(!wrfile.open(QIODevice::WriteOnly | QIODevice::Truncate))
{
qDebug() << "open file fail when wirte, path =" << m_fileFullPathName;
return;
}
else
{
wrfile.write(m_fileData);
#ifdef Q_OS_LINUX
system("sync");
#endif
wrfile.close();
}
return;
}
// 文件所在目录
QString DataFileDst::getFileFullPath()
{
QFileInfo file(m_fileFullPathName);
return file.absoluteFilePath();
}
// 文件名称(包括扩展名)
QString DataFileDst::getFileFullName()
{
QFileInfo file(m_fileFullPathName);
return file.fileName();
}
// 文件名称(不包括扩展名)
QString DataFileDst::getFileName()
{
QFileInfo file(m_fileFullPathName);
return file.completeBaseName();
}
// 文件扩展名
QString DataFileDst::getFileSuffix()
{
QFileInfo file(m_fileFullPathName);
return file.suffix();
}
int DataFileDst::getStitchNums()
{
if(m_embAbsData.size() <= 0)
{
return 0;
}
DataDs16FileHead * pDstHead = (DataDs16FileHead *)((m_embAbsData.data()));
return pDstHead->itemNums;
}
int DataFileDst::getColorNums()
{
if(m_embAbsData.size() <= 0)
{
return 0;
}
DataDs16FileHead * pDstHead = (DataDs16FileHead *)((m_embAbsData.data()));
return pDstHead->colorNum;
}
//测试fileid用目前这个函数没用到
int DataFileDst::getFileid()
{
if(m_embAbsData.size() <= 0)
{
return 0;
}
DataDs16FileHead * pDstHead = (DataDs16FileHead *)((m_embAbsData.data()));
return pDstHead->fileid;
}
int DataFileDst::getDatWidth()
{
if(m_embAbsData.size() <= 0)
{
return 0;
}
DataDs16FileHead * pDstHead = (DataDs16FileHead *)((m_embAbsData.data()));
return (pDstHead->maxX - pDstHead->minX);
}
int DataFileDst::getDatHeight()
{
if(m_embAbsData.size() <= 0)
{
return 0;
}
DataDs16FileHead * pDstHead = (DataDs16FileHead *)((m_embAbsData.data()));
return (pDstHead->maxY - pDstHead->minY);
}
int DataFileDst::getMaxX()
{
if(m_embAbsData.size() <= 0)
{
return 0;
}
DataDs16FileHead * pDstHead = (DataDs16FileHead *)((m_embAbsData.data()));
return pDstHead->maxX;
}
int DataFileDst::getMinX()
{
if(m_embAbsData.size() <= 0)
{
return 0;
}
DataDs16FileHead * pDstHead = (DataDs16FileHead *)((m_embAbsData.data()));
return pDstHead->minX;
}
int DataFileDst::getMaxY()
{
if(m_embAbsData.size() <= 0)
{
return 0;
}
DataDs16FileHead * pDstHead = (DataDs16FileHead *)((m_embAbsData.data()));
return pDstHead->maxY;
}
int DataFileDst::getMinY()
{
if(m_embAbsData.size() <= 0)
{
return 0;
}
DataDs16FileHead * pDstHead = (DataDs16FileHead *)((m_embAbsData.data()));
return pDstHead->minY;
}
int DataFileDst::getJumpNeedleNum()
{
if(m_embAbsData.size() <= 0)
{
return 0;
}
DataDs16FileHead * pDstHead = (DataDs16FileHead *)((m_embAbsData.data()));
return pDstHead->jumpNeedleNum;
}
// 设置珠片码对应表
int DataFileDst::setBeadSequinTable(u8 * val)
{
if(val == NULL)
{
return -1;
}
memcpy(m_beadSequinTable.data(),(char*)val,m_beadSequinTable.size());
return 0;
}
// 得到有效珠片码的位图
int DataFileDst::getBeadSequinMap(QByteArray & map)
{
if(m_embAbsData.size() <= 0)
{
return 0;
}
map.append(m_beadSequinMap);
return 0;
}
// 转换为绝对坐标数据,同时得到最大最小值
void DataFileDst::convertDataToAbs()
{
QByteArray ds4Data;//相对坐标
m_embAbsData.clear();
loadFile(); // 如果数据未读取,重新读取
int size = m_fileData.size();
if (size <= (int)(sizeof(DstHead)))
{
qDebug("dst size less then headsize");
return;
}
// int dstHeadSize = sizeof(DstHead);
// qDebug()<<"dstHeadSize"<<dstHeadSize;
size -= sizeof(DstHead);
int stepsize = size/sizeof(DstStep);
if (stepsize <= 0)
{
qDebug("dst data size err");
return;
}
DstHead * pDstHead = (DstHead *)((m_fileData.data()));
DstStep * dstDataBeg = (DstStep *)((m_fileData.data() + sizeof(DstHead)));
DstStep * dstDataPtr = dstDataBeg;
//qDebug()<<"Ds4Item begin";
// 绝对坐标数据
DataDs16FileHead dhead;
memset(&dhead, 0, sizeof(DataDs16FileHead));
Ds4Item * pData = new Ds4Item[stepsize*2];
if (pData == NULL)
{
qDebug("new DsAbsItem failed, size=%d", stepsize);
return;
}
Ds4Item ds4Item;
Ds4Item bds4Item; // 上一针数据
u8 bctrl,jctrl,ctrl;
int dxy;
int rslt;
int colornum = 1;
u32 jumpNum = 0; // 连续跳针的个数
u32 jumpNeedleNum = 0;
bctrl = 0;
u32 openSequin = 0; // 开关亮片码状态
u32 zeroJump = 0; // 空跳个数
//int predr,curdr;
//predr = curdr = 0.0;
// 得到最大最小值, 同时转换为相对坐标数据
int i = 0;
int stepidx = 0;
do
{
if (i < stepsize)
{
rslt = changeDstStep(dstDataPtr, ds4Item);//三字节针步转换
if (rslt >= 0)
{
ctrl = ds4Item.ctrl;
dxy = ((ds4Item.dx == 0) && (ds4Item.dy == 0))? 0:1;
jctrl = ctrl; // 跳针属性临时寄存
if (ctrl == DATA_EMB)
{// 运针
if (i == 0)
{// 第1针特殊处理
if (dxy == 0)
{// 第1针为空针转换为跳针为了避免第1针锁针添加失败
ctrl = DATA_JUMP;
ds4Item.ctrl = DATA_JUMP;
}
else
{
{ // 第1针为入针则向后扫描如果第二针也是运针则将第1针入针转换为跳针
DstStep * ndstDataPtr = dstDataPtr;
Ds4Item nds4Item; // 下一针数据
ndstDataPtr++;
rslt = changeDstStep(ndstDataPtr, nds4Item); //三字节针步转换
if (rslt != 0)
{
break;
}
if (nds4Item.ctrl == DATA_EMB)
{
ctrl = DATA_JUMP;
ds4Item.ctrl = DATA_JUMP;
}
}
{ // 第1针为入针则向后扫描如果有连续的3个以上跳针(或1个以上空跳)则将第1针入针转换为跳针
int count = 0;
DstStep * ndstDataPtr = dstDataPtr;
Ds4Item nds4Item; // 下一针数据
do
{
ndstDataPtr++;
rslt = changeDstStep(ndstDataPtr, nds4Item); //三字节针步转换
if (rslt != 0)
{
break;
}
if (nds4Item.ctrl == DATA_JUMP)
{
count++;
if ((nds4Item.dx == 0) && (nds4Item.dy == 0))
{
count += 2;
}
}
else
{
break;
}
if (count >= 3)
{
break;
}
}while(1);
if (count >= 3)
{
ctrl = DATA_JUMP;
ds4Item.ctrl = DATA_JUMP;
}
}
}
}
else if (((i == 1) && (sqrt(ds4Item.dx*ds4Item.dx+ds4Item.dy*ds4Item.dy) >= 60)) || // 第2针时,如果当前针位移大于6mm,下1针是运针,当前针转换为跳针
(bctrl == DATA_CHGND) || // 上1针为换色码时,如果下1针是运针,则当前针改为跳针
(jumpNum >= 2) || // 前面连续2个以上跳针时,如果当前针和下一针是运针,则当前针改为跳针
0 )
{
DstStep * ndstDataPtr = dstDataPtr;
Ds4Item nds4Item; // 下一针数据
ndstDataPtr++;
rslt = changeDstStep(ndstDataPtr, nds4Item); //三字节针步转换
if (rslt == 0)
{
if (nds4Item.ctrl == DATA_EMB)
{
ctrl = DATA_JUMP;
ds4Item.ctrl = DATA_JUMP;
}
}
}
if (zeroJump != 0)
{// 处理珠片码
bds4Item.ctrl = DATA_EMB;
bds4Item.attr |= (zeroJump & 0x1f);
m_beadSequinMap[(zeroJump & 0x1f)] = 1; // 位图有效
memcpy(&(pData[stepidx]), &bds4Item, sizeof(Ds4Item));
stepidx++;
zeroJump = 0;
}
if ((ctrl == DATA_EMB) || (dxy == 1))
{// 保存针步
memcpy(&(pData[stepidx]), &ds4Item, sizeof(Ds4Item));
stepidx++;
}
}
else if (ctrl == DATA_CHGND)
{// 换色
if (zeroJump != 0)
{
bds4Item.ctrl = DATA_EMB;
bds4Item.attr |= (zeroJump & 0x1f);
m_beadSequinMap[(zeroJump & 0x1f)] = 1; // 位图有效
memcpy(&(pData[stepidx]), &bds4Item, sizeof(Ds4Item));
stepidx++;
zeroJump = 0;
}
if (bctrl == DATA_CHGND) // 上一针也为换色码
{
ctrl = DATA_PAUSE; // 将此换色码改为暂停码
ds4Item.ctrl = ctrl;
}
{// 保存换色(暂停)针步
memcpy(&(pData[stepidx]), &ds4Item, sizeof(Ds4Item));
stepidx++;
}
if (ctrl == DATA_CHGND)
{
colornum++;
}
if (ctrl == DATA_CHGND)
{// 换色后插入毛巾高度码:DATA_TOWELHIGH
ds4Item.ctrl = DATA_TOWELHIGH;
memcpy(&(pData[stepidx]), &ds4Item, sizeof(Ds4Item));
stepidx++;
}
}
else if (ctrl == DATA_JUMP)
{// 跳针
if (openSequin == 0)
{// 不在开关状态码过程中
if (dxy != 0)
{// 非空跳
jumpNeedleNum++;
memcpy(&(pData[stepidx]), &ds4Item, sizeof(Ds4Item));
stepidx++;
}
}
else
{// 开关亮片码中 判断珠片码
if (dxy != 0)
{// 非空跳
if (zeroJump != 0)
{// 保存前一次的珠片码
bds4Item.ctrl = DATA_EMB;
bds4Item.attr |= (zeroJump & 0x1f);
m_beadSequinMap[(zeroJump & 0x1f)] = 1; // 位图有效
memcpy(&(pData[stepidx]), &bds4Item, sizeof(Ds4Item));
stepidx++;
zeroJump = 0;
}
memcpy(&bds4Item, &ds4Item, sizeof(Ds4Item)); // 保存当前珠片信息
zeroJump = 1;
}
else
{
zeroJump++;
}
}
}
else if (ctrl == DATA_OPEN_SEQUIN)
{// 开关亮片功能码
if (openSequin == 0)
{
openSequin = 1; // 进入开关亮片状态
zeroJump = 0;
}
else
{
if (zeroJump != 0)
{// 保存前一次的珠片码
bds4Item.ctrl = DATA_EMB;
bds4Item.attr |= (zeroJump & 0x1f);
m_beadSequinMap[(zeroJump & 0x1f)] = 1; // 位图有效
memcpy(&(pData[stepidx]), &bds4Item, sizeof(Ds4Item));
stepidx++;
zeroJump = 0;
}
openSequin = 0; // 退出开关亮片状态
}
}
else if (ctrl == DATA_END)
{// 结束码
memcpy(&(pData[stepidx]), &ds4Item, sizeof(Ds4Item));
stepidx++;
break;
}
else // 未定义
{
}
if ((openSequin == 0) && // 开关亮片状态:关
(jctrl == DATA_JUMP) && // 原始数据是跳针
1)
{// 连续跳针的个数
jumpNum++;
}
else
{
jumpNum = 0;
}
bctrl = jctrl;
}
dstDataPtr++;
i++;
}
else
{
break;
}
}while(1);
//qDebug()<<"Ds4Item end";
/*
for (i=0;i<BEADSEQUINTYPE;i++)
{// 测试,临时赋值
if (m_beadSequinMap.at(i) == 1)
{
qDebug()<<"m_beadSequinTable["<< (int)(i) <<"] = "<<(int)(m_beadSequinTable.at(i));
}
}
*/
//再将相对坐标转换为绝对坐标---开始
ds4Data.clear();
ds4Data.append((char *)pData, stepidx*sizeof(Ds4Item));//相对坐标字节数组
u32 fileID = 0;
fileID = calcCheckSum32((u8 *)(ds4Data.data()) , ds4Data.length()); // 原始数据累加校验和
QByteArray absItemAry;
absItemAry.clear();
DsAbsItem absItem;
memset(&absItem,0,sizeof(DsAbsItem));
u8 ctrlByte;
u8 attrByte;
u8 actionByte;
int ddx, ddy;
m_maxX = S32_MIN;
m_maxY = S32_MIN;
m_minY = S32_MAX;
m_minX = S32_MAX;
Ds4Item * pDs4Data = (Ds4Item *)(ds4Data.data());
Ds4Item * ds4DataPtr = pDs4Data;
int begX = pDstHead->startX;//起始点
int begY = pDstHead->startY;
int begR = 0;
s32 ax = 0; //起始点
s32 ay = 0;
s32 ar = 0;
int ds4StepSize = ds4Data.size()/sizeof(Ds4Item);
for (int i = 0; i < ds4StepSize; i++)
{
// 读入一个针步数据
ctrlByte = ds4DataPtr->ctrl;
attrByte = ds4DataPtr->attr;
if ((attrByte & 0x1f) != 0)
{
actionByte = m_beadSequinTable.at((int)(attrByte & 0x1f));
}
else
{
actionByte = 0;
}
ddx = ds4DataPtr->dx * DATAFACTOR;
ddy = ds4DataPtr->dy * DATAFACTOR;
if ((attrByte & 0x80) != 0)
{
ddx *= -1;
}
if ((attrByte & 0x40) != 0)
{
ddy *= -1;
}
ddx *= DST_EMB_DATADIRX; // X向数据坐标与下位机坐标系统的差异
ddy *= DST_EMB_DATADIRY; // Y向数据坐标与下位机坐标系统的差异
ax += ddx;
ay += ddy;
//ar = atan2(ddy,ddx) * 10000;
double tar = atan2(ddy,ddx);
ar = (tar * 10000+0.5*(tar>0?1:-1));
//中间数据
absItem.ctrl = ctrlByte;
absItem.attr = 0;
if (actionByte != 0)
{
if (actionByte == 0x10)
{// 叠片码特殊处理
absItem.action = ((u16)(0x03)<<8) + 0x20; // 根据参数将珠片码中对应的动作转为亮片和散数数据
}
else
{
absItem.action = ((u16)(actionByte)<<8) + 0x20; // 根据参数将珠片码中对应的动作转为亮片和散数数据
}
}
else
{
absItem.action = 0;
}
absItem.ax = ax;
absItem.ay = ay;
absItem.ar = ar;
if (ax > m_maxX)
{
m_maxX = ax;
}
if (ax < m_minX)
{
m_minX = ax;
}
if (ay > m_maxY)
{
m_maxY = ay;
}
if (ay < m_minY)
{
m_minY = ay;
}
absItemAry.append((char*)&absItem,sizeof(DsAbsItem));
ds4DataPtr++;
}
//qDebug()<<"DsAbsItem end";
//再将相对坐标转换为绝对坐标---结束
//qDebug()<<"dhead begin";
// 文件头转换
QString name = getFileFullName();
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(dhead.fileName, array, asize); // 文件名称
dhead.dataSize = ds4StepSize*sizeof(DsAbsItem); // 数据字节数
dhead.itemNums = ds4StepSize; // 数据项个数
dhead.bytesPerItem = sizeof(DsAbsItem); // 每项占的字节数
dhead.bytesPerBlk = MAX_EXDP_LEN; // 数据内容划分块大小
dhead.dataChecksum = calcCheckSum32((u8 *)(absItemAry.data()) , dhead.dataSize); // 数据累加校验和
dhead.checkCrc = calcCrc16((u8 *)(&dhead), HEAD_FIX_INFO_LEN); // 前面6个字段的CRC校验6个字段分别为文件名称字节数项个数每项字节数每块字节数数据累加和的CRC校验值
dhead.fileid = fileID;
//qDebug()<<"dhead 1";
dhead.anchorX = 0; // 定位点坐标X
dhead.anchorY = 0; // 定位点坐标Y
dhead.beginX = begX; // 数据起点坐标X
dhead.beginY = begY; // 数据起点坐标Y
dhead.beginR = begR; // 数据起点坐标R
dhead.minX = m_minX;
dhead.maxX = m_maxX;
dhead.minY = m_minY;
dhead.maxY = m_maxY; // 轮廓范围,使用重新计算之后的值
dhead.jumpNeedleNum = jumpNeedleNum;// 跳针数
dhead.colorNum = colornum; // 颜色数
//dsr头文件中的以何种工作机头定点
dhead.begHead = pDstHead->begWorkHead;
dhead.offsetEn = pDstHead->offsetEn; //两个结构体不一样,所以参数在结构体存的位置不影响
dhead.offsetX = pDstHead->offsetX;
dhead.offsetY = pDstHead->offsetY;
//dst的花版
//dhead.patternType = 1;
//qDebug()<<"m_maxX"<<m_maxX<<"m_minX"<<m_minX;
//qDebug()<<"m_maxY"<<m_maxY<<"m_minY"<<m_minY;
// 色序表
//qDebug()<<"dhead 2";
checkDefaultSwitchTable(colornum); // 检查默认换色表
memcpy(dhead.switchTable, pDstHead->switchTable, EMB_BF_SW_ND);
//qDebug()<<"dhead 3";
// 保存文件头到数组中
m_embAbsData.append((char *)(&dhead), sizeof(DataDs16FileHead));
//qDebug()<<"dhead 4";
// 保存数据到数组中
//qDebug()<<"ds4StepSize"<<ds4StepSize;
m_embAbsData.append(absItemAry);
delete []pData;
//qDebug()<<"dhead end";
return;
}
void DataFileDst::writePointToFile(u8 type, int x, int y, int st,u8 workHead)
{
if(st == 0){}
if(m_fileData.size() <= 0)
{
return;
}
DstHead * pDstHead = (DstHead *)((m_fileData.data()));
if(type == START_POINT)
{
pDstHead->begWorkHead=workHead;
pDstHead->startX = x;
pDstHead->startY = y;
}
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);
#ifdef Q_OS_LINUX
system("sync");
#endif
wfile.close();
}
//将fcg里的 偏移点XY写在dst头文件里
void DataFileDst::writeOffsetXYMoveToFile(s32 EnFlag,s32 offsetX,s32 offsetY)
{
if(m_fileData.size() <= 0)
{
return;
}
DstHead * pDstHead = (DstHead *)((m_fileData.data()));
pDstHead->offsetEn = EnFlag;
pDstHead->offsetX = offsetX;
pDstHead->offsetY = offsetY;
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);
#ifdef Q_OS_LINUX
system("sync");
#endif
wfile.close();
}
int DataFileDst::checkDstFile()
{
loadFile(); // 如果数据未读取,重新读取
int size = m_fileData.size();
if (size <= (int)(sizeof(DstHead)))
{
qDebug("dsr size less then headsize");
return -1;
}
size -= sizeof(DstHead);
int stepsize = size/sizeof(DstStep);
if (stepsize <= 0)
{
qDebug("dst data size err");
return -1;
}
if (stepsize > PATTERN_LARGE_NEEDLES)//128万针
{
qDebug("dsr data size big");
return -2;
}
return stepsize;
}
//-----------------------------------------------------------------------
//补光增加
QColor DataFileDst::getBrightAdd(QColor embcolor)
{
QColor backColor;
float rgbR = embcolor.red();//R值
float rgbG = embcolor.green();//G值
float rgbB = embcolor.blue();//B值
float Y = 0.257 * rgbR + 0.504 * rgbG + 0.098 * rgbB + 16;
float U = (-0.148) * rgbR - 0.291 * rgbG + 0.439 * rgbB +128;
float V = 0.439 * rgbR - 0.368 * rgbG + 0.071 * rgbB + 128;
Y = Y + 100;
int R = 1.164*Y + 1.596 * V - 222.9;
int G = 1.164*Y - 0.392 * U - 0.823 * V+ 135.6;
int B = 1.164*Y + 2.017 * U- 276.8 ;
if(R > 255)
{
R = 255;
}
else if (R < 0)
{
R = 0;
}
if(G > 255)
{
G = 255;
}
else if (G < 0)
{
G = 0;
}
if(B > 255)
{
B = 255;
}
else if (B < 0)
{
B = 0;
}
backColor.setRgb(R , G , B);
return backColor;
}
//补光减少
QColor DataFileDst::getBrightDec(QColor embcolor)
{
QColor backColor;
float rgbR = embcolor.red();//R值
float rgbG = embcolor.green();//G值
float rgbB = embcolor.blue();//B值
float Y = 0.257 * rgbR + 0.504 * rgbG + 0.098 * rgbB + 16;
float U = (-0.148) * rgbR - 0.291 * rgbG + 0.439 * rgbB +128;
float V = 0.439 * rgbR - 0.368 * rgbG + 0.071 * rgbB + 128;
if( Y > 100.0)
{
Y = Y - 100.0;
}
else
{
Y = 16;
}
int R = 1.164*Y + 1.596 * V - 222.9;
int G = 1.164*Y - 0.392 * U - 0.823 * V+ 135.6;
int B = 1.164*Y + 2.017 * U- 276.8 ;
if(R > 255)
{
R = 255;
}
else if (R < 0)
{
R = 0;
}
if(G > 255)
{
G = 255;
}
else if (G < 0)
{
G = 0;
}
if(B > 255)
{
B = 255;
}
else if (B < 0)
{
B = 0;
}
backColor.setRgb(R , G , B);
return backColor;
}
// 生成预览文件
int DataFileDst::createPreviewImage(QImage * pImg, int saveflag, int penwidth, int gradientFlag, int reDraw)
{
#if(1)
if(reDraw == 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 = DST_PREVIEW_WIDTH;
height = DST_PREVIEW_HEIGHT;
pImage = new QImage(width, height, IMAGE_TYPE);
newimgflag = 1;
}
else
{
pImage = pImg;
}
width = pImage->width();
height = pImage->height();
if (width <= DST_PREVIEW_SIDE*2 || height <= DST_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); // 透明背景
QColor backColor1;
QColor backColor2;
// 背景
QPen pen;
pen.setWidth(penwidth);
pen.setColor(backcolor);
painter.setPen(pen);
painter.setBrush(backcolor);
painter.drawRect(0, 0, width, height);
// 图形
//qDebug()<<"convertDataToAbs defore";
convertDataToAbs(); // 转换为绝对坐标数据
//qDebug()<<"convertDataToAbs end";
#define SEG2_1 0.1
#define SEG2_2 1.0
// absdat数据
int size = m_embAbsData.size();
if (size <= (int)sizeof(DataDs16FileHead))
{
qDebug("2 data less then head size");
return -1;
}
DataDs16FileHead * pAbsHead = (DataDs16FileHead *)(m_embAbsData.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_embAbsData.data() + sizeof(DataDs16FileHead));
DsAbsItem * absDataPtr = pData;
//--------
// 图形显示区域
int dpminx = DST_PREVIEW_SIDE;
int dpmaxx = width - DST_PREVIEW_SIDE;
int dpminy = DST_PREVIEW_SIDE;
int dpmaxy = height - DST_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;
}
// 计算显示参数,按照图形的实际位置显示(数据坐标零点对应图形中心)
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;
int dx;
int dy;
int colorIdx;
int oldcolor;
double datposx, datposy;
int curx, cury, prex, prey;
datposx = pAbsHead->beginX;
datposy = pAbsHead->beginY;
curx = (datposx) / factor + dpx;
cury = (datposy) / factor + dpy;
if (DST_SHOWDIRX == -1)
{
curx = (width)-curx;
}
if (DST_SHOWDIRY == -1)
{
cury = (height)-cury;
}
absDataPtr = pData;
colorIdx = 0;
oldcolor = -1;
s16 jumpFlag = 0;//遇到跳针的标志
for (int i = 0; i < stepsize; i++)
{
// 读入一个针步数据
ctrlByte = absDataPtr->ctrl;
if ( ctrlByte == DATA_EMB ||
0 )
{
prex = curx;
prey = cury;
dx = absDataPtr->ax;
dy = absDataPtr->ay;
datposx = dx;
datposy = dy;
curx = (datposx) / factor + dpx;
cury = (datposy) / factor + dpy;
if (DST_SHOWDIRX == -1)
{
curx = (width)-curx;
}
if (DST_SHOWDIRY == -1)
{
cury = (height)-cury;
}
if (oldcolor != colorIdx)
{
int cidx = pAbsHead->switchTable[colorIdx % EMB_BF_SW_ND];
int cnum = m_colorNum;
cnum /= sizeof(QRgb);
if (cnum > EMB_BF_SW_ND)
{
cnum = EMB_BF_SW_ND;
}
QColor embcolor;
if (cnum != 0)
{
cidx %= cnum;
QRgb * pColor = m_pColor;
if(pColor != NULL)
{
embcolor.setRgb(pColor[cidx]);
}
else
{
embcolor = QColor(Qt::green);
}
}
else
{
embcolor = QColor(Qt::green);
}
pen.setColor(embcolor);
painter.setPen(pen);
oldcolor = colorIdx;
if(gradientFlag == 1)//渐变色绘制
{
backColor2 = getBrightDec(embcolor);
backColor1 = getBrightAdd(embcolor);
}
}
if(gradientFlag == 1)//渐变色绘制
{
QLinearGradient gradient(prex, prey, curx, cury);
//绣花跳针两针为一步,所以要将两针跳针每针分两段渐变,亮色部分拼接到一起
//实现一针渐变的效果(可参考菱形图效果)
if(jumpFlag == 1)
{
jumpFlag = 2;
//两段渐变
gradient.setColorAt(SEG2_1,backColor1);
gradient.setColorAt(SEG2_2,backColor2);
}
else if (jumpFlag == 2)
{
jumpFlag = 0;
//两段渐变
gradient.setColorAt(SEG2_1,backColor2);
gradient.setColorAt(SEG2_2,backColor1);
}
else
{
gradient.setColorAt(0.1,backColor2);
gradient.setColorAt(0.5,backColor1);
gradient.setColorAt(1.0,backColor2);
}
painter.setRenderHint(QPainter::Antialiasing,true);
QBrush brush(gradient);
QPen npen(brush , penwidth);
painter.setPen(npen);
}
if(i != 0)
{
painter.drawLine(prex, prey, curx, cury);
}
}
//如果连续两步都是跳针,则过滤掉
else if (ctrlByte == DATA_JUMP)
{
jumpFlag = 1;//跳针标志置为1
DsAbsItem * JumpAbsDataPtr = pData;
JumpAbsDataPtr = absDataPtr - 1;
u8 beforectrlByte = JumpAbsDataPtr->ctrl;
JumpAbsDataPtr = absDataPtr + 2;
u8 nextctrlByte = JumpAbsDataPtr->ctrl;
prex = curx;
prey = cury;
dx = absDataPtr->ax;
dy = absDataPtr->ay;
datposx = dx;
datposy = dy;
curx = (datposx) / factor + dpx;
cury = (datposy) / factor + dpy;
if (DST_SHOWDIRX == -1)
{
curx = (width)-curx;
}
if (DST_SHOWDIRY == -1)
{
cury = (height)-cury;
}
if (oldcolor != colorIdx)
{
int cidx = pAbsHead->switchTable[colorIdx % EMB_BF_SW_ND];
int cnum = m_colorNum;
cnum /= sizeof(QRgb);
if (cnum > EMB_BF_SW_ND)
{
cnum = EMB_BF_SW_ND;
}
QColor embcolor;
if (cnum != 0)
{
cidx %= cnum;
QRgb * pColor = m_pColor;
if(pColor != NULL)
{
embcolor.setRgb(pColor[cidx]);
}
else
{
embcolor = QColor(Qt::green);
}
}
else
{
embcolor = QColor(Qt::green);
}
pen.setColor(embcolor);
painter.setPen(pen);
oldcolor = colorIdx;
if(gradientFlag == 1)//渐变色绘制
{
backColor2 = getBrightDec(embcolor);
backColor1 = getBrightAdd(embcolor);
}
}
if(beforectrlByte == DATA_JUMP || nextctrlByte == DATA_JUMP)
{
//该针上下两针都是跳针则不画线
}
else
{
if(gradientFlag == 1)//渐变色绘制
{
QLinearGradient gradient(prex, prey, curx, cury);
gradient.setColorAt(0.1,backColor2);
gradient.setColorAt(0.5,backColor1);
gradient.setColorAt(1.0,backColor2);
painter.setRenderHint(QPainter::Antialiasing,true);
QBrush brush(gradient);
QPen npen(brush , penwidth);
painter.setPen(npen);
}
if(i != 0)
{
painter.drawLine(prex, prey, curx, cury);
}
}
}
////
else if (ctrlByte == DATA_CHGND) // 换色
{
colorIdx++;
}
else
{
// 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;
}
#define EMB_DST_DAT_DIRX (-1) // X向DST数据坐标和绝对数据坐标的差异
#define EMB_DST_DAT_DIRY (1) // Y向DST数据坐标和绝对数据坐标的差异
// 针步转换
int DataFileDst::changeDstStep(DstStep * pDststep, Ds4Item & ds4step)
{
int dx, dy;
u8 c1, c2, c3;
u8 ctrl, attr;
if (pDststep == NULL)
{
return -1;
}
c1 = pDststep->c1;
c2 = pDststep->c2;
c3 = pDststep->c3;
dx = 0;
dy = 0;
if ((c1&0x08) != 0) { dx -= 9; }
if ((c1&0x04) != 0) { dx += 9; }
if ((c1&0x02) != 0) { dx -= 1; }
if ((c1&0x01) != 0) { dx += 1; }
if ((c2&0x08) != 0) { dx -= 27; }
if ((c2&0x04) != 0) { dx += 27; }
if ((c2&0x02) != 0) { dx -= 3; }
if ((c2&0x01) != 0) { dx += 3; }
if ((c3&0x08) != 0) { dx -= 81; }
if ((c3&0x04) != 0) { dx += 81; }
if ((c1&0x10) != 0) { dy -= 9; }
if ((c1&0x20) != 0) { dy += 9; }
if ((c1&0x40) != 0) { dy -= 1; }
if ((c1&0x80) != 0) { dy += 1; }
if ((c2&0x10) != 0) { dy -= 27; }
if ((c2&0x20) != 0) { dy += 27; }
if ((c2&0x40) != 0) { dy -= 3; }
if ((c2&0x80) != 0) { dy += 3; }
if ((c3&0x10) != 0) { dy -= 81; }
if ((c3&0x20) != 0) { dy += 81; }
#if(0)
switch (c3 & 0xF3)
{
case 0x03: // 运针
ctrl = DATA_EMB;
break;
case 0x43: // 开关亮片码
qDebug("Sequin switch, not support, c1=0x%x, c2=0x%x, c3=0x%x", c1, c2, c3); // 不合法的DST
return -2;
break;
case 0x83: // 跳针
ctrl = DATA_JUMP;
break;
case 0xC3: // 换色
ctrl = DATA_CHGND;
break;
case 0xF3: // 结束
if(dx == 0 && dy == 0)
{
ctrl = DATA_END;
}
break;
default:
if((c3 & 0x80) != 0x00)
{
if(dx == 0 && dy == 0)//空跳
{
ctrl = DATA_JUMP;
}
else
{
ctrl = DATA_OFFSET;
}
}
else
{
ctrl = DATA_EMB;
}
break;
}
#else
if (c3 == 0xF3 && dx == 0 && dy == 0)
{
ctrl = DATA_END; // 结束
}
else if ((c3&0xC3) == 0x03) // 运针
{
ctrl = DATA_EMB;
}
else if ((c3&0xC3) == 0x83) // 跳针
{
ctrl = DATA_JUMP;
}
else if ((c3&0xC3) == 0xC3) // 换色
{
ctrl = DATA_CHGND;
}
else if ((c3&0xC3) == 0x43) // 开关亮片码
{
ctrl = DATA_OPEN_SEQUIN;
}
else
{
ctrl = DATA_UNKNOW;
qDebug("not know dst step, c1=0x%x, c2=0x%x, c3=0x%x", c1, c2, c3); // 不合法的DST
return -3;
}
#endif
// 添加针步
attr = 0;
dx *= EMB_DST_DAT_DIRX; // X向显示坐标和数据坐标的差异
dy *= EMB_DST_DAT_DIRY; // Y向显示坐标和数据坐标的差异
if (dx < 0) { attr |= 0x80; }
if (dy < 0) { attr |= 0x40; }
ds4step.ctrl = ctrl;
ds4step.attr = attr;
ds4step.dx = abs(dx);
ds4step.dy = abs(dy);
return 0;
}
// 检查并设置默认换色表
int DataFileDst::checkDefaultSwitchTable(int colornum)
{
//loadFile(); // 如果数据未读取,重新读取
int size = m_fileData.size();
if (size <= (int)(sizeof(DstHead)))
{
qDebug("dst size less then headsize");
return -1;
}
size -= sizeof(DstHead);
int stepsize = size/sizeof(DstStep);
if (stepsize <= 0)
{
qDebug("dst data size err");
return -1;
}
DstHead * pDstHead = (DstHead *)((m_fileData.data()));
int i;
if (colornum < 1)
{
colornum = 1;
}
if (colornum > EMB_BF_SW_ND)
{
colornum = EMB_BF_SW_ND;
}
for (i = 0; i < colornum; i++)
{
if (pDstHead->switchTable[i] != 0x20)
{
break;
}
}
if (i < colornum) // 不全部是0x20, 可能设置过色序
{
for (i = 0; i < colornum; i++)
{
if (pDstHead->switchTable[i] != 0x00)
{
break;
}
}
}
if (i >= colornum && colornum > 1) // 全部是0x20 或 全部是0, 未设置过色序
{
for (i = 0; i < colornum; i++)
{
pDstHead->switchTable[i] = i; // 默认色序
}
saveFile(); // 保存文件
}
return 0;
}