Interactive Flexible Style Transfer for Vector Graphics

Vector graphics are an industry-standard way to represent and share visual designs. Designers frequently source and incorporate styles from existing designs into their own work. Unfortunately, popular design tools aren't well suited for this task. We present VST, Vector Style Transfer, a novel design tool for flexibly transferring visual styles between vector graphics. The core of VST lies in leveraging automation while respecting designers' tastes and the subjectivity inherent to style transfer. In VST, designers tune a cross-design element correspondence and customize which style attributes to change. We report results from a user study in which designers used VST to control style transfer between several designs, including designs participants created with external tools beforehand. VST shows that enabling design correspondence tuning and customization is one way to support interactive, flexible style transfer. We also find that someone using VST can significantly reduce the time and work for style transfer compared to experienced designers using industry-standard tools.


INTRODUCTION
Vector graphics are an industry-standard way to represent and share a broad range of designs.As a design medium, vector graphics offer compelling advantages, including scalability and precision.Vector graphic designs store information about each graphical element that they contain.This information enables editing the design at a higher level of semantics when compared to pixels.Many vector graphics design tools have achieved success supporting designers working in this medium (e.g., Adobe Illustrator, Figma, Canva, Sketch).
Designers often edit vector graphics' overall appearance or style while retaining their underlying content and structure.In this work, when we write style, we refer to the defining visual properties of a design's elements (e.g., color, shape, size, and font).Many alternative and valid definitions of this broad term exist.Style editing tasks arise in multiple situations, such as applying inspirations from a mood board, updating existing graphics to a new visual identity, or exploring multiple alternative style variations.For example, both a novice designer seeking to apply styles from a more polished design to their work and an experienced designer creating several variations of a similar design to present to a client for feedback face this task.This complex task requires many selection and editing operations for different groups of objects.Updating a design to conform to a new visual style can be exceptionally tedious and limits the exploration of different styles, even for experienced designers.
One potential solution is to use document-level themes or rules that consistently apply visual attributes to classes of objects.This approach is standard across many design and presentation software tools.For example, web pages use CSS (Cascading Style Sheets) to enable document-level styling, but these style-content links must be manually created and maintained.A notable downside of using document themes or stylesheets is their rigidity.Compelling themes require element class information and pre-planning, introducing viscosity [15] into the authoring process.Despite CSS support in SVG [62] via the <use> tag [42], most vector graphics avoid it.
Another promising direction is to automatically transfer visual styles between graphics using information on how two given designs relate to each other.However, this approach often fails to transfer styles as each designer uniquely intends.This failure stems from two sources: 1) the accuracy limitations of the algorithm and 2) the inherent subjectivity around good style and varying tastes that designers may have.A fully automated approach may transfer styles in undesired or unpredictable ways.The lack of adequate designer controls is a clear barrier to levering automation [49].
A tool should enable rapid iterating on different possible style transfer results to address the shortcomings of a fully automatic style transfer approach.Our research aims to combine the benefits of automation with effective controls for customizing and exploring design variations., Our approach combines automatically generated design correspondences with interactive control of how and where to transfer styles.We leverage prior work [54] on generating an automatic correspondence between vector graphics.This method yields a between-design element correspondence (Fig. 2) and element-wise similarity along multiple dimensions.
We present a new design tool, VST, short for Vector Style Transfer.VST provides designers with an interface to visualize and customize how style flows across designs (Fig. 3).VST displays a dynamic list of element styles, allowing designers to easily copy, reset, and customize element style attributes (see Appendix C for all attributes).With VST, designers can map and remap example Source element styles onto contextually similar elements.VST also features fast and flexible ways to identify, select, and style Target elements.The Output canvas re-renders the stylized Target graphics in real-time with any changes, providing immediate visual feedback.
Conceptually, VST expands the eyedropper or element-wise style copy-paste interactions to groups of elements.VST can infer many element relations directly, omitting the need for explicit element structure or class information.Our combined automation-powered interactive style transfer approach means that designers can get the best of both worlds -their style definitions can both be based on ad-hoc demonstrations and quick to apply flexibly across designs.
To evaluate VST's style transfer capability, we recruited six designers to transfer styles between nine designs.Each designer participating in the study successfully used VST to interactively transfer styles to their satisfaction and make nine new Output designs.In a follow-up design replication study, we recruited four expert designers to each manually replicate six of these Output designs in their preferred design tool.The results from this preliminary study suggest that someone using VST may reduce the time and work for this style transfer task compared to experienced designers using industry-standard tools.Our contributions include the following: (1) VST, a design tool that introduces a novel user interface for interactive, user-guided, flexible style transfer for vector graphics.Its key interaction principles are: a) enabling users to edit computed correspondences at multiple levels, and b) enabling users to customize how attributes are transferred between designs across the correspondence.(2) Two user studies that demonstrate: a) that designers can successfully transfer styles between graphics with VST, and b) that designers without VST can spend more time and effort to produce equivalent design results.

RELATED WORK
The most relevant prior work follows several themes: supporting creative processes with automation, inferring design structures, automatic transfer techniques, and other advanced vector graphics design tools.We review each of these in turn.

