From proprietary to portable: analyzing and standardizing quilting design file formats
| Publication Type | honors thesis |
| School or College | School of Computing |
| Department | Computer Science |
| Faculty Mentor | H. James de St. Germain |
| Creator | Lee, Jaden |
| Title | From proprietary to portable: analyzing and standardizing quilting design file formats |
| Date | 2025 |
| Description | Manufacturers of modern longarm quilting machines develop intricate computerized systems to control stitching speed and consistency. These machines are typically paired with proprietary software that interfaces with the hardware using undocumented file formats, which are only accessible to design software companies through non-disclosed licensing agreements. StitchMe is a quilting design platform that aims to enhance the interoperability of quilting machines without relying on costly file converters. To support widely used longarm machines, StitchMe has reverse-engineered these proprietary formats, enabling users to convert files across different systems. Traditionally, analyzing file format grammars has relied on visual inspection, developer-written regular expressions, and handcrafted scripts. However, the emergence of pattern-matching large language models offers a novel approach to parsing the grammars underlying proprietary file structures. Combining these new tools with traditional methods such as text and hex editor analysis, StitchMe examined quilting design files to uncover the specifications of several file types. The case study revealed that these proprietary formats prioritize neither security nor uniqueness; instead, they encode information in remarkably similar ways. To promote portability and accessibility, a universal open file format should be adopted across all quilting machines. |
| Type | Text |
| Publisher | University of Utah |
| Subject | proprietary file format reverse engineering; interoperability; large language models |
| Language | eng |
| Rights Management | (c) Jaden Lee |
| Format Medium | application/pdf |
| ARK | ark:/87278/s6jprjbp |
| Setname | ir_htoa |
| ID | 2917244 |
| OCR Text | Show ABSTRACT Manufacturers of modern longarm quilting machines develop intricate computerized systems to control stitching speed and consistency. These machines are typically paired with proprietary software that interfaces with the hardware using undocumented file formats, which are only accessible to design software companies through non-disclosed licensing agreements.StitchMeis a quilting design platform that aims to enhance the interoperability of quilting machines without relying on costly file converters. To support widely used longarm machines,StitchMehas reverse-engineered these proprietary formats, enabling users to convert files across different systems. Traditionally, analyzing file format grammars has relied on visual inspection, developer-written regular expressions, and handcrafted scripts. However, the emergence of pattern-matching large language models offers a novel approach to parsing the grammars underlying proprietary file structures. Combining these new tools with traditional methods such as text and hex editor analysis,StitchMeexamined quilting design files to uncover the specifications of several file types. The case study revealed that these proprietary formats prioritize neither security nor uniqueness; instead, they encode information in remarkably similar ways. To promote portability and accessibility, a universal open file format should be adopted across all quilting machines. ii TABLE OF CONTENTS ABSTRACT ii INTRODUCTION 1 BACKGROUND 3 METHODS 7 RESULTS 10 DISCUSSION 15 FUTURE WORK 20 CONCLUSION 21 REFERENCES 22 APPENDIX A: QUILTING FILE GRAMMARS 23 APPENDIX B: PROJECT DOCUMENTATION 29 iii 1 INTRODUCTION With the advent of motorized track systems,stitchregulators,andcomputerized controls, longarm quilting machines now allow artists to autonomously stitch detailed patterns faster and more consistently than ever before [1], enabling repeatable designs and complex art patterns as shown in Figure 1. To facilitate the creation of digitized designs, manufacturers typically bundle their machines with proprietary computerized design software. For example, Innova ships its M Series machines with the AutoPilot Mach 3 software [2], while APQS provides the Quilt Path system [3] similar to the machineincludedinFigure1.Althoughtheseapplicationsareoftenfeature-rich,theyare generallylimitedincompatibility—usuallyrestrictedtotheirrespectivemachinesandthe Drawing Exchange Format (DXF), an open standard for 2D and 3D CAD files. These programs neither interface with SVG-based design tools like Adobe Illustrator nor support cross-machine interoperability. StitchMe addresses this gap by entering the cross-platform design space—currently dominated by outdated, overly complex, and prohibitively expensive 2 software.Asmachineshavereducedthephysicaldemandsofquiltinganddigitaldesigns have become widely accessible online, custom quilting services can now offer professional, personalized quilts with ease [1]. StitchMe supports both creators and consumersinthisecosystembyofferinganaccessible,streamlinedwebsolutiontailored to hobbyists andsmallbusinessowners.Itssimpleuserinterfaceenablesuserstocreate designs, import existing files, and export them in their preferred quilting formats. Additionally, a community-driven marketplace allows users to share and customize designs created by others (seeAppendix Bfor project documentation). Due to the lack of a standardized file format within the quilting industry, most longarm machine manufacturers rely on proprietary file types that are not publicly documented. However, broad file format support is critical to StitchMe's mission. By analyzing files collected from quilting businesses, the StitchMe team has reverse-engineered these formats using traditional visual inspection alongside modern pattern-matching tools. This effort has enabled the decoding of file structures and instruction sets for a wide range of proprietary pattern files. 3 BACKGROUND Attheircore,filesarestructuredcollectionsofdata.Fileformatsstandardizehow this data is encoded and organized, dictating how software systems parse,process,and presenttheinformation.Identifiedbyfileextensions,theseformatsenabledataexchange across platforms—although conversions can sometimes result in data loss. Files may ay be compressed or encrypted to reduce size or store data as text or binary, and m enhance security. Open vs. Closed Formats File types based on open standards emphasize transparency and public accessibility. With publicly available specifications, open formats promote portability betweenapplications,userfreedom,andlong-termusability[4].Thesevaluesalignwith theGNUdefinitionoffreesoftware,whichemphasizestheuser’sfreedomtorun,study, modify, and redistribute programs—freedoms that, in this context,requireaccesstothe format specification [5]. Community support and cost-efficiency further position open formats as essential tools for both data preservation and data exchange [4]. However, open formats are not always paired with open software.Forinstance, while the .xlsx file type is an open standard, Microsoft Excel—its most common implementation—is proprietary. Despite the push for open standards, proprietary closed formats remain widespread in the quilting industry. With an emphasis on brand identity and tightly integrated user experiences, companies often restrict competitors from accessing or distributing content through proprietary file licensing. While proprietary formats allow 4 companiestoofferstrongtechnicalsupportandcloselymanagetheuserexperience,this centralization limitspublicdocumentationandlong-termfileaccessibility.Evenifafile format is publicly specified, internal integration with source code canmakethird-party supportchallenging.Inmanycases,thestructureofthesefilesistreatedasatradesecret, and while proprietary algorithms m ay be used to obfuscate data, some files remain unprotected. Ifamanufacturerdiscontinuesitssoftwareorauserswitchestoadifferent machine, access to the data could be lost. Reverse Engineering Files Since StitchMe intends to import and export a wide rangeofquiltingfiletypes, understandingtheencodingstructureofeachformatisessential.Thefirststepinreverse engineering is identifying the file format, preferably by analyzing the filesignature—a unique sequence of bytes at the start of the file—rather than relying on potentially misleadingfileextensions.Oncethefile'spurposeisunderstood,examiningitwithatext editorandahexeditorrevealsitscharacterandbytestructure.Familiaritywithhowdata types like timestamps, floats, and doubles appear in hexadecimal is crucial when analyzing binary formats [6]. Forunobfuscatedfiles,binaryortextdatatypicallyusesdelimitersandpaddingto separate sections, allowing basic scripting to identify and interpret patterns. These methods help expose the file’s internal logic and structure. Legal Considerations 5 Under U.S. law, fair use permits limited use of copyrighted materials without explicit permission. The Digital Millennium Copyright Act (DMCA) extends fair use principles to digital media, though it generally prohibits reverse engineering.However, Section 1201 of the DMCA provides a key exception: reverseengineeringispermitted “for the sole purpose of achieving interoperability,” provided that no d igital rights management or access controls are circumvented [7]. BecauseStitchMeusesonlypubliclyvisibledataanddoesnotbypassencryption or authentication mechanisms, its efforts fall within fair use. Should future formats employ patented algorithms or impose legal restrictions, the StitchMe team will reevaluate its features to maintain legal compliance. Expectations of Quilting Design Files Longarmquiltingmachinesstitchpatternsthatbindtogetherthreelayersoffabric. These machines require precise, repeatable instructions to controltheirmotionacrossa two-dimensional plane. Because any "jump" in stitching would require manual intervention—detaching the machine,tyingoffthethread,andrepositioningit—designs are generallycontinuous.Asaresult,vector-basedrepresentationsoflines,arcs,curves, and other shapes are ideal. Vector art supports scalability, efficient editing, and compactfilesizes.Scalable Vector Graphics (SVG), in particular, is well-suited to this context, using coordinate-baseddefinitionsandattributemetadatatorendercomplexshapes.SVGfiles are widely supported, including by modern web browsers. 6 Raster formats like JPEG or PNG, and document formats like PDF, prioritize colorandresolutionoverprecisionandscalability,makingthemunsuitableforStitchMe's purposes. While SVG features align well withquiltingdesignneeds,someadaptationsare required. For example, unlike traditional vector art, quilting designs often imply continuity, where the starting point of one path is the endpoint of the previous. To preservestitchingdirection,designfilesmustexplicitlyrecordstartandendpoints.Since thread color and thickness are controlled manually by operators, SVG attributes like strokecolor,width,andfillareunnecessary.Additionalmetadata—suchasdesignname, author, dimensions, and copyright—may also be included. 7 METHODS During the prototype stage of development, StitchMe prioritized support for importing and exporting INNOVA Pattern (PAT) files such as the one in Figure 2, as these correspond most directly with the machines used by the application's target audience. The PAT format is a proprietary standard developed by ABM Innova. To understand its structure, the StitchMe team consulted a libraryspecialistwhoidentified the encoding as a variant of the Marlin implementation of G-Code [8], a language commonly used to control CNC machines along geometric planes. Through multiple development iterations,theteamsuccessfullydecodedthe.pat instructionsetandmappedittotheSVG-basedshapemodelusedwithintheapplication. When these files were imported, the resulting designs matched the image previews provided in corresponding PDFs. This successful decoding provided a foundational understanding that informed the analysis of additional proprietary file types. 8 All quilting files used in the reverse engineering process were obtained from a quiltingprofessionalwhoprovidedZIParchivesforthedesigns.Thearchivesincludeda variety of file formats for one primarydesign—titledCirclesandSquares(Figure3)— andtwosupplementaldesigns—Wildwood(Figure4)andStargazing(Figure5)—which were u sed to verify the accuracyofthegeneratedgrammars.AreferencePDFincluded witheacharchiveillustratedtheexpecteddesignoutcomeandincludedmetadatasuchas design dimensions and title. The files were generated using Art & Stitch, a leading quiltingdesignsoftware,andarealsosupportedbyPro-StitcherDesigner,anothermajor application in the industry. Circles and Squares, Wildwood, and Stargazingareallcontinuous,edge-to-edge quilting designs, meaning they can be tessellatedseamlesslyacrossaquiltsurface.The patterns each measure approximately 10 by 10 inches and incorporates lines, arcs, and curves. To reverse engineer the structure of each file format, the team first opened the files in a plain text editor (Notepad) to visually assess any human-readable patterns or data structures. When readable, files were compared to previously analyzed formats to 9 identifysharedstructuresorconventions.Ifnodirectsimilaritieswerefound,thecontent was parsed into coordinate pointsusingAItoolssuchasChatGPTandvisualizedusing the Desmos Graphing Calculator. Incaseswherethefileswerenotreadableasplaintext,theywereopenedusinga hex editor to identify recurring byte sequences and infer underlyingstructuralpatterns. For e ach format, the time required and the effectiveness of the reverse engineering process were documented. It is worth noting that the order in which file formats were decoded may have influenced subsequent decoding efficiency, due to knowledge carryover between formats. 10 RESULTS This section details the proprietary quilting file formats successfully acquired and analyzed by theStitchMeteam. For each format, wedescribe its documentation status, compatible machines, related software, and an overview of decoding its structure. A file snippet and corresponding decoding analysis are provided where applicable, and formal grammars are included inAppendix A. The grammars cover the breadth of structures observed in the three given design files and can be adjusted as more files are encountered. Bernina Q-Matic (BQM) File The BQM formatisproprietarytoBernina’sQ-Seriesmachines,typicallypaired withArt&Stitchsoftware.InitialinspectionofthefileslikeinFigure6revealedthatits structure mirrors that of the PAT format, using Marlin-style G-Code with an identical coordinate system and instruction syntax. By applying the PAT import logic,theBQM file was parsed and rendered successfully as demonstrated by Figure 7.Implementationofthe parser took under 10 minutes and required no tools beyond a standard text editor. 11 CompuQuilter Pattern (CQP) File CQP files (F igure 8) originate from discontinued CompuQuilter longarm machines. The file begins with a design title, followed by an extensive sequence of floating-point coordinate pairs and ends with copyright text. The file distinguishes between 'PU' (pen up) and 'PD' (pen down) commands, each associated with X and Y values. The data suggests curves a re flattened into fine line segments, evidenced by varying point densities throughout the file. Plotting these absolute points in Desmos revealed arcs, allowing the reconstruction of the Circles and Squares design seen in Figure 9 by connecting some points with lines. Decoding required approximately 20 minutes and was deemed effective. HandiQuilter Format (HQF) File HQFisusedinHandi-Quiltermachinesandthe proprietary Pro-Stitcher ecosystem. Observing Figure 10 shows each line comprises four space-separated floating-pointnumbers;thelasttwoofonelinealways 12 matchthefirsttwoofthenext,representingasequenceofconnectedstartandendpoints. Comparing this to CQP files revealed nearly identical floating-point values and line countsaswellaslimitedcopyrightinformation.Decodingtook10minutesandrequired only a text editor. IntelliQuilter Pattern (IQP) File IQP files, proprietarily used in IntelliQuilter systems and shown in ostly unreadable Figure 11, contain m binary data when viewed in a text editor, asidefromthedesignnameandcopyright.A hexeditorrevealedthepresenceofpaddingbytesprecedingrecurring4-bytesequences, frequentlystartingwith3F,40,BF,orC0, indicative of IEEE 754 floating-point valuesintherange-4to4(seeFigure12). While thepreciseencodingschemecould not be fully decoded, the structure appeared consistent as a frequency histogram showed those bytesequencesoccurredat tentimestherateofothercombinations.Severalhourswerespentonthisformatwithout a complete solution. Plotter (PLT) File Used by QBOT HPGL systems, PLT files such as the oneinFigure13contain largeintegercoordinatepairsseparatedbysemicolons.Theseintegersapproximatescaled 13 versionsofthevaluesfoundinotherformats.LikeCQP, PLT files employ ‘PU’ and ‘PD’ commands to denote movement and drawing instructions. The lack of metadata, except a truncated author note, made identification difficult. The format was analyzed in 7 minutes without auxiliary tools. Quilter’s Creative Touch (QCC) File QCC files are shared across machines from Butler Robotics,ShirleyStitcher,andQuiltMagician,butlack a public specification. Exported via Quilt EZ’s Quilt Manager Digitizing Software, the QCC structure seen inFigure14closelyresemblesCQPfiles,withidentical floating-point coordinate sequencesflattenedfromcurvedataandoutputlinebyline.A brief header and copyright data precedethecoordinatelist.Analysisanddecodingtook approximately 5 minutes. Quilting (QLI) File QLIistheprimaryformatforGammillStatlerStitchersystems,generatedbythe Creative Studio software. It is more verbose per line than other formats but requires fewer lines overall. Figure15portrayshowitusesvariouscommandcodes (e.g., ‘VP’ for vertex point, ‘CR’forcurveradius)and 14 represents coordinates as integers scaled by 1000. Arcs are explicitly preserved using radius,startangle,anddeltaangleparameters(indegrees).WhenalignedwithPATfiles, a near 1:1 instruction mapping exists, though QLI retains more arcs than the PAT file. This format took 45 minutestodecode.WhileChatGPTinitiallyfailedtofullyidentify the encoding, it correctly suggested polar deltas, which were later confirmed. Side Saddle (SSD) File SSD files, from the now-defunct Side Saddle System, use clearly labeled floating-point coordinate pairsforlinesequencesasdemonstratedinFigure16. Minimal metadata is included, and the file structure parallels that of CQP and QCC formats. The design was decoded in 2 minutes. PC Quilter Text (TXT) File TXT filesfromthediscontinuedPCQuiltersystem resemble SSD files in structure. The proprietary format (shown in Figure 17) begins with quoted copyright lines, followedbyastraightforwardlistofcoordinatepairs.There is no additional metadata. This file type was fully understood within a few minutes. 15 DISCUSSION Despitethediversityofproprietaryquiltingfileformatsanalyzedinthisstudy,all servethesamefundamentalpurpose:encodingasequenceofstitchablepathsforlongarm quilting machines. Notably, none of the formats employ encryption, compression, or deliberateobfuscation.Mostfilescontaineasilyparsablecoordinatedataaccessibleviaa basictexteditor,andseveralformatssharesimilarconventionsforstoringorderedpoint sequences. This widespread functional overlap—combined with the absence of patented encodingtechniques—makesquiltingdesignfilesastrongcandidateforstandardization. Anopen,vendor-agnosticfileformatwouldsignificantlyimproveinteroperabilityacross machines and software ecosystems. More importantly, it would provide long-term assurancethatuserdataremainsaccessibleevenifproprietarysystemsbecomeobsolete. In the absence of such a standard, continued reliance on translation tools between proprietaryformatsintroducesasinglepointoffailure:ifthosetoolsaredeprecatedorno longer maintained, entire classes of quilting machines risk becoming unusable. Another key consideration in the creation of an open format isthepotentialfor data loss during vector-to-stitch conversion. Current quiltingfilesoftenflattencomplex vector paths—such as Bézier curves or arcs—into dense sequences of linearsegments, discarding the originalcontrolpoints.Oncesimplified,thisgeometricfidelitycannotbe recovered when re-importing the file into a design environment. Users must either approximate the intended shapes by fitting new curves to the clustered line segments (introducing uncertainty), or accept the overly literal line data,whichcanbetediousto modify. 16 While hardware limitations may currently prevent some machines from supporting complex path instructions, advances in motor controlandprecisiontracking suggestafuturewherenativesupportforarcsandsplinesisubiquitous.Supportingthese higher-levelgeometricprimitiveswouldpavethewayforlosslessdataworkflows—from design to stitching and back—thus improvingbotharchivalqualityandeaseofcreative iteration. Standard Quilting Format Proposal Nearly all longarm quilting machines todaysupportstitchingpatternsdefinedin the Drawing eXchange Format (DXF), an open standard for representing 2D and 3D CADdrawingsusingvectorsandembeddedmetadata.DXFfilesarehighlyinteroperable withmajorCADtoolssuchasAutoCADandcanbegeneratedfromdesignformatslike SVG using most modern vector editors. However, despite its availability, DXFhasnot been widelyadoptedastheprimarymethodofsharingquiltingdesigns.Thereasonsfor this are not explicitlydocumented,butpotentialfactorsincludeconversionimprecision, unnecessarycomplexity,oralackofmomentumwithinthequiltingcommunitytoadopt it as a de facto standard. In contrast, a purpose-built, open file formattailoredtoquiltingmachinescould offer greater benefits thanDXF,includingmorecompactfilestructures,richersemantic meaning,andimprovedcompatibilityacrossquiltinghardware.Whilemovingawayfrom entrenched proprietary formats would require ashiftinmanufacturerpriorities,quilting designs are relatively simple data structures, making this transition feasible within a typical product lifecycle or two. 17 Most computerized longarm machines were originally developed in the 1990s, whenfilesizeandmemoryusagewereparamount.Today,storageconstraintsarefarless significant, and file formats have generally trended toward more self-describing and human-readable structures, such as JSONorXML.Theseformatslendthemselveswell to representing sequences of quilting paths, offering clear hierarchies, metadata containers, integer data types, and built-in support for extensions. Figure 18 demonstrates a baseline proposal for aJSON-basedopenquiltingfile format that supports fields for thedesignname,copyrightdata,metadatastorage,anda self-describing list of instructions. It is further described in Appendix A. Due to the StitchMe team’s lack of expertise in quilting machine hardware requirements, this proposal may notcaptureeveryedgecase,butitprovidesastrongfoundationonwhich manufacturers and developers could collaboratively build. 18 However,industry-wideadoptionwouldstillfacehurdlesduetothelongevityof existing machinesandthehighcostofhardwarereplacement.Toaccommodatesystems with limited capabilities, a simplified companion specification could be introduced—limitedtolinearinstructions—whilestillconformingtotheoverallstructure oftheJSONschema.Insuchcases,variableslikestitchlengthshouldbeconsideredpart of the machine’s execution logic rather than encoded in the file format itself. Byadoptingamodern,open,andextensiblequiltingformat,thecommunitycould ensurelong-termdataportability,improvecreativeworkflows,andencourageinnovation across both hardware and software ecosystems. Limitations This case study investigates the reverse-engineering of quilting design files available to the StitchMe team. It is important to note that the findings may not fully representthecompleteinstructionsetssupportedbyeachfileformat.Duetotheabsence of official specifications, all conclusions are based exclusively on observed behaviors within the analyzed files. Nevertheless, every example uploaded to the website was successfully parsed into an intermediate SVGrepresentation,enablingformat-to-format transformation. The analyzeddesignswereallcontinuousedge-to-edgepatterns—acommonuse casethatavoidsmorecomplexmachineinstructionssuchasjumps,trims,ormulti-block registration. Consequently, StitchMe’s decoding logic may currently be limited to this subset of use cases.Additionally,sinceallfilesweregeneratedbyproprietarysoftware, they may contain implementation-specific constraints—such as curve subdivision 19 thresholds or non-standard instructionsequences—thatarenotnecessarilygeneralizable across different machines or design tools. As StitchMe acquires a broader and more diversedataset,thedevelopmentteamexpectstoenhancetheaccuracyoftheparsersand refine the associated grammars. 20 FUTURE WORK Furtherrefinementoftheproposedstandardformatremainsnecessary,largelydue to the current lack of domain-specific expertise withintheStitchMedevelopmentteam. With modest coordination and input from specialists associated with longarm quilting machinemanufacturers,itisanticipatedthataworkingdraftofthespecificationcouldbe completed within a matter of weeks. Such collaboration w ould likely lead to a more comprehensive and nuanced standard, including additional fields required for machine initialization and configuration. While JSON has become a prevalent format for data serialization in modern software applications, it has not yet been widely adopted within the ecosystem of computer-aided design tools. Before pursuing a broader transition to a JSON-based format, collaboration with machine manufacturers would be essential to assess the viability of such an approach and to ensure compatibility with existing hardware and software workflows. In particular, for quilting formats that depend on legacy software developed prior to the widespread adoption of serialization practices, a standard more closely aligned with traditionalplottingorvector-basedfilestructuresmayofferamore practical and immediately compatible solution. 21 CONCLUSION Upon examining the various proprietary quilting file formats, it became abundantly clear that none of them actively obscure the structure of their data. Developers can recreate the software needed to parse and generate these files with relative ease, although there may be some margin for error in their implementation. This lack of modernization can likely be attributed to outdated hardware and a lack of collaboration between manufacturers. Consequently, users bear the burden of each system's inflexibility, often facing incompatibilities and loss of data integrity. A standardized, open file format—such as the proposed JSON-based format—could resolve many of these challenges, addressing issues with compatibility, data loss, and long-term data persistence while still adhering to the operational needs of longarm quilting machines. With further input and refinement from industry professionals, such an open standard could supplant the DXF format, providing a more efficient and scalable solution. This would not only promote interoperability across machines but also encourage greater collaboration among quilters, benefiting the entire quilting industry by enabling future-proofed designs and workflows. 22 REFERENCES [1] icked Stitch Quilting and Embroidery Services. “A Brief History of Long-arm W Quilting.” Wicked Stitch Quilting. Accessed: April 21, 2025. [Online]. Available: https://www.wickedstitchquilting.com/long-arm-quilting [2] I NNOVA Longarm Quilting Machines. “AutoPilot Computerized Quilting System M3.” INNOVA Longarm Quilting Machines. Accessed: April 21, 2025. [Online]. Available:https://innovalongarm.com/products/software/autopilot [3] PQS. “Quilt Path.” APQS. Accessed: April 22, 2025. [Online]. Available: A https://www.apqs.com/machines/quilt-path/ [4] . Madden. “Open Source File Formats – Benefits and Limitations.” Hex K Browser. Accessed: April 9, 2025. [Online]. Available: https://www.hexbrowser.com/open-source-file-formats/ [5] ree Software Foundation. “What is Free Software?” GNU Operating System. F Accessed: April 9, 2025. [Online]. Available: https://www.gnu.org/philosophy/free-sw.en.html [6] nton. “How to Reverse Engineer a Proprietary File Format: A Brief Guide with A Practical Examples.” Apriorit. Accessed: April 8, 2025. [Online]. Available: https://www.apriorit.com/dev-blog/780-reverse-reverse-engineer-a-proprietary-fil e-format [7] opyright Office, Library of Congress. “Exemption to Prohibition on C Circumvention of Copyright Protection Systems for Access Control Technologies.” Federal Register. Accessed: April 24, 2025. [Online]. Available: https://www.federalregister.gov/d/2021-23311 [8] arlin. “G-code Index.” Marlin. Accessed: Nov. 25, 2024. [Online]. Available: M https://marlinfw.org/meta/gcode/ 23 APPENDIX A: QUILTING FILE GRAMMARS All the quilting file types that were obtained have been listed below with their corresponding grammar. In order to trim the size of each grammar, assume the following rules exist to represent numbers, text, and syntax: Digit = "0" | "1" | ... | "9" ; Sign = “-” |ε UInt = Digit, {Digit} ; Int = Sign, Uint ; UFloat = Int, ".", Int ; Float = Sign, UFloat ; Character = ? any Unicode character ? ; Text = { character } ; Space = “ ” ; Newline = “\n” ; Bernina Q-Matic (BQM) File File = Instructions, Copyright ; Instructions = Start, {Trace}, End ; LineNum = Int ; Start = “N”, LineNum, “G00”, “X”, Float, “Y”, Float, Newline ; Trace = “N”, LineNum, Path, Newline ; Path = Line | ClockwiseArc | CounterClockwiseArc ; Line = “G01”, “X”, Float, “Y”, Float ; 24 ClockwiseArc = “G02”, “X”, Float, “Y”, Float, “I”, Float, “J”, Float ; CounterClockwiseArc = “G03”, “X”, Float, “Y”, Float, “I”, Float, “J”, Float ; End = “N”, LineNum, “M02”, Newline ; Copyright = {CopyrightLine} ; CopyrightLine = “(“, Text, “)”, Newline CompuQuilter Pattern (CQP) File File = Name, Instructions, Copyright ; Name = Text, Newline ; Instructions = Start, {Trace}, End ; Start = “PU”, Newline, “X”, Float, Space, “Y”, Float” ; Trace = “PD”, Newline, {Line} ; Line = “X”, Float, Space, “Y”, Float, Newline ; End = “END”, Newline, “REPEAT=NO”, Newline, “INDEX=0.000”, Newline, “TAG=N/A”, Newline ; Copyright = PNote, Newline, ENote ; PNote = “PNOTE”, Newline, {CopyrightLine} ; PNote = “ENOTE”, Newline, {CopyrightLine} ; CopyrightLine = Space, Space, Text, Newline ; HandiQuilter Format (HQF) File File = Instructions, Copyright ; Instructions = {Line}; Line = Float, Space, Float, Space, Float, Space, Float, Space, Newline ; 25 Copyright = {CopyrightLine} ; CopyrightLine = “*”, Space, Text, Newline ; IntelliQuilter Pattern (IQP) File A complete grammar for IQP files was not found. INNOVA Pattern (PAT) File The PAT file type is an exact match of the BQM file type. See the grammar listed for that above. Plotter (PLT) File File = Initialization, Instructions ; Initialization = “IN;”, Newline, “IP;”, Newline, “SP1”, Newline, Copyright ; Copyright = “WD”, Space, Space, Space, Text, Newline ; Instructions = Start, {Line}, End ; Start = “PU”, Int, “,”, Int, “;”, Newline ; Line = “PD”, Int, “,”, Int, “;”, Newline ; End = “EN;”, Newline ; Quilter’s Creative Touch (QCC) File File = Copyright, Newline, Instructions ; Copyright = “n”, Space,{CopyrightLine} ; CopyrightLine = Space, Space, Text, Newline ; 26 Instructions = Header, {Line} ; Header = “c s” ; Line = “p”, Space, “X”, Float, Space, “Y”, Float, Newline ; Quilting (QLI) File File = Initialization, Instructions ; Initialization = “#CAD2DMC”, Newline, “CS”, Newline, “VMXY”, Newline, Copyright, “REM CONTINUOUS ----------------”, Newline, “NO NEEDLE ON”, “REM end macro -----------------”, Newline ; Copyright = “REM FIRST_MACRO ---------------”, Newline, {CopyrightLine}, “REM end macro -----------------”, Newline ; CopyrightLine = “NO INFO”, Space, Space, Text, Newline ; Instructions = {Path}, End ; Path = Line | Arc ; Line = “VP”, Space, Int, “,”, Int, Newline ; Arc = “CR”, Space, Int, “,”, Float, “,”, Float, Newline ; End = “VE”, Newline, “BGS”, Newline, “AMS”, Newline, “EN”, Newline ; Side Saddle (SSD) File File = Name, Copyright, Newline, Instructions ; Name = “:NAME”, Newline, Text, Newline ; Copyright = “:COMMENT”, Newline, {CopyrightLine} ; CopyrightLine = Space, Space, Text, Newline ; 27 Instructions = “:POINTSEQUENCE”, Newline, {Point}, “:END”, Newline; Point= Float, Space, Space, Float, Newline ; PC Quilter Text (TXT) File File = Copyright, Instructions ; Copyright = {CopyrightLine} ; CopyrightLine = “"”, Space, Space, Text, Newline ; Instructions = {Point} ; Point= Float, Space, Float, Newline ; *Proposed* Standard Quilting Format (SQF) File The new file type should adhere to the JSON standard with the following fields: Field Description title Name of the quilting design data n empty bucket for any metadata developers wish to A include with the design creator_copyright Copyright statement on behalf of the design’s creator software_copyright opyright statement on behalf of the application used to C create the design instructions n array of serialized path instructions describing how to A stitch the design. Longarm machines shouldsupportthefollowinginstructiontypesidentifiedbythetype field of a serialized instruction: 28 Instruction Fields Start ● Point: coordinates to start the design at Line ● Point: coordinates to draw a line to from the previous point Clockwise-Arc ● Point: coordinates to draw a clockwise arc to from the previous point ● Center: the center point from which to draw the arc Counter-Clockwise-Arc ● Point: coordinates to draw a counter-clockwise arc to from the previous point ● Center: the center point from which to draw the arc Bezier-Curve ● Point: coordinates to draw a bezier curve to from the previous point ● Control Points: an array of control points defining the curve End n/a 29 APPENDIX B: PROJECT DOCUMENTATION (the design document begins on the next page) Design Specification University of Utah - Kahlert School of Computing CS 4000 - Senior Capstone Design December 9, 2024 Winston Ji, Ari Lacanienta, Jaden Lee, Austin Li StitchMe | Design Document | 1 Table of Contents 1. Executive Summary 2. Background 2.1 Similar Software 2.2 Required Technology 2.3 Customer Software Requirements 3. Requirements Analysis 3.1 System Architecture 3.2 Personnel 3.3 System Features 4. Software Engineering Tools and Techniques 4.1 Project Management 4.2 Tools 4.3 Code Quality 5. Timeline 5.1 Prototype 5.2 Pre-Alpha (Winter Break) 5.3 Alpha Stage 5.4 Beta Stage 5.5 Final Stage Appendix A: Use Cases Appendix B: User Interface Sketches Appendix C: Ethics Statement Appendix D: Revisions 2 2 3 4 4 5 5 6 8 10 10 10 12 13 13 13 14 14 15 15 22 28 28 StitchMe | Design Document | 2 1. Executive Summary Our software system is designed to provide an accessible, streamlined solution for quilters who create and export patterns for longarm quilting machines. In the modern quilting industry, quilters typically use vector-based designs that longarm machines interpret to stitch fabric layers together autonomously. However, current software solutions like Art and Stitch and Pro-Sticher Designer are expensive and complex, making them inaccessible for many users, particularly hobbyists and small businesses. The primary goal of our system is to offer a more affordable and user-friendly alternative that retains essential functionalities. The target users are quilting enthusiasts, small quilting businesses, and designers who need to create and export patterns without the burden of steep costs or difficult interfaces. The software will enable users to convert vector designs into file formats compatible with longarm quilting machines, ensuring seamless workflow integration with vector graphics editors such as Adobe Illustrator or Affinity Designer. For users who do not want to invest in those general-purpose vector design tools, our application will include quilting-focused vector design capabilities, tailored specifically to the needs of quilters. A novel feature of our software is the ability to import standard image files and automatically generate quilting patterns based on those images. This functionality allows users to transform any image, such as photographs or custom artwork, into a continuous line quilting pattern. This feature is especially valuable for small businesses and hobbyists looking to offer personalized quilting services, such as quilts featuring images of loved ones or custom designs. For those without the time to create their own designs but still in search of a personalized pattern, we will develop an online marketplace to share and download quilting designs. This will remove the financial barrier to customized designs and help our creators find the inspiration they need to produce what they really want. Ultimately, by combining affordability, ease of use, and unique functionality, our system will make quilting pattern creation accessible to a wider audience. Altogether, we will enable this niche community more autonomy over their workflows and finally allow users the freedom to bring their creative visions to life. 2. Background Because current quilting design software is expensive and overly complex, many quilting business owners and hobbyists use other vector graphics software to develop their own designs. However, those existing quilting softwares remain a bottleneck as the only services that StitchMe | Design Document | 3 exist to convert quilting files between various formats. StitchMe seeks to rectify this by providing the ability to create, import, and export quilting designs in formats for longarm machines in a simple, quilting-focused environment, enabling our creators to have more affordable options in their workflow. 2.1 Similar Software The two dominant players in the marketplace are “Art and Stitch” and “ProStitcher Designer”. While these two pieces of software are feature-rich and very powerful, at $1200 and $600 respectively, they are extremely cost prohibitive to use for hobbyists and some small business owners. Additionally, most users utilize these pieces of software for converting custom quilt designs from their vector files to file types such as: .PAT, .CQP, .BQM, .DXF, .HQF, .PLT, and .QLI. For our light users, our program will convert the file types and optimize them to minimize overstitching, a common problem in computerized quilt stitching. Longarm quilting machines create stitches in a single continuous line, which results in the occasional need to “backtrack” and take a second pass over segments of the design. Such backtracking can ruin the design or misalign the quilt material itself. Existing software applications require the user to manually draw the backtrace over the intended design instead of automatically detecting when a backtrace is necessary. StitchMe will add the functionality of backtracing and algorithmically ensure minimal overstitching. For creative users who would like to design their own patterns, our software will provide a more intuitive user interface that will put the most useful design tools directly at the user’s fingertips and make powerful features easier to use. We will conduct user testing with existing programs to identify pain points in the current user workflow, and create paper prototypes of our StitchMe | Design Document | 4 own solution to make sure our software addresses these pain points. Our software will be tailored specifically for quilting designers, so the non-quilting design features of programs like Adobe Illustrator or Affinity Design can be omitted. Confusing and hard to use features in programs like Art and Stitch and ProStitcher Designer such as splines or bezier curves will be simplified and made more accessible to beginner users. Additionally, our solution will have a unique flagship feature that the competition does not have: image to line design conversion. StitchMe will produce a line design from a user-uploaded image, which they can then touch up using basic editing tools. This feature will empower quilters to create designs based on images from the real world. Since art is an intrinsically human experience, we will not only permit but encourage the user to add their artistic interpretation in tandem with the computer generated baseline to produce a clean and beautiful design. 2.2 Required Technology Our project will utilize a variety of existing technologies, including image processing libraries and possibly WebGL to convert images into line art. Many of these algorithms are already well-known and documented, and several of our team members have taken Introduction to Computer Graphics. However, we plan to represent the design as a set of points in a graph data structure which will need to be built from the ground up. To go along with this, we will need to research and learn many graph algorithms to analyze and manipulate the design. Additionally, we will need to research various file types so that users can import and export designs. Since these are not common file formats, API’s do not exist for them so they will need to be reverse engineered. For the development and hosting of the application itself, we will be leveraging AWS and Amazon RDS for web hosting and database management. Some team members are experienced with SQL, but we will also have to learn AWS and Amazon RDS specifically in order to implement our marketplace. We will use Typescript to develop the backend of our application and use Remix/React for our front end. Our team is already familiar with JavaScript and TypeScript, and some members have used React before. We additionally would like to provide an Electron container for users who are more comfortable working from a desktop application. 2.3 Customer Software Requirements Our application will address the accessibility issue by being hosted on the Web. This will allow users to access the application without the need to download anything locally if they prefer not to. For users who prefer a more native desktop experience, the program will also run StitchMe | Design Document | 5 within an Electron container which the user can download locally and use offline. However, certain online features such as design sharing in the native marketplace will require an internet connection. The user will have the ability to decide whether or not they will utilize these features. Our software does not require any additional hardware such as a longarm quilting machine to produce designs and convert file types. Our software is focused on producing the designs that will be used by one of these machines later in the production process. In order to utilize the design files output by our software, the user will either need to connect their longarm quilting machine to the internet and access their files over a network or use a USB drive to save and move the design to their quilting machine. 3. Requirements Analysis 3.1 System Architecture StitchMe | Design Document | 6 StitchMe will be a web application with a desktop container for users to run as a desktop application if they choose. The user will interact with the application either through their browser or through the downloaded executable contained within an Electron container. The application will utilize the Remix framework of React to build our user interface and will connect the backend through function calls. Many of the backend services will be available offline within the Electron container if the user chooses to download the application, but for users who choose to use StitchMe as a web application, the backend will be hosted on a server. Both systems will run on Node.js and will be designed using TypeScript. The backend will handle file conversions, image processing, our core graph traversal algorithms, as well as any stateful data required to run the application. The marketplace will be implemented using a MySQL database that users can interact with through the application. Raw quilt designs will be stored using a separate file hosting system. In order for creators to monetize their published designs, we plan to add an authentication and payment system using existing JavaScript libraries. 3.2 Personnel Database & File Hosting ● Ari has taken the Database Systems class which gave him experience designing and administering databases. He has also worked at an internship for 3 years where he frequently interacted with his work’s RDMS. These reasons make him a good candidate to lead the database component. ● Jaden enjoys data management and organization and accordingly plans to take the Database Systems course in the Spring. Deployment & Web Hosting ● Jaden has some familiarity using Docker from working with a deployed website at his past internship. He is currently working on a project in another class that requires deploying to the Web and should be well-versed to guide our capstone team once we reach that step. ● Ari has experimented with Docker in the past, and is excited to learn more about the world of web hosted development. Electron StitchMe | Design Document | 7 ● Winston has worked on personal projects which have used Electron so he has a record of employing this technology successfully and will be well suited to making sure StitchMe will use this technology effectively as well. For this reason, Winston will be responsible for ensuring the successful deployment of the desktop application using Electron. ● Jaden will assist in making sure the application will deploy using Electron. UI Design & Frontend ● Winston has an eye for UI/UX design and has historically been in charge of the user interface in past projects. Winston has also taken an HCI class which has equipped him with the tools needed to make sure the user interface is ideal for the greatest number of users. Given his past experience in this area, Winston will be responsible for the clean implementation of our user interface. ● Austin is interested in gaining experience in working with user interfaces so he will be assisting Winston with producing a beautiful UI. Image Processing ● Austin has some experience with image processing through personal projects. Given that this is one of the toughest features, a lot of time will be dedicated to researching and developing this portion of the project. ● Jaden worked on a handwritten character recognition project years ago that familiarized him with basic image processing algorithms. That should be of aid to our capstone team. File Conversions ● Jaden has done some preliminary research into quilting-specific file types. Meanwhile, our team has secured a range of files that we can reverse engineer to determine the format of how each outlines a stitching path. We feel comfortable that we can dissect each file type and make a library to convert files between types. ● Winston will be helping with file conversions. He has already identified that one of our file types utilizes Marlin, one of the most common variants of GCode. Graph Algorithms & Indicators ● Winston has worked on graph traversal algorithms in the past. ● Ari has a lot of backend development experience at his internship and in class. ● Austin has familiarity with graph traversal algorithms through class and internship experience. StitchMe | Design Document | 8 Editing Tools ● Ari, Jaden, and Austin are taking the graphics class which will equip them with useful skills in implementing these editing tools. They will have an understanding on how to implement vector based designs. ● Winston has experience with Photoshop and Affinity Design which gives him understanding into how these tools are meant to work and how to design them to be user friendly. 3.3 System Features Rank 1: Infrastructure and Core Functionality ● Create Blank Designs ○ Open a blank quilting design canvas with no lines. ● Draw and Erase Lines & Curves ○ Interactively draw directional lines and curves on current working quilting design. ● Discontinuity Detection ○ Live detect and highlight discontinuities in the current working design. ● Tessellation Enforcement ○ Require current working design to meet criteria for tessellation before allowing the user to export the design. Namely, the points at the edges of the design must be able to meet up with each other when the pattern is tessellated. ● Toolpath Calculations & Overstitching Analysis ○ Find the shortest path through the design with the fewest backtracks. Highlight for the user which sections get backtracked over the most. (see: “Chinese Postman Problem”) ● Import Files ○ Convert .svg line drawing files to our own .stch format that can be modified with our design editor. ● Export a File ○ Convert our .stch quilting designs into a format compatible with longarm quilting machines such as .pat or .cqp. Rank 2: Planned Features ● Marketplace StitchMe | Design Document | 9 ○ Provide a marketplace where users can upload their designs to share with other users. This will allow users that are not as adept at designing to be able to use premade designs from the community. Users will also be able to download and modify designs acquired through the marketplace. ● Adding Shapes/Shape Manipulation ○ This will be a way for users to easily add basic shapes to their designs so that they do not have to freehand draw some commonly used shapes such as rectangles, circles, and triangles. ● Layers ○ Layering allows users to isolate portions of their design so they can edit a subset of their overall design without needing to worry about their edits affecting other sections. This will also allow users to use reference images. ● Reference Images ○ Insert images into the editor interface that can be conveniently referenced to guide the user. The image will affect the underlying stitch design. Rank 3: Advanced Individual Features ● Authentication ○ Require creators to login before uploading their designs. We can tie payment information to their accounts. Similarly, people downloading should login to preserve their purchased quilting designs across sessions. ● Payment System ○ Creators can upload their designs with an associated cost and receive compensation when users download their designs. ● Simulated Tessellation Mirroring ○ Designers can visualize how their design will behave when tessellated in real-time as they produce their design. ● Alternative Tessellations ○ While most quilts use squares as the units of tessellation for edge-to-edge designs, some designers may want to use more unique shapes such as hexagons or triangles. This will allow the editor to support easier designing for these shapes. ● Simulated Design Pathing ○ Helps quilters to visualize how their machine will traverse the design so they can make changes to limit inefficiencies. ● Image To Continuous Line Drawing ○ Allows a user to take a standard image photo and StitchMe will convert it into a baseline continuous line drawing that can be edited to suit the users needs. This will require the use of edge detection algorithms. StitchMe | Design Document | 10 ● Masking ○ Allows the user to use the layering functionality to mask off a portion of their design so that there is a window of an arbitrary shape with no stitching. This will recalculate the tool pathing for that section of the design. ● Marketplace Search ○ Search and filter designs uploaded to the Marketplace. 4. Software Engineering Tools and Techniques 4.1 Project Management Team Meetings We plan to use an Agile development project methodology with weekly sprints. We’ll hold a standup meeting every Friday at 10:00am after our in-person meeting with Professor Jim de St. Germain at 9:30am. At this, we’ll reflect on our progress and workflow from the previous week and make adjustments as needed. For each team member, we’ll also assign several tasks of a couple hours each and make GitLab issues to track them. We may schedule intermediate meetings for upcoming assignments in flexible meeting times that generally fall Monday or Tuesday evening around 5pm, Wednesdays during class time, or Thursdays around noon. Team Communication Our primary mode of communication regarding the state of the project and tasks that need to be done will be GitLab issue boards. To call attention to a specific issue, tag a team member in an issue comment. For organizational communication, we will utilize Discord, taking care to put our communications within the proper channels in our StitchMe Discord server. It is expected that communications for planning meetings should occur at least 12 hours before the expected meeting time for urgent matters and with 24 hour prior notice given for regular meetings. If those channels don’t work or there is an emergency, team members can call each other by phone using numbers listed on Discord. 4.2 Tools Issue Tracking GitLab Epics will be used to track large software features that need to be implemented. Individual issues that contribute to the completion of those features will be grouped under the respective Epic. This will help with big-picture organization for our application. StitchMe | Design Document | 11 GitLab Issue Boards will be our primary mode of tracking our backlog, to-do’s, in-progress, and completed tasks. We will also use GitLab to track which code reviews need to be done and which features need to be tested. Bugs Tracking We will use GitLab’s bug tag on our issue boards to identify and track bugs. If a bug is discovered, move an old issue back to the “To Do” column with the bug tag and add a detailed description of what happened as well as how to recreate the bug. Assign the task to a specific developer for resolution. Implementation Workflow 1. Branch Creation: A new branch shall be created from the development branch for each feature or issue. 2. Code Review: A code review must be completed before merging feature branches back into development. 3. Rebasing: Whenever the development branch is updated, we will rebase our feature branches on the most up to date version of the development branch. It is the responsibility of the branch owner to ensure a proper rebase is completed before issuing a pull request to maintain a clean history. 4. Testing: After code is pushed back to the development branch, another team member will be responsible to test it thoroughly. 5. Merging: Submit a pull request to merge into main once testing is complete. Pull requests into main must be approved by the person responsible for testing which will be assigned in a rotation. 6. Branch Cleanup: It is the responsibility of branch owners to close branches when they are no longer needed. Version Control - GitLab Main Branches: ● development – the development branch will be used for active development. Feature branches will be based on the development branch. ● testing – the testing branch will be used for testing features before release. It will be branched from development for the testing purposes and once it is ready it will be merged into main. ● main – The main branch is for production-ready code that has already been tested. Versions of the development branch that have been tested will be merged into main periodically. StitchMe | Design Document | 12 Feature Branches: ● Feature branches shall be named with the related issue number for clarity (e.g., 123-feature-name). A new feature branch must be created for implementing or making additions to features. Once the feature is completed, it must undergo a code review before being merged back into the development branch. IDE’s Our team primarily uses Visual Studio Code and JetBrains WebStorm for their robust support of the programming languages we work with and their range of development utilities. These IDEs offer essential tools such as development containers, debugging capabilities, and syntax highlighting, enhancing productivity and code quality. Libraries ● Prettier and Black: These libraries enforce opinionated code formatting guidelines. ● ESLint: This plugin analyzes code for adherence to good coding standards practices. Testing We will write unit and user interface tests with Jest before and after implementing features in the development branch. Also, use IDE debug tools to remove bugs. After passing code reviews, all changes will be passed to another team member to perform manual integration testing in the testing branch. Once a change passes all tests, it will be merged into the main branch. Throughout commits, GitLab should perform continuous integration testing. Deployment We intend to use GitLab pipelines to continuously integrate and deploy the latest production-ready code to a cloud platform hosted on AWS. This offers scalable and reliable infrastructure that can be customized with Docker containerization. With Docker, we can package applications and dependencies, ensuring consistency across environments. 4.3 Code Quality Documentation Update the GitLab Wiki and the Design Document whenever important changes are made to the project. Also, add header comments to all methods, classes, and files. These should StitchMe | Design Document | 13 be written prior to implementing the functionality and should include the author(s), parameters, and a description of what the program does. Code Style We are using TypeScript to erase a certain class of type inconsistency bugs. To further this, we’ll be using ESLint to analyze our code for bad programmatic and stylistic errors. We intend to install the Prettier plugin to format all of our TS code and will use Black if we need any formatting for Python scripts. Code Reviews Most programming will be done independently, but pair programming is encouraged to expedite debugging and ensure at least two team members can explain any given code. When an issue is ready for merge and moves to the “Code Review” column in GitLab, at least one team member not involved in implementation will be assigned as the reviewer. The programmer and reviewer should meet on their own time (remotely or in-person) and check that functionality, documentation, and code style meets team quality standards before approving the merge on GitLab and moving the issue to the “Testing” column. 5. Timeline 5.1 Prototype The primary goals for the Prototype stage were to setup all the development environment for our project, build an editing canvas, and export a valid .PAT file. 5.2 Pre-Alpha (Winter Break) Our team intends to maintain a reduced workflow over Winter Break to complete features we wanted to have done by the end of the Prototype stage. This will include finalizing the canvas editing features, producing a valid stitching path, and importing a .PAT file to our canvas. Ari Wk 1 Electron Configuration Austin Jaden Winston Graph Generation and Traversal, Discontinuity Check Import/Export PAT, Coordinate Conversions Graph Generation and Traversal, Discontinuity Check StitchMe | Design Document | 14 Wk 2 Select/Rotate/Edit/ Delete/Split Image Processing Research Testing of Editing Features Basic Drawable Editing Features. Wk 3 Testing/Debugging Image Conversion to SVG Editor Display Basic Drawable Features (zooming, Editing Features ruler, origin, and Testing gridlines) 5.3 Alpha Stage By the Alpha stage, we hope to have all of our deployment and infrastructure created. We will round out the editor features and begin implementing the marketplace. Ari Austin Jaden Winston Wk 1 Deploy to AWS Image Conversion to SVG Marketplace Frontend Layers Wk 2 Marketplace Backend Layers and Reference Image Marketplace Backend Layers and Reference Image Wk 3 Identity Management UI Design Miscellaneous Editing Features UI Elements Design Wk 4 Testing/Integration Testing/Debugging Testing/Debugging Testing/Debugging 5.4 Beta Stage During the Beta stage, we will begin implementing our advanced individual features that include backtracking visualization, tessellation enforcement, and marketplace features. Ari Austin Jaden Winston Wk 1 Tessellation Mirroring User Authentication, Payment System Import/Export Other File Types Alternative Tessellation Shapes Wk 2 Tessellation Mirroring Simulate Pathing Simulate Pathing Backtracking Visualization Wk 3 Marketplace Search/Filter UI Refinement Upload to and Download from Marketplace UI Refinement StitchMe | Design Document | 15 Wk 4 Testing/Debugging 5.5 Final Stage Testing/Debugging Testing/Debugging Testing/Debugging For the Final stage, we intend to finish up our nice-to-have marketplace and editor features, and then rigorously test and refine our system to make it into an impressive, complete product by Capstone Demo Day. The primary goals will be adding masking, marketplace searching and filtering, and building an aesthetic user interface. Ari Austin Jaden Winston Wk 1 Marketplace Search/Filter Masking Marketplace UI Development Masking Wk 2 File Conversions Graph Traversal Options File Conversions Playback Simulation Wk 3 Testing/Debugging Testing/Debugging Testing/Debugging Testing/Debugging Wk 4 UI Refinement UI Refinement UI Refinement UI Refinement Appendix A: Use Cases Use Case #1: Create, Edit, and Export Designs Use Case #2: Modify the Size and Shape of Blocks Use Case #3: Stretch and Rotate Designs Use Case #4: Adding Basic Shapes to the Design Use Case #5: Preview Tessellation Behavior for Edge-to-Edge Designs Use Case #6: Convert .SVG to .PAT Use Case #7: Simulate Stitching Path Use Case #8: Identify Overstitching Sections Use Case #9: Upload an Image → Get Lineart → Tweak Pattern → Export Use Case #10: Tracing over Reference Images Use Case #11: Uploading to the Marketplace Use Case #12: Using Designs from the Marketplace 14 14 15 15 16 16 17 18 18 19 19 20 StitchMe | Design Document | 16 Use Case #1: Create, Edit, and Export Designs Preparer Jaden Lee Actor Designer User Story As a designer, I want to be able to create an empty design, edit it with drawing tools, and export it as a longarm quilting machine-compatible file. Course of Events 1. The user creates a blank design from the home page. 2. The page navigates to the design editor page. 3. A user creates their design using tools listed on the toolbar and references the Help Menu for any guidance on how to use the application. 4. The user navigates to File > Save. 5. The user selects the preferred file format to save the quilting design. 6. The designer selects a directory on their home computer to save the file. 7. A user clicks an Exit button to return to the Home Page and finish work on the current design. Exceptions ● The user closes their web browser before saving the design file to their computer. UI Sketch Appendix B – Figure 3: Design Editor Use Case #2: Modify the Size and Shape of Blocks Preparer Jaden Lee Actor Designer User Story As a designer, I want to customize the size and shape of stitching pattern blocks so I can produce non-square tessellation patterns. Course of Events 1. A user has the design editor open with no pattern yet. 2. The bounding block is drawn around the design. 3. User selects Edit > Block Size and Shape. 4. The user enters new dimensions and selects a new shape (square, diamond, triangle, hexagon) or creates their own. 5. The design scales to fit the new size but does not alter the shape or orientation of the pattern if one exists. 6. The bounding box on the editor is updated to display the new block shape. StitchMe | Design Document | 17 Exceptions UI Sketch ● The custom block shape cannot be tessellated properly across an entire quilt. ● Chosen dimensions are outside a range of realistic quilt sizes. Appendix B – Figure 3: Design Editor Use Case #3: Stretch and Rotate Designs Preparer Jaden Lee Actor Designer User Story As a designer, I want to stretch, rotate, and delete the lines and shapes of my design to adjust the size and appearance of a pattern. Course of Events 1. A portion of the pattern should already be completed. 2. The user selects one or more shapes and a bounding box is displayed. 3. The user drags a corner vertex to stretch the selected shapes. 4. The user drags the rotate handle at the top of the containment box and twists the design. 5. Connected lines update to travel to the altered points. 6. If the user presses the delete button on their keyboard, the shape disappears, and the rest of the design is unaffected. Exceptions ● The transformation causes part of the shapes to extend beyond the block’s boundary. UI Sketch Appendix B – Figure 3: Design Editor Use Case #4: Adding Basic Shapes to the Design Preparer Winston Ji Actor Designer User Story As a designer, I want to be able to add basic shapes to my design with the ability to change its size, location, and rotation within the design Course of Events 1. A design has already been opened by the user. 2. The user selects the shapes tool. 3. The default shape is a square, but the user would like to add a triangle so the user selects the side drop down with shape options 4. The user selects the triangle option 5. The user clicks and drags diagonally on the canvas to draw a triangle. StitchMe | Design Document | 18 6. The triangle is drawn onto the canvas on the existing design with a box around it showing the height and width bounds and handles for adjusting the size. Intersections with the design are indicated with a small blue dot. 7. The user then clicks and drags the shape from the center to its desired location. Exceptions UI Sketch ● A user drags their shape outside the boundaries. ● A user changes the shape after they’ve entered some points. Appendix B – Figure 3: Design Editor Use Case #5: Preview Tessellation Behavior for Edge-to-Edge Designs Preparer Winston Ji Actor Designer User Story As a designer, I want to be able to see the tessellation behavior of my edge to edge designs as I’m editing Course of Events 1. 2. 3. 4. 5. 6. A design has already been started by the user. The user draws on the edge of the design. The same lines that are being drawn are drawn at the same time on the opposite side of the design just beyond the boundary. As the user draws a design past the boundary, they miss the starting line. The ends are highlighted in red to indicate the mis-alignment. The user erases a portion of the line and redraws it so that contact is made. The dot turns green. During steps 3 and 4, edits reflected on the opposite side of the design live in partial opacity. The user zooms out and the canvas shows the design tessellated across numerous squares. Exceptions ● Attempts export before tessellation behavior has been satisfied. A warning dialog appears to show that the design is not tessellable. UI Sketch Appendix B – Figure 3: Design Editor, Figure 6: Quilting Design Validity Analysis Use Case #6: Convert .SVG to .PAT Preparer Winston Ji Actor Quilter StitchMe | Design Document | 19 User Story Course of Events As a quilter, I have a .SVG file that I need to convert to a .PAT file so that my machine can actually use the design. 1. 2. 3. 4. 5. 6. 7. 8. Exceptions UI Sketch The user clicks on File > Import which opens up a file selector where they can select their .SVG file The line drawing shows up on the canvas which the user has specified to be 10” x 10”, but the design is only 5” x 5”. The user clicks on the design and drags it into the corner and grabs the corner resize tab and drags to the opposite corner. The design snaps into the borders of the canvas indicating that it now fits on the canvas. The user notices that the path has not been defined yet, so they click the path tool and click on one end of the path. An ‘A’ appears indicating the start point has been set, and a ‘B’ appears on the opposite end showing the end point has been set. The user clicks on File > Export which opens up the export window where the user can specify the file type. The user selects the drop down and clicks on .PAT The user clicks export and a file explorer appears for the user to select where the file should be exported to. ● If the user forgets to set start point and end point, then an error dialog pops up indicating that they need to set the start and end points before the file can be exported. ● The user tries to export a file without a defined path. A warning dialog appears to notify the user that a path has not been defined. Appendix B – Figure 3: Design Editor Use Case #7: Simulate Stitching Path Preparer Austin Li Actor Designer User Story As a designer, I want to be able to simulate the pathway my machine will take to stitch the design onto the quilt. This way, I can modify any directions I don’t like. Course of Events 1. User clicks View -> Simulate Quilting Path 2. A panel appears to the right of the design with options like “Start, Pause, Close” and sliders for “Speed” and “Progress”. 3. The user can adjust the slider to pick a desirable speed. 4. The user presses “Start” and the quilting pattern begins being traced by a different color from the starting point, and running through the current StitchMe | Design Document | 20 planned pathway for stitching. 5. At any point, the user can change the speed, fast forward or rewind, or pause/close the process altogether. 6. The user decides that they have seen the portion of quilting they need to see, so they press “Close” and the panel and trace disappears. Exceptions UI Sketch ● If the current stitching pattern is not continuous, then an error dialog will pop up instead denoting this issue and highlighting the region(s) where this is present. Appendix B – Figure 3: Design Editor, Figure 6: Quilting Design Validity Analysis Use Case #8: Identify Overstitching Sections Preparer Austin Li Actor Designer User Story As a designer, I want to be able to identify any sections that will have overstitching/backtracking. Course of Events 1. User clicks View → Overstitching (or maybe a hotkey). 2. Any sections that have backtracking become highlighted with designated colors (green for no overstitching, yellow for 1 overstitch, red for anything higher) 3. User clicks View → Overstitching (or un-presses the hotkey). 4. Overstitch highlights are no longer visible. Exceptions None. UI Sketch Appendix B – Figure 3: Design Editor, Figure 6: Quilting Design Validity Analysis Use Case #9: Upload an Image → Get Lineart → Tweak Pattern → Export Preparer Austin Li Actor Quilter User Story As a quilter, I want to use the flagship feature of converting an image to quiltable patterns. Course of 1. User clicks Insert → Selects a file(jpeg, png). StitchMe | Design Document | 21 Events 2. StitchMe will accept the image, perform edge detection, and then produce a continuous line that covers important features of the image. 3. This will then be displayed as a normal line art on the canvas, with the original image in the background. 4. Users now have the options to delete sections, rearrange lines in the design, and add sections. StitchMe will either automatically ensure continuity of the pattern, or will highlight problematic sections. 5. Once finished, the user clicks File → Export → Choose File Type. 6. StitchMe then generates a file with the correct extension containing the design. Exceptions ● If the pattern is invalid, StitchMe will create a dialog and ask the user if they are sure they want to save it. UI Sketch Appendix B – Figure 3: Design Editor, Figure 4: Image to Line Art Use Case #10: Tracing over Reference Images Preparer Ari Lacanienta Actor Designer User Story As a designer, I want to be able to trace over a reference image Course of Events 1. User clicks Insert → Selects a file 2. A dialog opens, prompting the user to select an image from their file system 3. The user selects the desired image to use as a reference 4. The image appears in the editor window 5. The user may optionally reposition or modify the reference image in the editor window 6. The user then selects the option to ‘use as reference image’, which locks it in the background so they can’t accidentally modify it while drawing. 7. The user then draws their desired design using various tools from the toolbar. Exceptions ● If there is an error accessing the file, no reference image is displayed and the editor window remains unchanged and an error popup is displayed. UI Sketch Appendix B – Figure 3: Design Editor Use Case #11: Uploading to the Marketplace Preparer Ari Lacanienta StitchMe | Design Document | 22 Actor Designer User Story As a designer, I want to be able to upload my designs so that other community members can use them. Course of Events 1. User navigates to the StitchMe Marketplace page. 2. User clicks ‘Upload’ 3. The user is taken to a new webpage, where they can enter in details such as the title of the design. 4. The user clicks ‘select file’ and selects the desired compatible file from their filesystem. 5. The user clicks ‘upload design’, and the design is added to the marketplace. Exceptions ● If there is an error uploading the design, an error dialog is displayed. UI Sketch Appendix B – Figure 7: Upload to Marketplace Use Case #12: Using Designs from the Marketplace Preparer Ari Lacanienta Actor Designer User Story As a designer, I want to be able to download other user’s designs from the marketplace. Course of Events 1. User navigates to the StitchMe Marketplace page. 2. The user searches the marketplace using the provided filters 3. The user clicks on one of the available design previews. 4. The user is taken to a design preview page, where they can view a larger preview and more metadata about the design. 5. The user then clicks the download button.. Exceptions ● The design requires payment, but none is supplied. UI Sketch Appendix B – Figure 6: Marketplace, Figure 8: Marketplace Preview Appendix B: User Interface Sketches Figure 1: Navigation Diagram Figure 2: Home Figure 3: Design Editor 23 24 24 StitchMe | Design Document | 23 Figure 4: Image to Line Art Figure 5: Quilting Design Validity Analysis Figure 6: Marketplace Figure 7: Upload to Marketplace Figure 8: Marketplace Preview Figure 1: Navigation Diagram 25 26 27 27 28 StitchMe | Design Document | 24 Figure 2: Home Figure 3: Design Editor StitchMe | Design Document | 25 Figure 4: Image to Line Art StitchMe | Design Document | 26 Figure 5: Quilting Design Validity Analysis StitchMe | Design Document | 27 Figure 6: Marketplace Figure 7: Upload to Marketplace StitchMe | Design Document | 28 Figure 8: Marketplace Preview Appendix C: Ethics Statement Our application does not have any direct concerns with user data. However, we intend to comply with Copyright Law and Fair Use policies. All specifications related to reverse engineering file formats will be kept in house. Our software will be an open source software that the community can audit to keep developers ethically accountable. We intend to permit users to report any designs that are uploaded to the marketplace. This will allow us to monitor our site for explicit content as well as to remove any uploads that infringe upon the ability of our creators to fairly monetize their work and protect their intellectual property. Appendix D: Revisions Here is an outline of changes we’ve made since our initial submissions. Executive Summary StitchMe | Design Document | 29 ● No changes made. Background ● Added introduction paragraph to specify idea space. ● Updated software requirements. Specified that we are using TypeScript and Remix. ● Explicitly stated that we would be using AWS and SQL to implement our marketplace and its respective database. ● Updated customer requirements to explicitly say that the user will need to use either the internet or a storage device to to transfer the design to their quilting machine. Requirements Analysis ● No changes made. Software Tools and Techniques ● Removed libraries that belong in the “Required Technology” heading of Section 2. Timeline ● Added to document. Use Cases ● Updated the associated sketches to reflect changes to our User Interface Sketches. User Interface Sketches ● Added UI sketches for getting line art from an uploaded image and analyzing the validity of a quilting design. ● Updated UI sketches of marketplace design preview to contain price listing. Ethics Statement ● Added to document. Revisions ● Added to document. 30 Name of Candidate: Jaden Lee Date of Submission: April 29, 2025 |
| Reference URL | https://collections.lib.utah.edu/ark:/87278/s6jprjbp |