-
-
Notifications
You must be signed in to change notification settings - Fork 14
/
embroidery.c
20489 lines (18783 loc) · 584 KB
/
embroidery.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* Libembroidery 1.0.0-alpha
* https://www.libembroidery.org
*
* A library for reading, writing, altering and otherwise
* processing machine embroidery files and designs.
*
* Also, the core library supporting the Embroidermodder Project's
* family of machine embroidery interfaces.
*
* ---------------------------------------------------------
*
* Copyright 2018-2024 The Embroidermodder Team
* Licensed under the terms of the zlib license.
*
*/
#include "embroidery.h"
const int NUMBINS = 10;
double epsilon = 0.000000001;
double emb_included_angle(EmbGeometry *geometry);
/* System-specific functions.
*
* Only uses source from this directory or standard C libraries,
* not including POSIX headers like unistd since this library
* needs to support non-POSIX systems like Windows.
*
* ---------------------------------------------------------
*
* In order to support embedded systems and WASM these need to
* be replaced, see the #else block below.
*/
#ifndef EMB_EMBEDDED
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <inttypes.h>
#include <string.h>
#include <stdbool.h>
void *
emb_fopen(const char *fname, const char *mode)
{
return (void *)fopen(fname, mode);
}
int
emb_fread(void *data, int length, void *file_pointer)
{
return fread((unsigned char *)data, 1, length, (void*)file_pointer);
}
int
emb_fwrite(void *data, int length, void *file_pointer)
{
return fwrite((unsigned char *)data, 1, length, (void*)file_pointer);
}
int
emb_fseek(void *file, int offset, int from)
{
return emb_fseek((FILE*)file, offset, from);
}
void
emb_fclose(void *f)
{
fclose((void*)f);
}
#else
/* For other systems, file i/o functions like emb_fread/emb_fwrite have
* to be defined by the includer. So this list of functions defines what
* a new platform would have to define.
*
* Emscripten doesn't use this, it's not considered "EMB_EMBEDDED".
*/
typedef long unsigned int size_t;
static const int stdin = 0;
static const int EOF = -1;
static const int SEEK_SET = 2;
#define NULL ((void*)0)
void *malloc(long unsigned int);
void *realloc(void *, long unsigned int);
void *calloc(long unsigned int, long unsigned int);
void free(void *);
/* These often have in-built assembly commands: so it's very chip-specific. */
double fabs(double);
double cos(double);
double sin(double);
double sqrt(double);
double ceil(double);
double floor(double);
float fmodf(float, float);
double atan2(double, double);
double atan(double);
int puts(const char *);
int printf(const char *, ...);
void *emb_fopen(const char *fname, const char *mode);
int emb_fread(void *data, int length, void *file_pointer);
int emb_fwrite(void *data, int length, void *file_pointer);
void emb_fclose(void *f);
int emb_fseek(void *file, int offset, int from);
#endif
/* Internal function declarations.
* ----------------------------------------------------------------------------
*/
/* Utility Functions: merge first three with string library */
int stringInArray(const char *s, const char **array);
char *copy_trim(char const *s);
char* emb_optOut(EmbReal num, char* str);
void safe_free(void *data);
int testMain(int);
/* DIFAT functions */
unsigned int entriesInDifatSector(bcf_file_difat* fat);
bcf_file_fat* bcfFileFat_create(const unsigned int sectorSize);
void loadFatFromSector(bcf_file_fat* fat, void* file);
void bcf_file_fat_free(bcf_file_fat** fat);
bcf_directory* CompoundFileDirectory(const unsigned int maxNumberOfDirectoryEntries);
void bcf_directory_free(bcf_directory** dir);
unsigned int numberOfEntriesInDifatSector(bcf_file_difat* fat);
void bcf_file_difat_free(bcf_file_difat* difat);
bcf_file_header bcfFileHeader_read(void* file);
int bcfFileHeader_isValid(bcf_file_header header);
void bcf_file_free(bcf_file* bcfFile);
static EmbPattern *focussed_pattern = NULL;
void
printArcResults(
EmbReal bulge,
EmbArc arc,
EmbVector center,
EmbReal radius,
EmbReal diameter,
EmbReal chord,
EmbVector chordMid,
EmbReal sagitta,
EmbReal apothem,
EmbReal incAngle,
char clockwise);
int testTangentPoints(EmbCircle c, EmbVector p, EmbVector *t0, EmbVector *t1);
int create_test_file(int test_file, int format);
/* Encoding/decoding and compression functions. */
int hus_compress(char* input, int size, char* output, int *out_size);
int hus_decompress(char* input, int size, char* output, int *out_size);
void huffman_build_table(huffman *h);
int *huffman_table_lookup(huffman *h, int byte_lookup, int *lengths);
int compress_get_bits(compress *c, int length);
int compress_pop(compress *c, int bit_count);
int compress_read_variable_length(compress *c);
void compress_load_character_length_huffman(compress *c);
void compress_load_character_huffman(compress *c);
void compress_load_distance_huffman(compress *c);
void compress_load_block(compress *c);
int compress_get_token(compress *c);
int compress_get_position(compress *c);
EmbReal pfaffDecode(unsigned char a1, unsigned char a2, unsigned char a3);
int decodeNewStitch(unsigned char value);
unsigned char mitEncodeStitch(EmbReal value);
int mitDecodeStitch(unsigned char value);
void encode_t01_record(unsigned char b[3], int x, int y, int flags);
int decode_t01_record(unsigned char b[3], int *x, int *y, int *flags);
int encode_tajima_ternary(unsigned char b[3], int x, int y);
void decode_tajima_ternary(unsigned char b[3], int *x, int *y);
/*
* Note that this file only has to exist because we cannot necessary include
* any of the C standard library on all platforms. For example, "void *" and
* "printf" aren't universal. See the "Supported Platforms" section of
* the reference manual.
*/
/* Function Declarations */
void readPecStitches(EmbPattern* pattern, void* file);
void writePecStitches(EmbPattern* pattern, void* file, const char* filename);
void pfaffEncode(void* file, int x, int y, int flags);
void readPESHeaderV5(void* file, EmbPattern* pattern);
void readPESHeaderV6(void* file, EmbPattern* pattern);
void readPESHeaderV7(void* file, EmbPattern* pattern);
void readPESHeaderV8(void* file, EmbPattern* pattern);
void readPESHeaderV9(void* file, EmbPattern* pattern);
void readPESHeaderV10(void* file, EmbPattern* pattern);
void readDescriptions(void* file, EmbPattern* pattern);
void readHoopName(void* file, EmbPattern* pattern);
void readImageString(void* file, EmbPattern* pattern);
void readProgrammableFills(void* file, EmbPattern* pattern);
void readMotifPatterns(void* file, EmbPattern* pattern);
void readFeatherPatterns(void* file, EmbPattern* pattern);
void readThreads(void* file, EmbPattern* pattern);
void emb_read(void* f, void *b, int mode);
void emb_write(void* f, void *b, int mode);
int emb_readline(void* file, char *line, int maxLength);
int bcfFile_read(void* file, bcf_file* bcfFile);
void* GetFile(bcf_file* bcfFile, void* file, char* fileToFind);
void binaryReadString(void* file, char *buffer, int maxLength);
void binaryReadUnicodeString(void* file, char *buffer, const int stringLength);
void fpad(void *f, char c, int n);
void write_24bit(void* file, int);
int check_header_present(void* file, int minimum_header_length);
unsigned short emb_read_u16(void *file);
short emb_read_i16(void* f);
void emb_write_u32be(void* f, unsigned int data);
void emb_write_u32(void* f, unsigned int data);
void emb_write_i32be(void* f, int data);
void emb_write_i32(void* f, int data);
void emb_write_u16(void* f, unsigned short data);
void emb_write_u16BE(void* f, unsigned short data);
void emb_write_i16(void* f, int16_t data);
bcf_file_difat* bcf_difat_create(void* file, unsigned int fatSectors, const unsigned int sectorSize);
unsigned int readFullSector(void* file, bcf_file_difat* bcfFile, unsigned int* numberOfDifatEntriesStillToRead);
bcf_directory_entry* CompoundFileDirectoryEntry(void* file);
void readNextSector(void* file, bcf_directory* dir);
void embColor_read(void *f, EmbColor *c, int toRead);
void embColor_write(void *f, EmbColor c, int toWrite);
unsigned char toyota_position_encode(EmbReal a);
EmbReal toyota_position_decode(unsigned char a);
void toyota_100_encode(EmbVector *position, EmbStitch *st, unsigned char *b);
void toyota_100_decode(EmbVector *position, EmbStitch *st, unsigned char *b);
void toyota_10o_encode(EmbVector *position, EmbStitch *st, unsigned char *b);
void toyota_10o_decode(EmbVector *position, EmbStitch *st, unsigned char *b);
void bernina_art_encode(EmbVector *position, EmbStitch *st, unsigned char *b);
void bernina_art_decode(EmbVector *position, EmbStitch *st, unsigned char *b);
char read_stitch_block(
EmbPattern *,
void *file,
void (*stitch_encoder)(EmbVector *, EmbStitch *, unsigned char *),
int stitch_data_size,
int mode
);
char write_stitch_block(
EmbPattern *,
void *file,
void (*stitch_encoder)(EmbVector *, EmbStitch *, unsigned char *),
int stitch_data_size,
int mode
);
char readBmc(EmbPattern *pattern, void* file);
char writeBmc(EmbPattern *pattern, void* file);
char readBro(EmbPattern *pattern, void* file);
char writeBro(EmbPattern *pattern, void* file);
char readCnd(EmbPattern *pattern, void* file);
char writeCnd(EmbPattern *pattern, void* file);
char readCol(EmbPattern *pattern, void* file);
char writeCol(EmbPattern *pattern, void* file);
char readCsd(EmbPattern *pattern, void* file);
char writeCsd(EmbPattern *pattern, void* file);
char readCsv(EmbPattern *pattern, void* file);
char writeCsv(EmbPattern *pattern, void* file);
char readDat(EmbPattern *pattern, void* file);
char writeDat(EmbPattern *pattern, void* file);
char readDem(EmbPattern *pattern, void* file);
char writeDem(EmbPattern *pattern, void* file);
char readDsb(EmbPattern *pattern, void* file);
char writeDsb(EmbPattern *pattern, void* file);
char readDst(EmbPattern *pattern, void* file);
char writeDst(EmbPattern *pattern, void* file);
char readDsz(EmbPattern *pattern, void* file);
char writeDsz(EmbPattern *pattern, void* file);
char readDxf(EmbPattern *pattern, void* file);
char writeDxf(EmbPattern *pattern, void* file);
char readEdr(EmbPattern *pattern, void* file);
char writeEdr(EmbPattern *pattern, void* file);
char readEmd(EmbPattern *pattern, void* file);
char writeEmd(EmbPattern *pattern, void* file);
char readExp(EmbPattern *pattern, void* file);
char writeExp(EmbPattern *pattern, void* file);
char readExy(EmbPattern *pattern, void* file);
char writeExy(EmbPattern *pattern, void* file);
char readEys(EmbPattern *pattern, void* file);
char writeEys(EmbPattern *pattern, void* file);
char readFxy(EmbPattern *pattern, void* file);
char writeFxy(EmbPattern *pattern, void* file);
char readGc(EmbPattern *pattern, void* file);
char writeGc(EmbPattern *pattern, void* file);
char readGnc(EmbPattern *pattern, void* file);
char writeGnc(EmbPattern *pattern, void* file);
char readGt(EmbPattern *pattern, void* file);
char writeGt(EmbPattern *pattern, void* file);
char readHus(EmbPattern *pattern, void* file);
char writeHus(EmbPattern *pattern, void* file);
char readInb(EmbPattern *pattern, void* file);
char writeInb(EmbPattern *pattern, void* file);
char readInf(EmbPattern *pattern, void* file);
char writeInf(EmbPattern *pattern, void* file);
char readJef(EmbPattern *pattern, void* file);
char writeJef(EmbPattern *pattern, void* file);
char readKsm(EmbPattern *pattern, void* file);
char writeKsm(EmbPattern *pattern, void* file);
char readMax(EmbPattern *pattern, void* file);
char writeMax(EmbPattern *pattern, void* file);
char readMit(EmbPattern *pattern, void* file);
char writeMit(EmbPattern *pattern, void* file);
char readNew(EmbPattern *pattern, void* file);
char writeNew(EmbPattern *pattern, void* file);
char readOfm(EmbPattern *pattern, void* file);
char writeOfm(EmbPattern *pattern, void* file);
char readPcd(EmbPattern *pattern, const char *fileName, void* file);
char writePcd(EmbPattern *pattern, void* file);
char readPcm(EmbPattern *pattern, void* file);
char writePcm(EmbPattern *pattern, void* file);
char readPcq(EmbPattern *pattern, const char *fileName, void* file);
char writePcq(EmbPattern *pattern, void* file);
char readPcs(EmbPattern *pattern, const char *fileName, void* file);
char writePcs(EmbPattern *pattern, void* file);
char readPec(EmbPattern *pattern, const char *fileName, void* file);
char writePec(EmbPattern *pattern, const char *fileName, void* file);
char readPel(EmbPattern *pattern, void *file);
char writePel(EmbPattern *pattern, void *file);
char readPem(EmbPattern *pattern, void *file);
char writePem(EmbPattern *pattern, void *file);
char readPes(EmbPattern *pattern, const char *fileName, void* file);
char writePes(EmbPattern *pattern, const char *fileName, void* file);
char readPhb(EmbPattern *pattern, void* file);
char writePhb(EmbPattern *pattern, void *file);
char readPhc(EmbPattern *pattern, void* file);
char writePhc(EmbPattern *pattern, void *file);
char readPlt(EmbPattern *pattern, void* file);
char writePlt(EmbPattern *pattern, void* file);
char readRgb(EmbPattern *pattern, void* file);
char writeRgb(EmbPattern *pattern, void* file);
char readSew(EmbPattern *pattern, void* file);
char writeSew(EmbPattern *pattern, void* file);
char readShv(EmbPattern *pattern, void* file);
char writeShv(EmbPattern *pattern, void *file);
char readSst(EmbPattern *pattern, void* file);
char writeSst(EmbPattern *pattern, void *file);
char readStx(EmbPattern *pattern, void* file);
char writeStx(EmbPattern *pattern, void *file);
char readSvg(EmbPattern *pattern, void* file);
char writeSvg(EmbPattern *pattern, void* file);
char readT01(EmbPattern *pattern, void* file);
char writeT01(EmbPattern *pattern, void* file);
char readT09(EmbPattern *pattern, void* file);
char writeT09(EmbPattern *pattern, void* file);
char readTap(EmbPattern *pattern, void* file);
char writeTap(EmbPattern *pattern, void* file);
char readThr(EmbPattern *pattern, void* file);
char writeThr(EmbPattern *pattern, void* file);
char readTxt(EmbPattern *pattern, void* file);
char writeTxt(EmbPattern *pattern, void* file);
char readU00(EmbPattern *pattern, void* file);
char writeU00(EmbPattern *pattern, void *file);
char readU01(EmbPattern *pattern, void* file);
char writeU01(EmbPattern *pattern, void *file);
char readVip(EmbPattern *pattern, void* file);
char writeVip(EmbPattern *pattern, void* file);
char readVp3(EmbPattern *pattern, void* file);
char writeVp3(EmbPattern *pattern, void* file);
char readXxx(EmbPattern *pattern, void* file);
char writeXxx(EmbPattern *pattern, void* file);
char readZsk(EmbPattern *pattern, void* file);
char writeZsk(EmbPattern *pattern, void* file);
void write_24bit(void* file, int);
/* Replacing functions that compilers complain about.
* In some cases, this is due to valid concerns about
* functions not returning (like a string without null-termination).
*
* We don't use size_t because it's system-specific.
*
* IDEA: don't rely on "sizeof" because it's system and
* compiler-specific, depending on how the struct is packed.
* We could manually pack out structs and then know exactly
* how much space they need.
*
* TODO: UTF-8 support.
*/
void string_copy(char *dst, const char *src);
int string_equals(const char *s1, const char *s2);
int string_len(const char *src);
void string_cat(char *dst, const char *src);
int string_rchar(const char *s1, char c);
void char_ptr_to_string(char *dst, char *src);
void memory_copy(void *dst, const void *src, int n);
char memory_cmp(void *dst, const void *src, int n);
/* Internal Data
* ----------------------------------------------------------------------------
*
* This file contains all the read and write functions for the
* library.
*
* .. todo::
* This list needs reviewed in case some stitch
* formats also can contain object data (EMBFORMAT_STCHANDOBJ). *
*/
EmbFormatList formatTable[numberOfFormats] = {
{".10o", "Toyota Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".100", "Toyota Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".art", "Bernina Embroidery Format", ' ', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".bmc", "Bitmap Cache Embroidery Format", ' ', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".bro", "Bits & Volts Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".cnd", "Melco Embroidery Format", ' ', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".col", "Embroidery Thread Color Format", 'U', 'U', EMBFORMAT_STITCHONLY, 1, 0, 0},
{".csd", "Singer Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".csv", "Comma Separated Values Format", 'U', 'U', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".dat", "Barudan Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".dem", "Melco Embroidery Format", ' ', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".dsb", "Barudan Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".dst", "Tajima Embroidery Format", 'U', 'U', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".dsz", "ZSK USA Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".dxf", "Drawing Exchange Format", ' ', ' ', EMBFORMAT_OBJECTONLY, 0, 0, 0},
{".edr", "Embird Embroidery Format", 'U', 'U', EMBFORMAT_STITCHONLY, 1, 0, 0},
{".emd", "Elna Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".exp", "Melco Embroidery Format", 'U', 'U', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".exy", "Eltac Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".eys", "Sierra Expanded Embroidery Format", ' ', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".fxy", "Fortron Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".gc", "Smoothie G-Code Format", ' ', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".gnc", "Great Notions Embroidery Format", ' ', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".gt", "Gold Thread Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".hus", "Husqvarna Viking Embroidery Format", 'U', 'U', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".inb", "Inbro Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".inf", "Embroidery Color Format", 'U', 'U', EMBFORMAT_STITCHONLY, 1, 0, 0},
{".jef", "Janome Embroidery Format", 'U', 'U', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".ksm", "Pfaff Embroidery Format", 'U', 'U', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".max", "Pfaff Embroidery Format", 'U', 'U', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".mit", "Mitsubishi Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".new", "Ameco Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".ofm", "Melco Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".pcd", "Pfaff Embroidery Format", 'U', 'U', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".pcm", "Pfaff Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".pcq", "Pfaff Embroidery Format", 'U', 'U', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".pcs", "Pfaff Embroidery Format", 'U', 'U', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".pec", "Brother Embroidery Format", 'U', 'U', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".pel", "Brother Embroidery Format", ' ', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".pem", "Brother Embroidery Format", ' ', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".pes", "Brother Embroidery Format", 'U', 'U', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".phb", "Brother Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".phc", "Brother Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".plt", "AutoCAD Plot Drawing Format", 'U', 'U', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".rgb", "RGB Embroidery Format", 'U', 'U', EMBFORMAT_STITCHONLY, 1, 0, 0},
{".sew", "Janome Embroidery Format", 'U', 'U', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".shv", "Husqvarna Viking Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".sst", "Sunstar Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".stx", "Data Stitch Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".svg", "Scalable Vector Graphics", 'U', 'U', EMBFORMAT_OBJECTONLY, 0, 0, 0},
{".t01", "Pfaff Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".t09", "Pfaff Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".tap", "Happy Embroidery Format", 'U', 'U', EMBFORMAT_STITCHONLY, 0, 1, 0},
{".thr", "ThredWorks Embroidery Format", 'U', 'U', EMBFORMAT_STITCHONLY, 1, 0, 0},
{".txt", "Text File", ' ', 'U', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".u00", "Barudan Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".u01", "Barudan Embroidery Format", ' ', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".vip", "Pfaff Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".vp3", "Pfaff Embroidery Format", 'U', 'U', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".xxx", "Singer Embroidery Format", 'U', 'U', EMBFORMAT_STITCHONLY, 0, 0, 0},
{".zsk", "ZSK USA Embroidery Format", 'U', ' ', EMBFORMAT_STITCHONLY, 0, 0, 0}
};
const char *help_msg[] = {
"Usage: embroider [OPTIONS] fileToRead... ",
"",
"Conversion:",
" -t, --to Convert all files given to the format specified",
" by the arguments to the flag, for example:",
" $ embroider -t dst input.pes",
" would convert \"input.pes\" to \"input.dst\"",
" in the same directory the program runs in.",
"",
" The accepted input formats are (TO BE DETERMINED).",
" The accepted output formats are (TO BE DETERMINED).",
"",
"Output:",
" -h, --help Print this message.",
" -F, --formats Print help on the formats that embroider can deal with.",
" -q, --quiet Only print fatal errors.",
" -V, --verbose Print everything that has reporting.",
" -v, --version Print the version.",
"",
"Modify patterns:",
" --combine takes 3 arguments and combines the first",
" two by placing them atop each other and",
" outputs to the third",
" $ embroider --combine a.dst b.dst output.dst",
"",
"Graphics:",
" -c, --circle Add a circle defined by the arguments given to the current pattern.",
" -e, --ellipse Add a circle defined by the arguments given to the current pattern.",
" -l, --line Add a line defined by the arguments given to the current pattern.",
" -P, --polyline Add a polyline.",
" -p, --polygon Add a polygon.",
" -r, --render Create an image in PNG format of what the embroidery should look like.",
" -s, --satin Fill the current geometry with satin stitches according",
" to the defined algorithm.",
" -S, --stitch Add a stitch defined by the arguments given to the current pattern.",
"",
"Quality Assurance:",
" --test N Run the test number N.",
" --convert-test A N M Test conversion of test file A from format N to format M.",
" --full-test-suite Run all tests, even those we expect to fail.",
"EOF"
};
/* EmbString table of flags. */
const EmbString flag_list[] = {
"--to",
"-t",
"--help",
"-h",
"--formats",
"-F",
"--quiet",
"-q",
"--verbose",
"-V",
"--version",
"-v",
"--circle",
"-c",
"--ellipse",
"-e",
"--line",
"-l",
"--polyline",
"-P",
"--polygon",
"-p",
"--render",
"-r",
"--satin",
"-s",
"--stitch",
"-S",
"--test",
"--full-test-suite",
"--convert-test",
"--hilbert-curve",
"--sierpinski-triangle",
"--fill",
"-f",
"--simulate",
"--combine",
"--cross-stitch",
"--ps"
};
const char *version_string = "embroider v0.1";
const char *welcome_message = "EMBROIDER\n"
" A command line program for machine embroidery.\n"
" Copyright 2013-2022 The Embroidermodder Team\n"
" Licensed under the terms of the zlib license.\n"
"\n"
" https://github.com/Embroidermodder/libembroidery\n"
" https://embroidermodder.org\n";
EmbThread black_thread = { { 0, 0, 0 }, "Black", "Black" };
int emb_verbose = 0;
const EmbReal embConstantPi = 3.1415926535;
/* Constant representing the number of EmbReal Indirect FAT
* entries in a single header */
const unsigned int difatEntriesInHeader = 109;
const unsigned int sizeOfFatEntry = sizeof(unsigned int);
const unsigned int sizeOfDifatEntry = 4;
const unsigned int sizeOfChainingEntryAtEndOfDifatSector = 4;
const unsigned int sizeOfDirectoryEntry = 128;
/*
const int supportedMinorVersion = 0x003E;
const int littleEndianByteOrderMark = 0xFFFE;
*/
/* Based on the DraftSight color table. It doesn't appear to be authoratitive
* and there isn't much said in the official manual about colors 8-255:
* http://images.autodesk.com/adsk/files/autocad_2012_pdf_dxf-reference_enu.pdf
*
* A possible "standard" solution here is to use xterm ESC color codes with the first
* 8 overridden for compatibility. That way a curious user may be able to guess
* and be _almost_ right. See this script for how simple those codes are:
* https://gist.github.com/hSATAC/1095100
*/
const unsigned char _dxfColorTable[][3] = {
{ 0, 0, 0 }, /* '0' (BYBLOCK) */
{ 255, 0, 0 }, /* '1' (red) */
{ 255, 255, 0 }, /* '2' (yellow) */
{ 0, 255, 0 }, /* '3' (green) */
{ 0, 255, 255 }, /* '4' (cyan) */
{ 0, 0, 255 }, /* '5' (blue) */
{ 255, 0, 255 }, /* '6' (magenta) */
{ 255, 255, 255 }, /* '7' (white) */
{ 128, 128, 128 }, /* '8' (dark gray) */
{ 192, 192, 192 }, /* '9' (light gray) */
{ 255, 0, 0 }, /* '10' */
{ 255, 127, 127 }, /* '11' */
{ 204, 0, 0 }, /* '12' */
{ 204, 102, 102 }, /* '13' */
{ 153, 0, 0 }, /* '14' */
{ 153, 76, 76 }, /* '15' */
{ 127, 0, 0 }, /* '16' */
{ 127, 63, 63 }, /* '17' */
{ 76, 0, 0 }, /* '18' */
{ 76, 38, 38 }, /* '19' */
{ 255, 63, 0 }, /* '20' */
{ 255, 159, 127 }, /* '21' */
{ 204, 51, 0 }, /* '22' */
{ 204, 127, 102 }, /* '23' */
{ 153, 38, 0 }, /* '24' */
{ 153, 95, 76 }, /* '25' */
{ 127, 31, 0 }, /* '26' */
{ 127, 79, 63 }, /* '27' */
{ 76, 19, 0 }, /* '28' */
{ 76, 47, 38 }, /* '29' */
{ 255, 127, 0 }, /* '30' */
{ 255, 191, 127 }, /* '31' */
{ 204, 102, 0 }, /* '32' */
{ 204, 153, 102 }, /* '33' */
{ 153, 76, 0 }, /* '34' */
{ 153, 114, 76 }, /* '35' */
{ 127, 63, 0 }, /* '36' */
{ 127, 95, 63 }, /* '37' */
{ 76, 38, 0 }, /* '38' */
{ 76, 57, 38 }, /* '39' */
{ 255, 191, 0 }, /* '40' */
{ 255, 223, 127 }, /* '41' */
{ 204, 153, 0 }, /* '42' */
{ 204, 178, 102 }, /* '43' */
{ 153, 114, 0 }, /* '44' */
{ 153, 133, 76 }, /* '45' */
{ 127, 95, 0 }, /* '46' */
{ 127, 111, 63 }, /* '47' */
{ 76, 57, 0 }, /* '48' */
{ 76, 66, 38 }, /* '49' */
{ 255, 255, 0 }, /* '50' */
{ 255, 255, 127 }, /* '51' */
{ 204, 204, 0 }, /* '52' */
{ 204, 204, 102 }, /* '53' */
{ 153, 153, 0 }, /* '54' */
{ 153, 153, 76 }, /* '55' */
{ 127, 127, 0 }, /* '56' */
{ 127, 127, 63 }, /* '57' */
{ 76, 76, 0 }, /* '58' */
{ 76, 76, 38 }, /* '59' */
{ 191, 255, 0 }, /* '60' */
{ 223, 255, 127 }, /* '61' */
{ 153, 204, 0 }, /* '62' */
{ 178, 204, 102 }, /* '63' */
{ 114, 153, 0 }, /* '64' */
{ 133, 153, 76 }, /* '65' */
{ 95, 127, 0 }, /* '66' */
{ 111, 127, 63 }, /* '67' */
{ 57, 76, 0 }, /* '68' */
{ 66, 76, 38 }, /* '69' */
{ 127, 255, 0 }, /* '70' */
{ 191, 255, 127 }, /* '71' */
{ 102, 204, 0 }, /* '72' */
{ 153, 204, 102 }, /* '73' */
{ 76, 153, 0 }, /* '74' */
{ 114, 153, 76 }, /* '75' */
{ 63, 127, 0 }, /* '76' */
{ 95, 127, 63 }, /* '77' */
{ 38, 76, 0 }, /* '78' */
{ 57, 76, 38 }, /* '79' */
{ 63, 255, 0 }, /* '80' */
{ 159, 255, 127 }, /* '81' */
{ 51, 204, 0 }, /* '82' */
{ 127, 204, 102 }, /* '83' */
{ 38, 153, 0 }, /* '84' */
{ 95, 153, 76 }, /* '85' */
{ 31, 127, 0 }, /* '86' */
{ 79, 127, 63 }, /* '87' */
{ 19, 76, 0 }, /* '88' */
{ 47, 76, 38 }, /* '89' */
{ 0, 255, 0 }, /* '90' */
{ 127, 255, 127 }, /* '91' */
{ 0, 204, 0 }, /* '92' */
{ 102, 204, 102 }, /* '93' */
{ 0, 153, 0 }, /* '94' */
{ 76, 153, 76 }, /* '95' */
{ 0, 127, 0 }, /* '96' */
{ 63, 127, 63 }, /* '97' */
{ 0, 76, 0 }, /* '98' */
{ 38, 76, 38 }, /* '99' */
{ 0, 255, 63 }, /* '100' */
{ 127, 255, 159 }, /* '101' */
{ 0, 204, 51 }, /* '102' */
{ 102, 204, 127 }, /* '103' */
{ 0, 153, 38 }, /* '104' */
{ 76, 153, 95 }, /* '105' */
{ 0, 127, 31 }, /* '106' */
{ 63, 127, 79 }, /* '107' */
{ 0, 76, 19 }, /* '108' */
{ 38, 76, 47 }, /* '109' */
{ 0, 255, 127 }, /* '110' */
{ 127, 255, 191 }, /* '111' */
{ 0, 204, 102 }, /* '112' */
{ 102, 204, 153 }, /* '113' */
{ 0, 153, 76 }, /* '114' */
{ 76, 153, 114 }, /* '115' */
{ 0, 127, 63 }, /* '116' */
{ 63, 127, 95 }, /* '117' */
{ 0, 76, 38 }, /* '118' */
{ 38, 76, 57 }, /* '119' */
{ 0, 255, 191 }, /* '120' */
{ 127, 255, 223 }, /* '121' */
{ 0, 204, 153 }, /* '122' */
{ 102, 204, 178 }, /* '123' */
{ 0, 153, 114 }, /* '124' */
{ 76, 153, 133 }, /* '125' */
{ 0, 127, 95 }, /* '126' */
{ 63, 127, 111 }, /* '127' */
{ 0, 76, 57 }, /* '128' */
{ 38, 76, 66 }, /* '129' */
{ 0, 255, 255 }, /* '130' */
{ 127, 255, 255 }, /* '131' */
{ 0, 204, 204 }, /* '132' */
{ 102, 204, 204 }, /* '133' */
{ 0, 153, 153 }, /* '134' */
{ 76, 153, 153 }, /* '135' */
{ 0, 127, 127 }, /* '136' */
{ 63, 127, 127 }, /* '137' */
{ 0, 76, 76 }, /* '138' */
{ 38, 76, 76 }, /* '139' */
{ 0, 191, 255 }, /* '140' */
{ 127, 223, 255 }, /* '141' */
{ 0, 153, 204 }, /* '142' */
{ 102, 178, 204 }, /* '143' */
{ 0, 114, 153 }, /* '144' */
{ 76, 133, 153 }, /* '145' */
{ 0, 95, 127 }, /* '146' */
{ 63, 111, 127 }, /* '147' */
{ 0, 57, 76 }, /* '148' */
{ 38, 66, 76 }, /* '149' */
{ 0, 127, 255 }, /* '150' */
{ 127, 191, 255 }, /* '151' */
{ 0, 102, 204 }, /* '152' */
{ 102, 153, 204 }, /* '153' */
{ 0, 76, 153 }, /* '154' */
{ 76, 114, 153 }, /* '155' */
{ 0, 63, 127 }, /* '156' */
{ 63, 95, 127 }, /* '157' */
{ 0, 38, 76 }, /* '158' */
{ 38, 57, 76 }, /* '159' */
{ 0, 63, 255 }, /* '160' */
{ 127, 159, 255 }, /* '161' */
{ 0, 51, 204 }, /* '162' */
{ 102, 127, 204 }, /* '163' */
{ 0, 38, 153 }, /* '164' */
{ 76, 95, 153 }, /* '165' */
{ 0, 31, 127 }, /* '166' */
{ 63, 79, 127 }, /* '167' */
{ 0, 19, 76 }, /* '168' */
{ 38, 47, 76 }, /* '169' */
{ 0, 0, 255 }, /* '170' */
{ 127, 127, 255 }, /* '171' */
{ 0, 0, 204 }, /* '172' */
{ 102, 102, 204 }, /* '173' */
{ 0, 0, 153 }, /* '174' */
{ 76, 76, 153 }, /* '175' */
{ 0, 0, 127 }, /* '176' */
{ 63, 63, 127 }, /* '177' */
{ 0, 0, 76 }, /* '178' */
{ 38, 38, 76 }, /* '179' */
{ 63, 0, 255 }, /* '180' */
{ 159, 127, 255 }, /* '181' */
{ 51, 0, 204 }, /* '182' */
{ 127, 102, 204 }, /* '183' */
{ 38, 0, 153 }, /* '184' */
{ 95, 76, 153 }, /* '185' */
{ 31, 0, 127 }, /* '186' */
{ 79, 63, 127 }, /* '187' */
{ 19, 0, 76 }, /* '188' */
{ 47, 38, 76 }, /* '189' */
{ 127, 0, 255 }, /* '190' */
{ 191, 127, 255 }, /* '191' */
{ 102, 0, 204 }, /* '192' */
{ 153, 102, 204 }, /* '193' */
{ 76, 0, 153 }, /* '194' */
{ 114, 76, 153 }, /* '195' */
{ 63, 0, 127 }, /* '196' */
{ 95, 63, 127 }, /* '197' */
{ 38, 0, 76 }, /* '198' */
{ 57, 38, 76 }, /* '199' */
{ 191, 0, 255 }, /* '200' */
{ 223, 127, 255 }, /* '201' */
{ 153, 0, 204 }, /* '202' */
{ 178, 102, 204 }, /* '203' */
{ 114, 0, 153 }, /* '204' */
{ 133, 76, 153 }, /* '205' */
{ 95, 0, 127 }, /* '206' */
{ 111, 63, 127 }, /* '207' */
{ 57, 0, 76 }, /* '208' */
{ 66, 38, 76 }, /* '209' */
{ 255, 0, 255 }, /* '210' */
{ 255, 127, 255 }, /* '211' */
{ 204, 0, 204 }, /* '212' */
{ 204, 102, 204 }, /* '213' */
{ 153, 0, 153 }, /* '214' */
{ 153, 76, 153 }, /* '215' */
{ 127, 0, 127 }, /* '216' */
{ 127, 63, 127 }, /* '217' */
{ 76, 0, 76 }, /* '218' */
{ 76, 38, 76 }, /* '219' */
{ 255, 0, 191 }, /* '220' */
{ 255, 127, 223 }, /* '221' */
{ 204, 0, 153 }, /* '222' */
{ 204, 102, 178 }, /* '223' */
{ 153, 0, 114 }, /* '224' */
{ 153, 76, 133 }, /* '225' */
{ 127, 0, 95 }, /* '226' */
{ 127, 63, 111 }, /* '227' */
{ 76, 0, 57 }, /* '228' */
{ 76, 38, 66 }, /* '229' */
{ 255, 0, 127 }, /* '230' */
{ 255, 127, 191 }, /* '231' */
{ 204, 0, 102 }, /* '232' */
{ 204, 102, 153 }, /* '233' */
{ 153, 0, 76 }, /* '234' */
{ 153, 76, 114 }, /* '235' */
{ 127, 0, 63 }, /* '236' */
{ 127, 63, 95 }, /* '237' */
{ 76, 0, 38 }, /* '238' */
{ 76, 38, 57 }, /* '239' */
{ 255, 0, 63 }, /* '240' */
{ 255, 127, 159 }, /* '241' */
{ 204, 0, 51 }, /* '242' */
{ 204, 102, 127 }, /* '243' */
{ 153, 0, 38 }, /* '244' */
{ 153, 76, 95 }, /* '245' */
{ 127, 0, 31 }, /* '246' */
{ 127, 63, 79 }, /* '247' */
{ 76, 0, 19 }, /* '248' */
{ 76, 38, 47 }, /* '249' */
{ 51, 51, 51 }, /* '250' */
{ 91, 91, 91 }, /* '251' */
{ 132, 132, 132 }, /* '252' */
{ 173, 173, 173 }, /* '253' */
{ 214, 214, 214 }, /* '254' */
{ 255, 255, 255 }, /* '255' */
{ 0, 0, 0 } /* '256' (BYLAYER) */
};
/* HUS Colors */
const EmbThread husThreads[] = {
{{ 0, 0, 0 }, "Black", "TODO:HUS_CATALOG_NUMBER"},
{{ 0, 0, 255 }, "Blue", "TODO:HUS_CATALOG_NUMBER"},
{{ 0, 255, 0 }, "Light Green", "TODO:HUS_CATALOG_NUMBER"},
{{ 255, 0, 0 }, "Red", "TODO:HUS_CATALOG_NUMBER"},
{{ 255, 0, 255 }, "Purple", "TODO:HUS_CATALOG_NUMBER"},
{{ 255, 255, 0 }, "Yellow", "TODO:HUS_CATALOG_NUMBER"},
{{ 127, 127, 127 }, "Gray", "TODO:HUS_CATALOG_NUMBER"},
{{ 51, 154, 255 }, "Light Blue", "TODO:HUS_CATALOG_NUMBER"},
{{ 51, 204, 102 }, "Green", "TODO:HUS_CATALOG_NUMBER"},
{{ 255, 127, 0 }, "Orange", "TODO:HUS_CATALOG_NUMBER"},
{{ 255, 160, 180 }, "Pink", "TODO:HUS_CATALOG_NUMBER"},
{{ 153, 75, 0 }, "Brown", "TODO:HUS_CATALOG_NUMBER"},
{{ 255, 255, 255 }, "White", "TODO:HUS_CATALOG_NUMBER"},
{{ 0, 0, 127 }, "Dark Blue", "TODO:HUS_CATALOG_NUMBER"},
{{ 0, 127, 0 }, "Dark Green", "TODO:HUS_CATALOG_NUMBER"},
{{ 127, 0, 0 }, "Dark Red", "TODO:HUS_CATALOG_NUMBER"},
{{ 255, 127, 127 }, "Light Red", "TODO:HUS_CATALOG_NUMBER"},
{{ 127, 0, 127 }, "Dark Purple", "TODO:HUS_CATALOG_NUMBER"},
{{ 255, 127, 255 }, "Light Purple", "TODO:HUS_CATALOG_NUMBER"},
{{ 200, 200, 0 }, "Dark Yellow", "TODO:HUS_CATALOG_NUMBER"},
{{ 255, 255, 153 }, "Light Yellow", "TODO:HUS_CATALOG_NUMBER"},
{{ 60, 60, 60 }, "Dark Gray", "TODO:HUS_CATALOG_NUMBER"},
{{ 192, 192, 192 }, "Light Gray", "TODO:HUS_CATALOG_NUMBER"},
{{ 232, 63, 0 }, "Dark Orange", "TODO:HUS_CATALOG_NUMBER"},
{{ 255, 165, 65 }, "Light Orange", "TODO:HUS_CATALOG_NUMBER"},
{{ 255, 102, 122 }, "Dark Pink", "TODO:HUS_CATALOG_NUMBER"},
{{ 255, 204, 204 }, "Light Pink", "TODO:HUS_CATALOG_NUMBER"},
{{ 115, 40, 0 }, "Dark Brown", "TODO:HUS_CATALOG_NUMBER"},
{{ 175, 90, 10 }, "Light Brown", "TODO:HUS_CATALOG_NUMBER"}
};
const EmbThread jefThreads[] = {
{{0, 0, 0}, "Placeholder", "000"},
{{0, 0, 0}, "Black", "002"},
{{255, 255, 255}, "White", "001"},
{{255, 255, 23}, "Yellow", "204"},
{{255, 102, 0}, "Orange", "203"},
{{47, 89, 51}, "Olive Green", "219"},
{{35, 115, 54}, "Green", "226"},
{{101, 194, 200}, "Sky", "217"},
{{171, 90, 150}, "Purple", "208"},
{{246, 105, 160}, "Pink", "201"},
{{255, 0, 0}, "Red", "225"},
{{177, 112, 78}, "Brown", "214"},
{{11, 47, 132}, "Blue", "207"},
{{228, 195, 93}, "Gold", "003"},
{{72, 26, 5}, "Dark Brown", "205"},
{{172, 156, 199}, "Pale Violet", "209"},
{{252, 242, 148}, "Pale Yellow", "210"},
{{249, 153, 183}, "Pale Pink", "211"},
{{250, 179, 129}, "Peach", "212"},
{{201, 164, 128}, "Beige", "213"},
{{151, 5, 51}, "Wine Red", "215"},
{{160, 184, 204}, "Pale Sky", "216"},
{{127, 194, 28}, "Yellow Green", "218"},
{{229, 229, 229}, "Silver Gray", "220"},
{{136, 155, 155}, "Gray", "221"},
{{152, 214, 189}, "Pale Aqua", "227"},
{{178, 225, 227}, "Baby Blue", "228"},
{{54, 139, 160}, "Powder Blue", "229"},
{{79, 131, 171}, "Bright Blue", "230"},
{{56, 106, 145}, "Slate Blue", "231"},
{{7, 22, 80}, "Navy Blue", "232"},
{{249, 153, 162}, "Salmon Pink", "233"},
{{249, 103, 107}, "Coral", "234"},
{{227, 49, 31}, "Burnt Orange", "235"},
{{226, 161, 136}, "Cinnamon", "236"},
{{181, 148, 116}, "Umber", "237"},
{{228, 207, 153}, "Blond", "238"},
{{255, 203, 0}, "Sunflower", "239"},
{{225, 173, 212}, "Orchid Pink", "240"},
{{195, 0, 126}, "Peony Purple", "241"},
{{128, 0, 75}, "Burgundy", "242"},
{{84, 5, 113}, "Royal Purple", "243"},
{{177, 5, 37}, "Cardinal Red", "244"},
{{202, 224, 192}, "Opal Green", "245"},
{{137, 152, 86}, "Moss Green", "246"},
{{92, 148, 26}, "Meadow Green", "247"},
{{0, 49, 20}, "Dark Green", "248"},
{{93, 174, 148}, "Aquamarine", "249"},
{{76, 191, 143}, "Emerald Green", "250"},
{{0, 119, 114}, "Peacock Green", "251"},
{{89, 91, 97}, "Dark Gray", "252"},
{{255, 255, 242}, "Ivory White", "253"},
{{177, 88, 24}, "Hazel", "254"},
{{203, 138, 7}, "Toast", "255"},
{{152, 108, 128}, "Salmon", "256"},
{{152, 105, 45}, "Cocoa Brown", "257"},
{{77, 52, 25}, "Sienna", "258"},
{{76, 51, 11}, "Sepia", "259"},
{{51, 32, 10}, "Dark Sepia", "260"},
{{82, 58, 151}, "Violet Blue", "261"},
{{13, 33, 126}, "Blue Ink", "262"},
{{30, 119, 172}, "Sola Blue", "263"},
{{178, 221, 83}, "Green Dust", "264"},
{{243, 54, 137}, "Crimson", "265"},
{{222, 100, 158}, "Floral Pink", "266"},
{{152, 65, 97}, "Wine", "267"},
{{76, 86, 18}, "Olive Drab", "268"},
{{76, 136, 31}, "Meadow", "269"},
{{228, 222, 121}, "Mustard", "270"},
{{203, 138, 26}, "Yellow Ocher", "271"},
{{203, 162, 28}, "Old Gold", "272"},
{{255, 152, 5}, "Honey Dew", "273"},
{{252, 178, 87}, "Tangerine", "274"},
{{0xFF, 0xE5, 0x05}, "Canary Yellow", "275"},
{{0xF0, 0x33, 0x1F}, "Vermilion", "202"},
{{0x1A, 0x84, 0x2D}, "Bright Green", "206"},
{{0x38, 0x6C, 0xAE}, "Ocean Blue", "222"},
{{0xE3, 0xC4, 0xB4}, "Beige Gray", "223"},
{{0xE3, 0xAC, 0x81}, "Bamboo", "224"}
};
/* SHV Colors */
const int shvThreadCount = 42;
const EmbThread shvThreads[] = {
{{ 0, 0, 0 }, "Black", "TODO:CATALOG_NUMBER"},
{{ 0, 0, 255 }, "Blue", "TODO:CATALOG_NUMBER"},
{{ 51, 204, 102 }, "Green", "TODO:CATALOG_NUMBER"},
{{ 255, 0, 0 }, "Red", "TODO:CATALOG_NUMBER"},
{{ 255, 0, 255 }, "Purple", "TODO:CATALOG_NUMBER"},
{{ 255, 255, 0 }, "Yellow", "TODO:CATALOG_NUMBER"},
{{ 127, 127, 127 }, "Grey", "TODO:CATALOG_NUMBER"},