Supporting Creative Processes with AI
While automation is powerful, gracefully integrating it into existing creative practices demands care.Regarding working with AI as a design material, scholars have elaborated on the need for retaining control [45,49,50,55,59,68].For GUI design, Dayama et al. present a method for interactive layout transfer, where the layout of a source design is transferred automatically using a selected template layout while complying with relevant guidelines [6].In photography, researchers have provided mechanisms for guiding photographers to optimize image aesthetics [35] and to find ideal portrait lighting conditions [11].Goal-oriented transformations can also be applied to existing designs (e.g., improving accessibility) [69] or to produce alternative designs for different viewports [21].Our rationale for using element relationships between designs as a primary mechanism for transfer is that this mirrors how designers tend to work already when manually transferring styles.Highly related to our line of work are feedforward and example-driven corrections.Feedforward work refers to showing the user the output or result of their action before it happens-a preview of applying different interface actions [10,29,61].For example, OctoPocus provides dynamic guidance to bolster users' ability to learn stroke-based gestures [2].Example-driven corrections and interaction models like those in FlashMeta [46] or programming-by-demonstration disambiguation models [41] provide alternative techniques that address similar problems.Feedforward and inherent feedback can promote UI element functionality understanding to users, though computing this information fast enough for live, interactive contexts can be challenging.With that said, cluing in authors on their actions' impact is valuable.For example, the Lightspeed rendering pipeline enabled interactive prototyping of professional 3D graphics, enabling more design variation exploration [47].One approach might leverage lower-fidelity previews of variations when interacting with automation, such as design galleries.We avoid using design galleries as our early prototypes showed the varying complexity and breadth were visually overwhelming.For an analogy in text editing: VST spell-checks the entire document, while feedforward suggests autocompletion options given what is already written.
Example-based corrections generate a program that satisfies all demonstrated changes, iteratively growing more complex.Examplebased style retargeting for websites provides a successful analog to vector graphic style transfer in HTML/CSS [3,34].Example galleries can effectively support open-ended design authoring, where styles come from potentially multiple sources [36].While the documentobject-model hierarchy is essential to styling web pages, such grouping structures and labels are entirely optional and often absent in vector graphics.Groups may be constructed arbitrarily (e.g., for editing convenience) rather than having any consistent semantic meaning.Designers can encode hierarchical information through groups but frequently opt to style elements directly [50].Bringing interactive style transfer to vector graphics is a unique problem.

Inferring Design Structures
Researchers have used several approaches to infer underlying or implicit structures in visual designs.Traditionally, this work primarily operates on some structured representation (like HTML or SVG).For user interfaces, large libraries have helped to characterize and infer document structure [7,33].Linking styles via direct manipulation and element cloning provide a clear view and control of an element's style properties [20].There is also work to recognize higher-level design patterns through designs by inducting grammars [57].For the domain of D3 visualizations, Hoque et al. map data types onto shapes/axes to help search for relevant designs [22].Harper et al. showcase tools for deconstructing and restyling a D3 visualization by extracting the data and modifying visual attributes of marks [16].More recent work also focuses on inferring design structure from images directly.Computer vision techniques are improving on reverse engineering user interface models directly from screenshots [12,53,64].Similar work using vision-based methods has helped leverage attention towards answering questions and understanding mobile UIs [38,52,56].Reddy et al. use differentiable compositing to identify pattern instances within a design [48].Scene graphs have also characterized structural relationships within and between 3D environments [14].For vector graphics, Shin et al. demonstrate a technique using graph kernels to find relationships between elements of designs [54].We leverage this preexisting automatic technique to compute a correspondence between design elements (like those shown in Fig. 2).The contribution of this work centers on our novel design tool that goes beyond pure algorithmic automation by enabling flexible interactions between the capabilities of such an algorithm and the designer's high-level styling goals.

Automatic Transfer Techniques
While automatic style transfer techniques can generate impressive image transformations, they are generally functional as theme selections.Due to the broad range of shape primitives, graphic designs do not immediately lend themselves to this document-level style transfer approach.The selective extraction and transfer of specific styles are too precise to be encoded in a one-dimensional slider [24,28].The variations of vector designs also make mapping onto an otherwise standard template difficult (e.g., facial key points) [58].
Additionally, text can be used to edit image content and style directly [4].While layout is not our tool's focus, prior work highlights optimization techniques that can be used to automatically format text documents [23].ImagineNet restyles mobile apps with neural style transfer and updating assets in place [13].To be stylized with image-based techniques, vector graphics must first be rasterized, losing future object-level awareness and scaling abilities.The state of the art in automatic vector generation includes leveraging pixelbased diffusion models [27] by leveraging a differentiable vector graphics representation [39].DeepSVG uses GANs to generate and interpolate between SVG icons and shares a large-scale SVG dataset [5].Kotovenko et al. model a painting using discrete strokes to recreate style transfer better [32].Within font, some work shows the possibility of even inferring and transferring style between font glyphs [8,40].These techniques often give users little to no control of how the style is transferred.Our work focuses on optimizing the potential value that these automatic approaches can provide by introducing meaningful high-leverage interactions to customize and control generated output while retaining the core vector graphics representation that designers are familiar with working with.

