/*! Writes the data from \a pattern to a file with the given \a fileName.
* Returns \c true if successful, otherwise returns \c false. */
int writePes(EmbPattern* pattern, const char* fileName)
{
int pecLocation;
FILE* file = 0;
if(!pattern) {
embLog_error("format-pes.c writePes(), pattern argument is null\n");
return 0;
}
if(!fileName) {
embLog_error("format-pes.c writePes(), fileName argument is null\n");
return 0;
}
file = fopen(fileName, "wb");
if(!file)
{
embLog_error("format-pes.c writePes(), cannot open %s for writing\n", fileName);
return 0;
}
if(!pattern->stitchList || embStitchList_count(pattern->stitchList) == 0) /* TODO: review this. seems like only embStitchList_count should be needed. */
{
embLog_error("format-pes.c writePes(), pattern contains no stitches\n");
return 0;
}
embPattern_flipVertical(pattern);
embPattern_scale(pattern, 10.0);
binaryWriteBytes(file, "#PES0001", 8);
/* WRITE PECPointer 32 bit int */
binaryWriteInt(file, 0x00);
binaryWriteShort(file, 0x01);
binaryWriteShort(file, 0x01);
/* Write object count */
binaryWriteShort(file, 0x01);
binaryWriteShort(file, 0xFFFF); /* command */
binaryWriteShort(file, 0x00); /* unknown */
pesWriteEmbOneSection(pattern, file);
pesWriteSewSegSection(pattern, file);
pecLocation = ftell(file);
fseek(file, 0x08, SEEK_SET);
binaryWriteByte(file, (unsigned char)(pecLocation & 0xFF));
binaryWriteByte(file, (unsigned char)(pecLocation >> 8) & 0xFF);
binaryWriteByte(file, (unsigned char)(pecLocation >> 16) & 0xFF);
fseek(file, 0x00, SEEK_END);
writePecStitches(pattern, file, fileName);
fclose(file);
return 1;
}
/*! Writes the data from \a pattern to a file with the given \a fileName.
* Returns \c true if successful, otherwise returns \c false. */
int writeKsm(EmbPattern* pattern, const char* fileName)
{
EmbFile* file = 0; /* TODO: change writeKsm() to use EmbFile */
EmbStitchList* pointer = 0;
double xx = 0, yy = 0, dx = 0, dy = 0;
int flags = 0;
int i = 0;
unsigned char b[4];
if(!pattern) { embLog_error("format-ksm.c writeKsm(), pattern argument is null\n"); return 0; }
if(!fileName) { embLog_error("format-ksm.c writeKsm(), fileName argument is null\n"); return 0; }
if(!embStitchList_count(pattern->stitchList))
{
embLog_error("format-ksm.c writeKsm(), pattern contains no stitches\n");
return 0;
}
/* Check for an END stitch and add one if it is not present */
if(pattern->lastStitch->stitch.flags != END)
embPattern_addStitchRel(pattern, 0, 0, END, 1);
file = embFile_open(fileName, "wb");
if(!file)
{
embLog_error("format-ksm.c writeKsm(), cannot open %s for writing\n", fileName);
return 0;
}
for(i = 0; i < 0x80; i++)
{
binaryWriteInt(file, 0);
}
/* write stitches */
xx = yy = 0;
pointer = pattern->stitchList;
while(pointer)
{
dx = pointer->stitch.xx - xx;
dy = pointer->stitch.yy - yy;
xx = pointer->stitch.xx;
yy = pointer->stitch.yy;
flags = pointer->stitch.flags;
ksmEncode(b, (char)(dx * 10.0), (char)(dy * 10.0), flags);
embFile_printf(file, "%c%c", b[0], b[1]);
pointer = pointer->next;
}
embFile_printf(file, "\x1a");
embFile_close(file);
return 1;
}
int writeXxx(EmbPattern* pattern, const char* fileName)
{
FILE* file = 0;
int i;
EmbRect rect;
int endOfStitches;
EmbThreadList* colors;
int curColor = 0;
if(!pattern) { embLog_error("format-xxx.c writeXxx(), pattern argument is null\n"); return 0; }
if(!fileName) { embLog_error("format-xxx.c writeXxx(), fileName argument is null\n"); return 0; }
embPattern_correctForMaxStitchLength(pattern, 124, 127);
file = fopen(fileName, "wb");
if(!file)
{
embLog_error("format-xxx.c writeXxx(), cannot open %s for writing\n", fileName);
return 0;
}
for(i = 0; i < 0x17; i++)
{
binaryWriteByte(file, 0x00);
}
binaryWriteUInt(file, (unsigned int) embStitchList_count(pattern->stitchList));
for(i = 0; i < 0x0C; i++)
{
binaryWriteByte(file, 0x00);
}
binaryWriteUShort(file, (unsigned short)embThreadList_count(pattern->threadList));
binaryWriteShort(file, 0x0000);
rect = embPattern_calcBoundingBox(pattern);
binaryWriteShort(file, (short)(embRect_width(rect) * 10.0));
binaryWriteShort(file, (short)(embRect_height(rect) * 10.0));
binaryWriteShort(file, (short)(embRect_width(rect) / 2.0 * 10)); /*TODO: xEnd from start point x=0 */
binaryWriteShort(file, (short)(embRect_height(rect) / 2.0 * 10)); /*TODO: yEnd from start point y=0 */
binaryWriteShort(file, (short)(embRect_width(rect)/2.0 * 10)); /*TODO: left from start x = 0 */
binaryWriteShort(file, (short)(embRect_height(rect)/2.0 * 10)); /*TODO: bottom from start y = 0 */
for(i = 0; i < 0xC5; i++)
{
binaryWriteByte(file, 0x00);
}
binaryWriteInt(file, 0x0000); /* place holder for end of stitches */
xxxEncodeDesign(file, pattern);
endOfStitches = ftell(file);
fseek(file, 0xFC, SEEK_SET);
binaryWriteUInt(file, endOfStitches);
fseek(file, 0, SEEK_END);
binaryWriteByte(file, 0x7F); /* is this really correct? */
binaryWriteByte(file, 0x7F);
binaryWriteByte(file, 0x03);
binaryWriteByte(file, 0x14);
binaryWriteByte(file, 0x00);
binaryWriteByte(file, 0x00);
colors = pattern->threadList;
while(colors)
{
binaryWriteByte(file, 0x00);
binaryWriteByte(file, colors->thread.color.r);
binaryWriteByte(file, colors->thread.color.g);
binaryWriteByte(file, colors->thread.color.b);
curColor++;
colors = colors->next;
}
for(i = 0; i < (22 - curColor); i++)
{
binaryWriteUInt(file, 0x01000000);
}
binaryWriteByte(file, 0x00);
binaryWriteByte(file, 0x01);
fclose(file);
return 1;
}
/*! Writes the data from \a pattern to a file with the given \a fileName.
* Returns \c true if successful, otherwise returns \c false. */
int writeVp3(EmbPattern* pattern, const char* fileName)
{
EmbFile *file = 0;
EmbRect bounds;
int remainingBytesPos, remainingBytesPos2;
int colorSectionStitchBytes;
int first = 1;
int numberOfColors = 0;
EmbColor color;
EmbStitchList *mainPointer = 0, *pointer = 0;
if(!pattern) { embLog_error("format-vp3.c writeVp3(), pattern argument is null\n"); return 0; }
if(!fileName) { embLog_error("format-vp3.c writeVp3(), fileName argument is null\n"); return 0; }
if(!embStitchList_count(pattern->stitchList))
{
embLog_error("format-vp3.c writeVp3(), pattern contains no stitches\n");
return 0;
}
bounds = embPattern_calcBoundingBox(pattern);
file = embFile_open(fileName, "wb");
if(!file)
{
embLog_error("format-vp3.c writeVp3(), cannot open %s for writing\n", fileName);
return 0;
}
embPattern_correctForMaxStitchLength(pattern, 3200.0, 3200.0); /* VP3 can encode signed 16bit deltas */
embPattern_flipVertical(pattern);
binaryWriteBytes(file, "%vsm%", 5);
binaryWriteByte(file, 0);
vp3WriteString(file, "Embroidermodder");
binaryWriteByte(file, 0);
binaryWriteByte(file, 2);
binaryWriteByte(file, 0);
remainingBytesPos = embFile_tell(file);
binaryWriteInt(file, 0); /* placeholder */
vp3WriteString(file, "");
binaryWriteIntBE(file, bounds.right * 1000);
binaryWriteIntBE(file, bounds.bottom * 1000);
binaryWriteIntBE(file, bounds.left * 1000);
binaryWriteIntBE(file, bounds.top * 1000);
binaryWriteInt(file, 0); /* this would be some (unknown) function of thread length */
binaryWriteByte(file, 0);
numberOfColors = 0;
mainPointer = pattern->stitchList;
while(mainPointer)
{
int flag;
EmbColor newColor;
pointer = mainPointer;
flag = pointer->stitch.flags;
newColor = embThreadList_getAt(pattern->threadList, pointer->stitch.color).color;
if(newColor.r != color.r || newColor.g != color.g || newColor.b != color.b)
{
numberOfColors++;
color.r = newColor.r;
color.g = newColor.g;
color.b = newColor.b;
}
else if(flag & END || flag & STOP)
{
numberOfColors++;
}
while(pointer && (flag == pointer->stitch.flags))
{
pointer = pointer->next;
}
mainPointer = pointer;
}
binaryWriteByte(file, numberOfColors);
binaryWriteByte(file, 12);
binaryWriteByte(file, 0);
binaryWriteByte(file, 1);
binaryWriteByte(file, 0);
binaryWriteByte(file, 3);
binaryWriteByte(file, 0);
remainingBytesPos2 = embFile_tell(file);
binaryWriteInt(file, 0); /* placeholder */
binaryWriteIntBE(file, 0); /* origin X */
binaryWriteIntBE(file, 0); /* origin Y */
binaryWriteByte(file, 0);
binaryWriteByte(file, 0);
binaryWriteByte(file, 0);
binaryWriteIntBE(file, bounds.right * 1000);
binaryWriteIntBE(file, bounds.bottom * 1000);
binaryWriteIntBE(file, bounds.left * 1000);
binaryWriteIntBE(file, bounds.top * 1000);
binaryWriteIntBE(file, (bounds.right - bounds.left) * 1000);
binaryWriteIntBE(file, (bounds.bottom - bounds.top) * 1000);
vp3WriteString(file, "");
binaryWriteShortBE(file, 25700);
binaryWriteIntBE(file, 4096);
binaryWriteIntBE(file, 0);
binaryWriteIntBE(file, 0);
binaryWriteIntBE(file, 4096);
binaryWriteBytes(file, "xxPP\x01\0", 6);
vp3WriteString(file, "");
binaryWriteShortBE(file, numberOfColors);
mainPointer = pattern->stitchList;
while(mainPointer)
{
char colorName[8] = { 0 };
double lastX, lastY;
int colorSectionLengthPos;
EmbStitch s;
int lastColor;
if(!first)
binaryWriteByte(file, 0);
binaryWriteByte(file, 0);
binaryWriteByte(file, 5);
binaryWriteByte(file, 0);
colorSectionLengthPos = embFile_tell(file);
binaryWriteInt(file, 0); /* placeholder */
pointer = mainPointer;
color = embThreadList_getAt(pattern->threadList, pointer->stitch.color).color;
if(first && pointer->stitch.flags & JUMP && pointer->next->stitch.flags & JUMP)
pointer = pointer->next;
s = pointer->stitch;
embLog_print("format-vp3.c DEBUG %d, %lf, %lf\n", s.flags, s.xx, s.yy);
binaryWriteIntBE(file, s.xx * 1000);
binaryWriteIntBE(file, -s.yy * 1000);
pointer = pointer->next;
first = 0;
lastX = s.xx;
lastY = s.yy;
lastColor = s.color;
binaryWriteByte(file, 1);
binaryWriteByte(file, 0);
embLog_print("format-vp3.c writeVp3(), switching to color (%d, %d, %d)\n", color.r, color.g, color.b);
binaryWriteByte(file, color.r);
binaryWriteByte(file, color.g);
binaryWriteByte(file, color.b);
binaryWriteByte(file, 0);
binaryWriteByte(file, 0);
binaryWriteByte(file, 0);
binaryWriteByte(file, 5);
binaryWriteByte(file, 40);
vp3WriteString(file, "");
sprintf(colorName, "#%02x%02x%02x", color.b, color.g, color.r);
vp3WriteString(file, colorName);
vp3WriteString(file, "");
binaryWriteIntBE(file, 0);
binaryWriteIntBE(file, 0);
vp3WriteStringLen(file, "\0", 1);
colorSectionStitchBytes = embFile_tell(file);
binaryWriteInt(file, 0); /* placeholder */
binaryWriteByte(file, 10);
binaryWriteByte(file, 246);
binaryWriteByte(file, 0);
while(pointer)
{
int dx, dy;
EmbStitch s = pointer->stitch;
if(s.color != lastColor)
break;
if(s.flags & END || s.flags & STOP)
break;
dx = (s.xx - lastX) * 10;
dy = (s.yy - lastY) * 10;
lastX = lastX + dx / 10.0; /* output is in ints, ensure rounding errors do not sum up */
lastY = lastY + dy / 10.0;
if(dx < -127 || dx > 127 || dy < -127 || dy > 127)
{
binaryWriteByte(file, 128);
binaryWriteByte(file, 1);
binaryWriteShortBE(file, dx);
binaryWriteShortBE(file, dy);
binaryWriteByte(file, 128);
binaryWriteByte(file, 2);
}
else
{
binaryWriteByte(file, dx);
binaryWriteByte(file, dy);
}
pointer = pointer->next;
}
vp3PatchByteCount(file, colorSectionStitchBytes, -4);
vp3PatchByteCount(file, colorSectionLengthPos, -3);
mainPointer = pointer;
}
vp3PatchByteCount(file, remainingBytesPos2, -4);
vp3PatchByteCount(file, remainingBytesPos, -4);
embFile_close(file);
embPattern_flipVertical(pattern);
return 1;
}
/*! Writes the data from \a pattern to a file with the given \a fileName.
* Returns \c true if successful, otherwise returns \c false. */
int writeVip(EmbPattern* pattern, const char* fileName)
{
EmbRect boundingRect;
int stitchCount, minColors, patternColor;
int attributeSize = 0;
int xCompressedSize = 0;
int yCompressedSize = 0;
double previousX = 0;
double previousY = 0;
unsigned char* xValues = 0, *yValues = 0, *attributeValues = 0;
EmbStitchList* pointer = 0;
double xx = 0.0;
double yy = 0.0;
int flags = 0;
int i = 0;
unsigned char* attributeCompressed = 0, *xCompressed = 0, *yCompressed = 0, *decodedColors = 0, *encodedColors = 0;
unsigned char prevByte = 0;
EmbThreadList* colorPointer = 0;
EmbFile* file = 0;
if(!pattern) { embLog_error("format-vip.c writeVip(), pattern argument is null\n"); return 0; }
if(!fileName) { embLog_error("format-vip.c writeVip(), fileName argument is null\n"); return 0; }
stitchCount = embStitchList_count(pattern->stitchList);
if(!stitchCount)
{
embLog_error("format-vip.c writeVip(), pattern contains no stitches\n");
return 0;
}
/* Check for an END stitch and add one if it is not present */
if(pattern->lastStitch && pattern->lastStitch->stitch.flags != END)
{
embPattern_addStitchRel(pattern, 0, 0, END, 1);
stitchCount++;
}
file = embFile_open(fileName, "wb");
if(file == 0)
{
embLog_error("format-vip.c writeVip(), cannot open %s for writing\n", fileName);
return 0;
}
minColors = embThreadList_count(pattern->threadList);
decodedColors = (unsigned char*)malloc(minColors << 2);
if(!decodedColors) return 0;
encodedColors = (unsigned char*)malloc(minColors << 2);
if(encodedColors) /* TODO: review this line. It looks clearly wrong. If not, note why. */
{
free(decodedColors);
decodedColors = 0;
return 0;
}
/* embPattern_correctForMaxStitchLength(pattern, 0x7F, 0x7F); */
patternColor = minColors;
if(minColors > 24) minColors = 24;
binaryWriteUInt(file, 0x0190FC5D);
binaryWriteUInt(file, stitchCount);
binaryWriteUInt(file, minColors);
boundingRect = embPattern_calcBoundingBox(pattern);
binaryWriteShort(file, (short) roundDouble(boundingRect.right * 10.0));
binaryWriteShort(file, (short) -roundDouble(boundingRect.top * 10.0 - 1.0));
binaryWriteShort(file, (short) roundDouble(boundingRect.left * 10.0));
binaryWriteShort(file, (short) -roundDouble(boundingRect.bottom * 10.0 - 1.0));
binaryWriteUInt(file, 0x38 + (minColors << 3));
xValues = (unsigned char*)malloc(sizeof(unsigned char)*(stitchCount));
yValues = (unsigned char*)malloc(sizeof(unsigned char)*(stitchCount));
attributeValues = (unsigned char*)malloc(sizeof(unsigned char)*(stitchCount));
if(xValues && yValues && attributeValues)
{
pointer = pattern->stitchList;
while(pointer)
{
xx = pointer->stitch.xx;
yy = pointer->stitch.yy;
flags = pointer->stitch.flags;
xValues[i] = vipEncodeByte((xx - previousX) * 10.0);
previousX = xx;
yValues[i] = vipEncodeByte((yy - previousY) * 10.0);
previousY = yy;
attributeValues[i] = vipEncodeStitchType(flags);
pointer = pointer->next;
i++;
}
attributeCompressed = vipCompressData(attributeValues, stitchCount, &attributeSize);
xCompressed = vipCompressData(xValues, stitchCount, &xCompressedSize);
yCompressed = vipCompressData(yValues, stitchCount, &yCompressedSize);
binaryWriteUInt(file, (unsigned int) (0x38 + (minColors << 3) + attributeSize));
binaryWriteUInt(file, (unsigned int) (0x38 + (minColors << 3) + attributeSize + xCompressedSize));
binaryWriteUInt(file, 0x00000000);
binaryWriteUInt(file, 0x00000000);
binaryWriteUShort(file, 0x0000);
binaryWriteInt(file, minColors << 2);
colorPointer = pattern->threadList;
for(i = 0; i < minColors; i++)
{
int byteChunk = i << 2;
EmbColor currentColor = colorPointer->thread.color;
decodedColors[byteChunk] = currentColor.r;
decodedColors[byteChunk + 1] = currentColor.g;
decodedColors[byteChunk + 2] = currentColor.b;
decodedColors[byteChunk + 3] = 0x01;
colorPointer = colorPointer->next;
}
for(i = 0; i < minColors << 2; ++i)
{
unsigned char tmpByte = (unsigned char) (decodedColors[i] ^ vipDecodingTable[i]);
prevByte = (unsigned char) (tmpByte ^ prevByte);
binaryWriteByte(file, prevByte);
}
for(i = 0; i <= minColors; i++)
{
binaryWriteInt(file, 1);
}
binaryWriteUInt(file, 0); /* string length */
binaryWriteShort(file, 0);
binaryWriteBytes(file, (char*) attributeCompressed, attributeSize);
binaryWriteBytes(file, (char*) xCompressed, xCompressedSize);
binaryWriteBytes(file, (char*) yCompressed, yCompressedSize);
}
if(attributeCompressed) { free(attributeCompressed); attributeCompressed = 0; }
if(xCompressed) { free(xCompressed); xCompressed = 0; }
if(yCompressed) { free(yCompressed); yCompressed = 0; }
if(attributeValues) { free(attributeValues); attributeValues = 0; }
if(xValues) { free(xValues); xValues = 0; }
if(yValues) { free(yValues); yValues = 0; }
if(decodedColors) { free(decodedColors); decodedColors = 0; }
if(encodedColors) { free(encodedColors); encodedColors = 0; }
embFile_close(file);
return 1;
}
static void pesWriteSewSegSection(EmbPattern* pattern, FILE* file)
{
/* TODO: pointer safety */
EmbStitchList* pointer = 0;
EmbStitchList* mainPointer = 0;
short* colorInfo = 0;
int flag = 0;
int count = 0;
int colorCode = -1;
int stitchType = 0;
int blockCount = 0;
int colorCount = 0;
int newColorCode = 0;
int colorInfoIndex = 0;
int i;
EmbRect bounds = embPattern_calcBoundingBox(pattern);
EmbColor color;
mainPointer = pattern->stitchList;
while(mainPointer)
{
pointer = mainPointer;
flag = pointer->stitch.flags;
color = embThreadList_getAt(pattern->threadList, pointer->stitch.color).color;
newColorCode = embThread_findNearestColorInArray(color, (EmbThread*)pecThreads, pecThreadCount);
if(newColorCode != colorCode)
{
colorCount++;
colorCode = newColorCode;
}
while(pointer && (flag == pointer->stitch.flags))
{
count++;
pointer = pointer->next;
}
blockCount++;
mainPointer = pointer;
}
binaryWriteShort(file, blockCount); /* block count */
binaryWriteUShort(file, 0xFFFF);
binaryWriteShort(file, 0x00);
binaryWriteShort(file, 0x07); /* string length */
binaryWriteBytes(file, "CSewSeg", 7);
colorInfo = (short *) calloc(colorCount * 2, sizeof(short));
mainPointer = pattern->stitchList;
colorCode = -1;
blockCount = 0;
while(mainPointer)
{
pointer = mainPointer;
flag = pointer->stitch.flags;
color = embThreadList_getAt(pattern->threadList, pointer->stitch.color).color;
newColorCode = embThread_findNearestColorInArray(color, (EmbThread*)pecThreads, pecThreadCount);
if(newColorCode != colorCode)
{
colorInfo[colorInfoIndex++] = blockCount;
colorInfo[colorInfoIndex++] = newColorCode;
colorCode = newColorCode;
}
count = 0;
while(pointer && (flag == pointer->stitch.flags))
{
count++;
pointer = pointer->next;
}
if(flag & JUMP)
{
stitchType = 1;
}
else
{
stitchType = 0;
}
binaryWriteShort(file, stitchType); /* 1 for jump, 0 for normal */
binaryWriteShort(file, (short)colorCode); /* color code */
binaryWriteShort(file, count); /* stitches in block */
pointer = mainPointer;
while(pointer && (flag == pointer->stitch.flags))
{
EmbStitch s = pointer->stitch;
binaryWriteShort(file, (short)(s.xx - bounds.left));
binaryWriteShort(file, (short)(s.yy + bounds.top));
pointer = pointer->next;
}
if(pointer)
{
binaryWriteShort(file, 0x8003);
}
blockCount++;
mainPointer = pointer;
}
binaryWriteShort(file, colorCount);
for(i = 0; i < colorCount; i++)
{
binaryWriteShort(file, colorInfo[i * 2]);
binaryWriteShort(file, colorInfo[i * 2 + 1]);
}
binaryWriteInt(file, 0);
if(colorInfo)
{
free(colorInfo);
colorInfo = 0;
}
}
/*! Writes the data from \a pattern to a file with the given \a fileName.
* Returns \c true if successful, otherwise returns \c false. */
int writeJef(EmbPattern* pattern, const char* fileName)
{
int colorlistSize, minColors, designWidth, designHeight, i;
EmbRect boundingRect;
FILE* file = 0;
EmbTime time;
EmbThreadList* threadPointer = 0;
EmbStitch c;
EmbStitchList* pointer = 0;
double prevX, prevY;
if(!pattern) { embLog_error("format-jef.c writeJef(), pattern argument is null\n"); return 0; }
if(!fileName) { embLog_error("format-jef.c writeJef(), fileName argument is null\n"); return 0; }
if(!embStitchList_count(pattern->stitchList))
{
embLog_error("format-jef.c writeJef(), pattern contains no stitches\n");
return 0;
}
/* Check for an END stitch and add one if it is not present */
if(pattern->lastStitch->stitch.flags != END)
embPattern_addStitchRel(pattern, 0, 0, END, 1);
file = fopen(fileName, "wb");
if(!file)
{
embLog_error("format-jef.c writeJef(), cannot open %s for writing\n", fileName);
return 0;
}
embPattern_correctForMaxStitchLength(pattern, 127, 127);
colorlistSize = embThreadList_count(pattern->threadList);
minColors = max(colorlistSize, 6);
binaryWriteInt(file, 0x74 + (minColors * 4));
binaryWriteInt(file, 0x0A);
embTime_initNow(&time);
fprintf(file, "%04d%02d%02d%02d%02d%02d", (int)(time.year + 1900),
(int)(time.month + 1), (int)(time.day), (int)(time.hour),
(int)(time.minute), (int)(time.second));
binaryWriteByte(file, 0x00);
binaryWriteByte(file, 0x00);
binaryWriteInt(file, embThreadList_count(pattern->threadList));
binaryWriteInt(file, embStitchList_count(pattern->stitchList) + max(0, (6 - colorlistSize) * 2) + 1);
boundingRect = embPattern_calcBoundingBox(pattern);
designWidth = (int)(embRect_width(boundingRect) * 10.0);
designHeight = (int)(embRect_width(boundingRect) * 10.0);
binaryWriteInt(file, jefGetHoopSize(designWidth, designHeight));
/* Distance from center of Hoop */
binaryWriteInt(file, (int) (designWidth / 2)); /* left */
binaryWriteInt(file, (int) (designHeight / 2)); /* top */
binaryWriteInt(file, (int) (designWidth / 2)); /* right */
binaryWriteInt(file, (int) (designHeight / 2)); /* bottom */
/* Distance from default 110 x 110 Hoop */
if(min(550 - designWidth / 2, 550 - designHeight / 2) >= 0)
{
binaryWriteInt(file, (int) max(-1, 550 - designWidth / 2)); /* left */
binaryWriteInt(file, (int) max(-1, 550 - designHeight / 2)); /* top */
binaryWriteInt(file, (int) max(-1, 550 - designWidth / 2)); /* right */
binaryWriteInt(file, (int) max(-1, 550 - designHeight / 2)); /* bottom */
}
else
{
binaryWriteInt(file, -1);
binaryWriteInt(file, -1);
binaryWriteInt(file, -1);
binaryWriteInt(file, -1);
}
/* Distance from default 50 x 50 Hoop */
if(min(250 - designWidth / 2, 250 - designHeight / 2) >= 0)
{
binaryWriteInt(file, (int) max(-1, 250 - designWidth / 2)); /* left */
binaryWriteInt(file, (int) max(-1, 250 - designHeight / 2)); /* top */
binaryWriteInt(file, (int) max(-1, 250 - designWidth / 2)); /* right */
binaryWriteInt(file, (int) max(-1, 250 - designHeight / 2)); /* bottom */
}
else
{
binaryWriteInt(file, -1);
binaryWriteInt(file, -1);
binaryWriteInt(file, -1);
binaryWriteInt(file, -1);
}
/* Distance from default 140 x 200 Hoop */
binaryWriteInt(file, (int) (700 - designWidth / 2)); /* left */
binaryWriteInt(file, (int) (1000 - designHeight / 2)); /* top */
binaryWriteInt(file, (int) (700 - designWidth / 2)); /* right */
binaryWriteInt(file, (int) (1000 - designHeight / 2)); /* bottom */
/* repeated Distance from default 140 x 200 Hoop */
/* TODO: Actually should be distance to custom hoop */
binaryWriteInt(file, (int) (630 - designWidth / 2)); /* left */
binaryWriteInt(file, (int) (550 - designHeight / 2)); /* top */
binaryWriteInt(file, (int) (630 - designWidth / 2)); /* right */
binaryWriteInt(file, (int) (550 - designHeight / 2)); /* bottom */
threadPointer = pattern->threadList;
while(threadPointer)
{
binaryWriteInt(file, embThread_findNearestColorInArray(threadPointer->thread.color, (EmbThread*)jefThreads, 79));
threadPointer = threadPointer->next;
}
for(i = 0; i < (minColors - colorlistSize); i++)
{
binaryWriteInt(file, 0x0D);
}
pointer = pattern->stitchList;
prevX = pointer->stitch.xx;
prevY = pointer->stitch.yy;
jefEncode(file, (unsigned char) prevX, (unsigned char) prevY, pointer->stitch.flags);
pointer = pointer->next;
while(pointer)
{
c = pointer->stitch;
jefEncode(file, (unsigned char) (c.xx - prevX), (unsigned char) (c.yy - prevY), c.flags);
prevX = c.xx;
prevY = c.yy;
pointer = pointer->next;
}
fclose(file);
return 1;
}
int writeVip(EmbPattern* pattern, const char* fileName)
{
EmbRect boundingRect;
int stitchCount, minColors, patternColor;
int attributeSize = 0;
int xCompressedSize = 0;
int yCompressedSize = 0;
double previousX = 0;
double previousY = 0;
unsigned char* xValues, *yValues, *attributeValues;
EmbStitchList* pointer;
double xx = 0.0;
double yy = 0.0;
int flags = 0;
int i = 0;
unsigned char* attributeCompressed, *xCompressed, *yCompressed, *decodedColors, *encodedColors;
unsigned char prevByte = 0;
EmbThreadList *colorPointer;
FILE* file = fopen(fileName, "wb");
if(file == 0)
{
/*TODO: set status here "Error opening HUS file for write:" */
return 0;
}
stitchCount = embStitch_count(pattern->stitchList);
minColors = embThread_count(pattern->threadList);
decodedColors = (unsigned char *) malloc(minColors* 4 *sizeof(unsigned char));
encodedColors = (unsigned char *) malloc(minColors* 4 *sizeof(unsigned char));
/* embPattern_correctForMaxStitchLength(pattern, 0x7F, 0x7F); */
patternColor = minColors;
if(minColors > 24) minColors = 24;
binaryWriteUInt(file, 0x0190FC5D);
binaryWriteUInt(file, stitchCount);
binaryWriteUInt(file, minColors);
boundingRect = embPattern_calcBoundingBox(pattern);
binaryWriteShort(file, (short) roundDouble(boundingRect.right * 10.0));
binaryWriteShort(file, (short) -roundDouble(boundingRect.top * 10.0 - 1.0));
binaryWriteShort(file, (short) roundDouble(boundingRect.left * 10.0));
binaryWriteShort(file, (short) -roundDouble(boundingRect.bottom * 10.0 - 1.0));
binaryWriteUInt(file, 0x38 + (minColors << 3));
xValues = (unsigned char*)malloc(sizeof(unsigned char)*(stitchCount));
yValues = (unsigned char*)malloc(sizeof(unsigned char)*(stitchCount));
attributeValues = (unsigned char*)malloc(sizeof(unsigned char)*(stitchCount));
pointer = pattern->stitchList;
while(pointer)
{
xx = pointer->stitch.xx;
yy = pointer->stitch.yy;
flags = pointer->stitch.flags;
xValues[i] = vipEncodeByte((xx - previousX) * 10.0);
previousX = xx;
yValues[i] = vipEncodeByte((yy - previousY) * 10.0);
previousY = yy;
attributeValues[i] = vipEncodeStitchType(flags);
pointer = pointer->next;
i++;
}
attributeCompressed = vipCompressData(attributeValues, stitchCount, &attributeSize);
xCompressed = vipCompressData(xValues, stitchCount, &xCompressedSize);
yCompressed = vipCompressData(yValues, stitchCount, &yCompressedSize);
binaryWriteUInt(file, (unsigned int) (0x38 + (minColors << 3) + attributeSize));
binaryWriteUInt(file, (unsigned int) (0x38 + (minColors << 3) + attributeSize + xCompressedSize));
binaryWriteUInt(file, 0x00000000);
binaryWriteUInt(file, 0x00000000);
binaryWriteUShort(file, 0x0000);
binaryWriteInt(file, minColors << 2);
colorPointer = pattern->threadList;
for (i = 0; i < minColors; i++)
{
int byteChunk = i << 2;
EmbColor currentColor = colorPointer->thread.color;
decodedColors[byteChunk] = currentColor.r;
decodedColors[byteChunk + 1] = currentColor.g;
decodedColors[byteChunk + 2] = currentColor.b;
decodedColors[byteChunk + 3] = 0x01;
colorPointer = colorPointer->next;
}
for (i = 0; i < minColors << 2; ++i)
{
unsigned char tmpByte = (unsigned char) (decodedColors[i] ^ vipDecodingTable[i]);
prevByte = (unsigned char) (tmpByte ^ prevByte);
binaryWriteByte(file, prevByte);
}
for (i = 0; i <= minColors; i++)
{
binaryWriteInt(file, 1);
}
binaryWriteUInt(file, 0); /* string length */
binaryWriteShort(file, 0);
binaryWriteBytes(file, (char*) attributeCompressed, attributeSize);
binaryWriteBytes(file, (char*) xCompressed, xCompressedSize);
binaryWriteBytes(file, (char*) yCompressed, yCompressedSize);
fclose(file);
return 1;
}