Vector Graphics Design Tools
Several techniques for authoring or adjusting vector graphics exist and inform this work.Object-Oriented Drawing introduces a new way to create and style elements directly on the canvas [65].DataInk supports cloning and binding user-generated symbols to data, facilitating lightweight restyling [66].Sketch-n-Sketch links drawing code and vector graphics, letting users directly edit the SVG in a canvas, modifying the code which generates it [18].For mathematical diagramming, Penrose uses layout energy-minimization techniques coupled with a language for specifying explicit styles and content of what to render [67].Falx uses user demonstrations and program synthesis to create new visualizations [63].Existing tools can even convert web designs into a vector layout [9].Para supports binding procedural art generation constraints with graphics, including cases where there are many-to-many constraints [26].A follow-up project, Dynamic Brushes, combined procedural programming into brush behavior and design, enabling more custom expression [25].Other design tools have looked at supporting design layout [30,44], fashion [60] and design coloring [17,70].

VECTOR STYLE TRANSFER
When transferring styles between vector graphics, designers may identify an inspirational style they want to copy from a Source design.Next, in a Target design, they may identify design elements they would like to stylize.Then, they will update the stylistic attributes of those relevant Target elements using the Source style To relate design elements, we first construct a graph from each given design, where the vertices are primitive design elements (e.g., shapes, text, images) and edges are semantic relationships (e.g., same fill, containment, same font).Once the Source and Target graphs are constructed, we then compute a correspondence between the two designs' elements using the technique previously detailed in [54].This automatically generated correspondence is VST's basis for (a)how to find similar elements within a design (e.g., for easier selection/styling) and (b) identifying which elements are similar to each other across designs (e.g., determining which initial styles to transfer).Each Target element is linked to a single Source element.Only a subset of links between these designs' elements are shown.as a reference.Alternatively, they may first focus on the Target design they wish to change and pull stylistic influences in from a range of Sources, exploring possible variations.Generally, this styling is an iterative and flexible process that involves reasoning about (a) which elements correspond to each other across designs and (b) which style attributes to transfer.There is subjectivity regarding the most desired application of style, and higher-level considerations like the overall cohesion of the Target design after styles have transferred further complicate this task.The resulting Output design has the style of one design and the content/structure of another -though this distinction is still inherently subjective.Still, this task (using examples to update existing graphics with new visual styles) is expected in the graphic design process [19,31,37].

Design Goals
A high-quality element correspondence is one way to enable fast and effective style transfer for vector graphics designs.To provide designers with flexible control over style transfer is to provide them with tools to control the correspondence between designs.Moreover, to be worthwhile, the resulting designs should be of satisfying quality and faster to generate than existing tools, especially when considering the cost of learning to use a new tool.Grounded in our literature review and personal experience editing graphics, we created these design goals for Vector Style Transfer (VST): DG1 Let designers powerfully tune design correspondences.DG2 Enable flexible control over which styles are transferred.DG3 Reduce the work and time needed for transferring styles.
Our vision for how the functionality of VST best fits into existing processes is as a plugin or new tool in existing vector graphics design software.Designers could select an object group and copy their style.Then, they could select any other group within their design document and apply that style -without manually selecting each element subset.Additionally, they could filter which styling attributes they would like to copy.This work could either be used as a starting point to render a design in several alternative styles or to make a set of designs adhere to a single style.

Exemplar Scenario
We will demonstrate VST's functionality with an exemplar scenario involving vector style transfer.Consider Xavier, a designer hired by a local Italian restaurant, Leonard's.After a recent renovation, the restaurant is set to have a grand re-opening.Xavier has created a new flyer to help them advertise, which the business manager approves.To unify the brand's style, the business manager also asks him to create new versions of several existing graphics, including menus and a special delivery advertisement.These designs should look like they all refer to the same restaurant.
This style unification process Xavier faces involves many repeated manual edits and cross-references.Instead of manually ensuring exact visual consistency, he opens VST and loads in both graphics (Source: the new flyer, Target: the previous advertisement).VST computes a correspondence between elements of these two designs and automatically copies styles between matches.This correspondence technique ensures a one-to-many mapping from the Source elements to the Target elements.This ensures that every Target element will be matched, while some Source elements may not be initially matched.Xavier then sees the Output canvas update with newly stylized graphics (Fig. 3).For each Target element, styles are copied from the most similar Source element as determined by the design correspondence algorithm [54].In addition to seeing the updated target graphics, a list of changed style attributes is displayed on the right-hand side of the interface (Fig. 3D).The breadth of style attributes and the range of possible valid matches between elements makes using a fully automatic approach difficult.The inherent subjectivity of style also means this first attempt will not always be correct, especially for more complex and open-ended designs.Xavier immediately detects outlier text elements that are visually misaligned with the Source style directly on the Output canvas (Fig. 3).Designers are trained to use gestalt principles of perception to organize a design.Incorrect style transfer will lead to visual violations of these principles, which are often easy to detect [43].This means that some elements likely have been 'mismatched' by the correspondence algorithm (Fig. 4).Using the Source canvas (Fig. 3A), Xavier can then specify which Source element the incorrectly styled text fields should visually match.When he presses the Transfer Source Style to Target button (Fig. 10), VST renders styles from the Source element onto the Target selection in the rightmost Output canvas (Fig. 3C).Behind the scenes, VST applies these fixes to a copy of the original correspondence, avoiding recomputing the entire correspondence after updates.
Still, manually selecting each target element to update is tedious.To enable faster transfer, designers can double-click on any Target element to select similar elements, as determined by the design correspondence.Repeatedly double-clicking an element iteratively grows the set of selected Target elements.This feature mirrors the multi-click selection in other media, like toggling between word-sentence-paragraph selections within a text document.Here, we use the underlying within-document element-wise similarity score to intelligently add elements most similar to the currently active selection.A similarity score is computed for each element relative to the currently selected elements, and the elements with the highest score is added to the active selection.Double-clicking on a Source element conversely selects all Target elements currently matched to that element, which shows how style flows from the Source to Target design.The customization panel shows a pane of similar elements, where Xavier can preview this selection (Fig. 10).Despite Xavier updating the Source-Target correspondence, the resulting Output design still has some problems.For example, while the font and color are corrected, the copied font size makes some elements not fit neatly in the new design (Fig. 11).Once matched, VST has controls for customizing which specific style attributes are transferred.To focus on the desired element, he clicks Show Filtered Style to only see the styling applied to the text element (Fig. 11).He toggles the fontSize attribute, resetting that element's font size and updating the Output canvas.Similar attribute values are grouped in this view to make selecting and editing easier.He continues this style transfer process until he is satisfied with the quality of the new design.Internally, these changes build up a list of attribute transformations to apply to the Target design.The customization pane can highlight just the modified attributes, summarizing stylistic changes at a glance.Finally, Xavier downloads the Output graphics from VST as an SVG file to save his work.

Implementation
We used ReactJS to build the VST interface and deployed our prototype online.Vector graphics are rendered using FabricJS, a vector graphics library leveraging the HTML5 canvas backbone.SVG files, such as those exported from industry-standard design tools like Sketch, Figma, Canva, and Adobe Illustrator, can be directly imported.Once VST has imported the input Source and Target graphics, we compute a correspondence between the two designs using a comparison technique introduced by Shin et al. [54].This technique represents each design as a multigraph (rather than a typical parent-child hierarchy tree) to support matching elements across a broader range of similar attributes.Vertices are primitive design elements (e.g., shapes, text, images), and edges represent semantic relationships between elements (e.g., alignment, containment, same fill).This correspondence contains per-element similarity scores across several dimensions (e.g., color, shape, size, and text).In our implementation, correspondences between 20 or fewer elements are generally computed in real-time (< 1s).Though slower, our study's larger design pairs are still tractable to match, with the largest pair (185 total elements) taking about 100s.Our example set's average matching time per design pair (across Style Transfer Tasks 1 and 2) is 7.78s.Once obtained, match information can be exported and saved for later use.A version of VST for styling pre-matched design pair examples is available at: https://berkeleyhci.github.io/vst/.

EVALUATIONS
Style preferences are subjective, which means that making absolute statements about a style transfer tool's performance is difficult.Still, we sought to evaluate three key research questions: RQ1 How would designers use VST for style transfer?RQ2 Could VST stylize realistic, open-ended designs?RQ3 Could VST reduce the time or work of styling?

Style Transfer Evaluation
Method -To answer RQ1 and RQ2, we ran an exploratory study with six experienced designers (D1-6).Before the study began, we asked designers to create a new design from a given prompt with their preferred design tool.The prompt requested a single menu page design for a local restaurant's (Leonard's) mobile phone application.The goal was to include designer-provided source graphics to create a more realistic style transfer scenario.More methodology details are available in Appendix A, and more information about the participant's background is in Appendix B.
Task 1: Basic Graphics Pairs -After an interface demo and the opportunity to ask questions, designers used VST to transfer styles between five pairs of example designs that the authors prepared.The design pairs we chose for designers to transfer from are shown in Fig. 5 (T1.1-5).We chose these graphics to capture a breadth of different graphic design domains (e.g., art, infographics, UI mockups).We instructed designers to apply styles from the Source to the Target graphics to make the Source and Output as stylistically similar as possible.Once satisfied, they would save the Output graphics and move on to the next pair.
Task 2: Open-Ended Transfer -To observe how VST handled styling more open-ended realistic designs (RQ2), designers transferred styles from their externally created designs onto three new related templates (T2.1-3).In these tasks, the Source was a menu page created by each designer before the study with their preferred design tool.We matched their designs to three new template pages (a loading screen, a reviews page, and a checkout cart), all for Leonard's mobile app.The generated output design correspondences (Fig. 2) were not hand-tuned at all before the study.

Style Transfer Results
Our style transfer evaluation study found that designers could use VST to control style transfer across basic designs (RQ1), even generating variety in their Output designs from the same inputs.Those designers successfully used VST to flexibly transfer styles from more realistic, open-ended designs created with external tools (RQ2).We take this as an indication that VST enabled the style transfer it was designed to support.Each designer participating in the study (D1-6) used VST to generate eight new Output designs successfully.Designers also answered Likert-scale questions regarding their experience with VST (Fig. 8).Style transfer examples from the evaluation are shown in Figures 5 and 6.
Designers, despite never using a similar interface before, used VST's features to both (a) modify design correspondences (DG1) and (b) filter and edit styles per correspondence (DG2).Software instrumentation revealed that almost all designers on almost all tasks used VST to tune computed correspondence matches.On average, designers performed 6 such corrections per task.While making these corrections, designers used the functionality to select similar elements to the ones they manually selected.On average, designers performed 7.3 similarity selections and spent about 4.8 minutes per task.As a reminder, designers were only instructed to match the styles to the best of their ability -not to do so as quickly or efficiently as possible.We showcase additional, more complex VST graphics made outside of this study in the Appendix (Fig. 12) and in our paper's accompanying project video.
VST let designers tune design correspondences (DG1).Overall, designers appreciated the style transfer control that VST provided them.The designers' Likert-scale responses indicated they could produce designs they were satisfied with (Fig. 8).Most designers could see themselves using the tool again and found VST flexible enough to perform style transfer as they intended.Their verbal remarks are corroborated by the frequency with which they used the correspondence correction feature (Average:  : 6.0, Standard Deviation:  = 3.8) and attribute editing feature ( : 24.0,  = 17.3).VST enabled flexible control of style transfer (DG2).The designers created a wide variety of designs, even when given the same input graphics (Fig. 5).For their own provided graphics, designers reproduced a consistent theme across a set of provided vector graphics templates (Fig. 6).Several designers remarked on the convenience of reusing visual styles directly.D4: Very fun! Appealing to a visual thinker who values efficiency and hates repeatedly doing the same things.Magical, "it read my mind!" kind of feeling.While most found it clear how to use the different parts of the prototype to achieve their desired style transfer, there was also feedback that the transfer results were sometimes surprising.This surprise likely stemmed from having multiple ways to style elements (e.g., tuning the correspondence vs. what styles the correspondence transfers).
Designers enjoyed applying broad changes.Designers valued the ability to apply broad style changes quickly.D3: I was impressed by how well the system generated its "best guess" when I selected the "Copy All."I also thought it was easy to learn and intuitive.It had tools that worked similarly to design software I already used (like dragging values to change the font size).D5: I liked how efficient the transferring process was in closely replicating the desired style with just a button.Even if it wasn't completely accurate, the toggle buttons under Copy All made fine-tuning specific aspects of design elements easy -I could definitely see how this interface could reduce the amount of time that a designer would need to update designs.Designers also appreciated directly selecting similar elements easily, which helped broader styling.D4: Being able to select multiple elements precisely is very nice.

Correspondence-based transfer presents novel controls.
No designer reported using a similar style transfer design tool before this study.D6: I have not used anything that performed this exact function before, but I've used a tool to try to analyze an image and find out what fonts were used.It was not as reliable as this tool.While most designers (4/6) indicated an interest in using the tool again, others were hesitant, citing VST's deviation from the types of tools they were familiar with.Some designers recognized the value of a style transfer tool: D4: I have manually copied styles and have had other humans manually copy my own.When successful, this tool manages to give you that feeling of empathy and creative connection ("Wow, the other designer understood my aesthetic and was able to replicate it!I feel they really understand my vision").When it is not successful, it is easier and less stressful to correct than a human might be.Plus, it is faster than asking another designer, fewer resources, less risk, and when it is successful, high reward!

Design Replication Evaluation
Method -To answer RQ3, we ran a follow-up study.Our goal with this study was to compare the time and work required for style transfer in VST with that of an expert using industry-standard design software.We recruited four new expert designers as replication designers (RD1-4).More information about their background is in Appendix B. They were tasked with recreating a subset of the Output graphics from the previous study (T2.1-3) in their preferred design tool (Adobe Illustrator).Given that VST is a novel design tool there are no users with equivalent VST expertise comparable  -6) from the previous style transfer evaluation tasks (Fig. 6) using two different starting points: Basic and Auto.The first approach involved using Illustrator to transform the Basic input design to the replication goal.The second approach again used Illustrator, but instead has the algorithmic output (Auto) as the starting point.We provided the RDs with source styles and target structures from the previous study in vector form and a reference image of the replication goal for both approaches.
to the RDs' Illustrator skill.To approximate the performance of an expert VST user, the authors used VST to generate the same Output designs using the same input materials provided to the RDs.This data is labeled VST in Table 1.Further methodology details are in Appendix A. We report the comparison between these three design methods in our results.
Task: Design Replication -We selected six Output design examples from Fig. 6 for this designer to replicate in Illustrator (Goal in Fig. 7).We selected designs to include both graphics from every task (T2.1-3) that we gave the original designers and to include one example per designer (D1-6).We provided the RDs with the Source and Target vector graphics files and an image of the generated Output (created initially by D1-6).The RDs were then tasked with transforming the Target graphics to resemble the provided Output.To measure what human adjustment is needed when working with the automatically stylized designs, we also asked the RDs to replicate the Output starting with the initial automatically stylized Output graphics from VST.These graphics (Auto) are created by copying all styles using the initial automatic Source and Target correspondence.We asked the RDs to transform the now-partially stylized Target graphics to resemble the Output image.Any difference between these two sets (Basic and Auto) would highlight the algorithm's impact on the task time and work.To compare the potential of VST and existing tools, the authors also replicated the same Output designs from the previous study using VST (RT1-6).The same input materials were used as in the Illustrator replication: the Source and Target vector graphics files and an Output image.

Design Replication Results
In our study, using VST to transfer styles was faster than expert replication designers (RD1-4) transferring styles within their preferred design tool (RQ3).The RDs also performed more edit and selection operations using Illustrator than the authors using VST.
We report total work as a combination of selection and edit operations.On average, the RDs spent 534 seconds replicating from scratch (Basic) and 774 seconds replicating from the output of the correspondence algorithm (Auto).In comparison, the authors required, on average, 129 seconds to match styles using VST.A plot of the duration for each task is shown in Fig. 9. Stats averaged over all tasks (RT1-6) are shown in Table 1.Each replication designer also reported the style replication task as difficult and tedious.
Transferring styles with existing tools is tedious.After replicating the designs in Fig. 7 (RT1-6), the RDs reported on their experience by answering Likert-scale (ranging from 1-7) and openended survey questions.They reported that using Illustrator for this style matching task is tedious for both starting points, with Auto slightly more tedious than Basic (Average (): 6.8 → 5.8, Standard Deviation:   = 1.3,   = 0.5).The associated scale labels were: 1-Not tedious at all and 7-Extremely tedious.They also reported starting from Auto was less fun than Basic (: 2.0 → 3.8), with 1-Not fun at all and 7-Extremely fun (  = 1.0,   = 0.8).
Editing from Auto was not faster than Basic.Combining automated style transfer with existing design software tools may even hinder designer performance.The RDs reached roughly the same Likert-scale level of satisfaction with their final designs' quality from both the Basic and Auto starting points (  = 4.3,   = 4.5), with 1-Completely dissatisfied and 7-Completely satisfied (  = 1.0,   = 1.0).However, they reported that generating the desired Output was harder with Auto than Basic (: 6.3 → 5.0), with 1-Not difficult at all and 7-Extremely difficult (  = 1.0,   = 0.8).These stats match their written feedback: RD1: Editing the auto files is harder -there's more variance in the output, and sometimes unnecessary properties were added from the automatic transfer.RD2: In the standard [Basic] file, editing elements is more straightforward, while for the modified [Auto] one, I spent some extra I was satisfied with the quality of design produced.I could see myself using the tool again.
The tool was flexible enough to let me perform style transfer in the way I intended.
The results of style transfer were predictable.
It was clear to me how to use different parts of the tool to achieve my desired result.time cleaning.RD4: I largely had a similar approach to both design files, though the original [Basic] one tended to be easier.
Replication designers wanted transfer tools like VST.After briefly interacting with VST at the end of the study, all RDs were genuinely interested in trying out an Adobe Illustrator plugin with similar functionality ( = 6.25,  = 1.0), with 1-Not at all interested and 7-Extremely interested.RD4: The prototype looks very interesting!RD1: I would definitely try it when I want to apply vector-based styles to my design.When asked about if and where they would find VST useful: RD1: I can see how this tool would be beneficial for tasks like redesigning an existing UI or early-stage exploration.When asked about other similar tools they have used: RD2: In Figma, we save the font/color as a library preset, then when we change the setting, it automatically updates the components.RD3: The style transfer prototype is more adaptive than design components because files that I need to change may not have a component system.

DISCUSSION
The success of VST demonstrates the value of two key design goals that are relevant as recommendations for other automationpowered correspondence-based transfer tools: include the ability to flexibly tune generated design correspondences (DG1) and include the ability to flexibly customize what correspondences do (DG2).
Tuning Generated Design Correspondences.Providing powerful and convenient ways to tune correspondences avoids requiring users to make each mapping manually (DG1).In VST, this functionality is represented by our Selecting Similar feature, the ability to view and select elements sharing any of the same values in the customization pane, and the Similarity Threshold feature (which lets users quickly preview selections).
Customizing Correspondence Functions.Customizing a correspondence retains the flexibility of a manual approach, ensuring that designers still have control (DG2).The domain will ultimately specify what is reasonable to transfer per correspondence.Generally, the designer should be able to control what happens when two objects are linked.In VST, we achieve this through our customization panel, where designers can copy, reset, and customize attribute values.We also provide flexible ways to filter this list (e.g., by active selection and showing modified/all attributes).
The Cost of Automation -One notable point in our results is that starting with the algorithm's output (Auto) did not make replication easier.In fact, the RDs reported that starting with the automatically generated algorithm output was more difficult and Table 1: Replication work data -usage statistics averaged over replication tasks RT1-6 (see Fig. 7).The Basic and Auto columns show aggregate data collected from the four expert replication designers (RD1-4), while the VST column shows data from the paper authors using VST to replicate designs. .This is jarring, as applying the style transfer algorithm should have the opposite effect -otherwise, why apply it at all?First, applying a semi-correct transformation reduces cohesion in the design.The lack of cohesion commonly found in Auto designs reduces the efficiency of applying gestalt principles.This makes selecting similar elements to style them together harder.Second, the vast scope of the copied attributes may introduce new work.Incorrectly changing an attribute does not create new work if it already needs to be changed.However, if part of a Source style is not desired in the Output graphics, those attributes must be manually reset to their original Target value.Current design software fails to support this type of style transfer interaction.In contrast, VST features convenient ways to quickly select and explore element styles (double-clicking an element/selection, precision selection controls, visually selecting via the same attribute value).Current correspondence algorithms do not seem to reduce the total work in style transfer otherwise.This is especially true for more complex examples where correspondence accuracy is often lower.

LIMITATIONS AND FUTURE WORK 6.1 Limitations
VST is not a general-use vector graphics editing platform.The SVG standard is complex; even industry-standard platforms like Inkscape and Adobe Illustrator may render the same graphics differently.Still, some missing features limited how useful VST was for designers in its current state.Users wanted more advanced layering/z-reordering for sub-selections in complex design areas.Additionally, the current correspondence structure usage limits elements to inheriting styles from one Source element unless manually mixed with other styles.
We also did not measure the impact of algorithm matching performance on this task.Informally, study participants D1-6 updated the correspondence an average of six times per task, though our study instrumentation did not record the number of adjusted elements per update.In Shin's prior work [54], the average match accuracy was 95 However, their evaluation [54] was performed Figure 9: Plots of the duration, edits, and selections data from the design replication (RT1-6).Along each recorded measure (duration, edits, and selections), the authors using VST outperformed all four expert designers using Adobe Illustrator in replicating the stylized designs.The Basic and Auto plots also include ticks showing the standard error for each task computed over RD1-4.VST was only used once per task to obtain a baseline, so there are no comparable ticks to show.
with the Source as an element group within a Target design, rather than a separate design.Explicitly varying the match quality and leveraging different matching techniques are opportunities for future work.Another limitation of this work is the smaller scale of the surveyed designer population (10 unique designers across both studies).For our design replication study, we worked with four expert designers.While this smaller study size allowed us to deepen the level of feedback and data we gathered, future studies could evaluate a larger expert population to get additional feedback.Future work could conduct a larger-scale study with more designers to potentially collect insights into a broader set of behaviors that designers exhibit.Also, when comparing VST to other tools, the authors have more awareness of the replication goal and task, which likely improves their relative performance.Another evaluation could train experienced designers with VST and have them replicate graphics from the original study.

Future Work
Images can naturally add vibrancy to a design, though VST's style transfer only applies to vector graphics.One future direction is sourcing vector styles directly from images.RD1: It would be great to apply bitmap styling to my vector design.This use case is more common in my workflow.This requires converting the image to vector graphics or a novel style extraction technique.Some features (e.g., colors) are simple to extract, while other features like paths, gradients, shapes, and fonts are potentially much harder to source from an image correctly.For image-to-vector graphics conversion, some research methods [51] and commercial tools [1] exist.However, these methods tend to optimize pixel-based similarity to the source image over a consistent output structure or element resolution.The internal document complexity makes determining correspondences much more challenging.Rasterizing vector graphics is a lossy process with no perfect inverse.Still, given the ubiquity of image-based inspiration, a vector styling tool that uses images as a styling source is an exciting future direction.
Better correspondence algorithms may reduce the need for a corrective interface like VST.Consider automatic speech transcription as an analogy: under a certain accuracy threshold, manually transcribing speech is easier than correcting a low-quality generated transcript.The work required to fix the algorithm's output exceeds that of simply creating that same output manually.There is room for improvement in design correspondence accuracy for vector graphics.However, even with the best algorithm, some cases will still need manual tuning.This ambiguity stems from the inherent subjectivity around good style and varying designer tastes.
Primarily, our style transfer with this prototype addresses element size, font, stroke, and fill.While designers can modify other features, this feature subset visually dominates the result.A complete list of transferrable properties is in Appendix C. Future work could serve as a larger-scale multi-design style linter or unification technique where many designs are edited simultaneously.The design layout and structure are held constant throughout our style transfer process.Applying the layout from source to target is an exciting and relevant next direction.

CONCLUSION
We presented a novel design tool called VST (Vector Style Transfer) for flexibly transferring styles across vector graphics designs.We conducted two studies to investigate (1) how designers may use correspondence-based transfer tools like VST and (2) the potential of these tools in relation to traditional industry-standard design tools (e.g., Adobe Illustrator).The first study, an open-ended style transfer evaluation, revealed that despite not previously using any similar tools, experienced designers could effectively transfer styles even across graphics independently created using other design tools.The second study, a preliminary design replication evaluation, suggests that tools like VST may reduce the time and work required to transfer styles across designs compared to traditional design tools.These expert designers also found directly editing automatically stylized graphics more difficult and tedious than the original baseline design templates.This work provides two design recommendations for future design tools to support flexible user control: enable tuning generated design correspondences and customizing how these correspondences transform designs.

A METHODOLOGY DETAILS
Style Transfer Evaluation -Four designers used Figma to generate their initial designs they brought into the study, while the other two designers used Adobe Illustrator.After designers responded to the prompt, we hosted an hour-long Zoom session with each designer.We instrumented the interface to log relevant events with timestamps (e.g., loading, saving, editing).We sought to gather rich commentary and reflection from designers as they engaged with the prototype.We invited designers to verbally share any thoughts on their experience and highlight any surprising interactions throughout the study.While we recorded usage times per example, designers were not told this nor instructed to be as efficient as possible.The designers moved on only after indicating satisfaction with the relative appearance of their stylized Output graphics.Finally, designers answered a brief survey about their experience using VST, including Likert-scale (Fig. 8) and open-ended questions.Designers sent all styled designs and an interface usage log to the authors and received a $30 Amazon gift card.
Design Replication Evaluation -We conducted this study remotely over Zoom in a 3-hour session for each designer.Unlike the style transfer evaluation, the RDs were asked to work as swiftly and efficiently as possible.Once the RDs reported they were satisfied with the similarity between their replication graphics and the reference Output image, they would save their file and move on to the following example.While the RDs participated in our study, we recorded their screen, an audio log of the call, application edit history, and mouse activity.From this data, we recorded the number of selections (including selection adjustments like shift-clicking or clicking the background to clear the selection) and attribute edits (per selection-so, for example, modifying the fill of a group counts as one edit).We also recorded the time spent on each example task, measured from when all input files were opened to the last save of the output file.Finally, the RDs were shown, briefly used VST, and filled out a survey based on their experiences.The RDs received a variable Amazon gift card.The amount was prorated based on their required completion time (rated at $30/hour).

B PARTICIPANT BACKGROUNDS
Style Transfer Evaluation (D1-6) -We recruited designers via design-oriented email lists at a large research university.Designers included undergraduates (4), Ph.D. students (1), and design professionals (1).Each participating student had completed multiple design internships, bolstering their relevant experience.Their preferred tools included Figma, Adobe Illustrator, and Canva.They had an average of 4.7 years of design experience (2-10 years).
Design Replication Evaluation (RD1-4) -We recruited from the same design community as before, now selecting only the most experienced designers.All RDs had professionally worked as designers.One was the instructor for a university course teaching students how to use Illustrator, and another held a residence in a design lab guiding student projects.These designers had, on average, 6.5 years of design experience and used Illustrator daily.None of these expert designers participated in the original study.

Figure 2 :
Figure2: An overview of automated design correspondence.To relate design elements, we first construct a graph from each given design, where the vertices are primitive design elements (e.g., shapes, text, images) and edges are semantic relationships (e.g., same fill, containment, same font).Once the Source and Target graphs are constructed, we then compute a correspondence between the two designs' elements using the technique previously detailed in[54].This automatically generated correspondence is VST's basis for (a)how to find similar elements within a design (e.g., for easier selection/styling) and (b) identifying which elements are similar to each other across designs (e.g., determining which initial styles to transfer).Each Target element is linked to a single Source element.Only a subset of links between these designs' elements are shown.

Figure 3 :
Figure 3: An overview of the VST interface, including (A) the Source graphics (where the style is sourced from), (B) the Target graphics, (C) the Output canvas (the current style transfer result), and (D) customization controls for matching element styles across canvases and filtering which style attributes to copy or modify.Designers can filter this list of attributes (shown in D) based on the current selection to do more focused editing or instead modify shared style attributes across the entire design.

Figure 4 :
Figure 4: The black lines show an initial correspondence between the elements of the Source and Target designs.The green lines show an alternative, more desired set of links.When users select their desired Source and Target elements and press Transfer Source Style, VST will update these links, redirecting the flow of visual styles across designs.

Figure 5 :
Figure 5: Task 1 (Style Transfer) -Basic Graphics Pairs.Here, designers D1-6 used VST to transfer styles from the Source to the Target graphics.Both Source and Target designs were provided to the designers.In simpler cases, the design transfer result is uniform across designers (T1.1-3).Still, despite each designer starting from the same pair of designs, variations arose in more complex design pairs (T1.4-5).

Figure 6 :
Figure 6: Task 2 (Style Transfer) -Open-Ended Transfer.Before the study, we gave designers (D1-6) a prompt for a menu design with specific elements without any style instructions.The column header shows designs that they brought into the study (Sources), and the row header shows design templates (Targets).The inner table shows new designs created by applying styles from their externally created Source design onto previously unseen Target templates.Inspecting each column shows a unified visual style inherited from the Source document, while rows show the Target structure.

Figure 7 :
Figure7: Design Replication Task -A new set of expert designers (replication designers RD1-4) replicated six reference designs (RT1-6) from the previous style transfer evaluation tasks (Fig.6) using two different starting points: Basic and Auto.The first approach involved using Illustrator to transform the Basic input design to the replication goal.The second approach again used Illustrator, but instead has the algorithmic output (Auto) as the starting point.We provided the RDs with source styles and target structures from the previous study in vector form and a reference image of the replication goal for both approaches.

Figure 11 :
Figure 11: The Customization UI also provides fine-grained control over which styles to transfer.Element style attributes can be copied, reset, or customized each set of similar values.This list can be filtered only to show styles for the current selection and only to show modified attributes.The UI also features the Copy All and Copy None buttons -Copy All blindly copies all styles for every matched element (e.g., the fully automatic output), and Copy None restores the Output graphics to the original Target state.

Figure 12 :
Figure 12: Additional graphics generated by transferring styles with VST.
Simply throwing automation into existing tools and processes may backfire.This is backed by our quantitative results: the Auto designs, on average, required more work to style than the corresponding Basic starting point (Basic: 265 operations, Auto: 383 operations)