arXiv:2605.27332v1 [cs.SE] 26 May 2026
EdgeFlow: Edge-Map Augmented VLM-Based Flowchart Processing for Industrial Requirements Engineering Zhifei Dou
Shabnam Hassani
Ou Wei
Huawei Research Canada [email protected]
Huawei Research Canada [email protected]
Huawei Research Canada [email protected]
Abstract—Flowcharts are widely used in industrial requirements, but usually remain embedded as static images. Vision Language Models (VLMs) show promise in the conversion of these flowcharts into machine-readable models for RE activities, yet, when directly applied to flowchart conversion, they often fail on topology-critical visual details. To address this, we propose EdgeFlow that augments a VLM’s original input with a deterministically extracted Canny edge map–acting as a structural prior– to improve flowchart-to-Mermaid conversion, without requiring annotated training data or domain-specific model fine-tuning. We evaluate EdgeFlow on IndusReqFlow, a dataset sourced from real-world requirements. Compared with off-the-shelf VLMs, EdgeFlow improves node-level F1 by 17.39 percentage points and edge-level F1 by 16.94 percentage points. At the path level, EdgeFlow improves path F1 by 11.06 percentage points, enabling better support for model-based testing. These results demonstrate that EdgeFlow provides a practical, trainingfree means to improve topology-preserving flowchart-to-Mermaid conversion for industrial RE. Cross-dataset evaluation results on a public synthetic benchmark show no significant improvement; this highlights the need for diverse benchmarks incorporating industrial data for the comprehensive evaluation of future VLMbased RE tools.
I. I NTRODUCTION Flowcharts are widely used to communicate and validate system behavior, business logic, and operational procedures in specification documents [1–3]. Their primary advantage is practical: they provide an accessible, review-friendly abstraction of control flow (e.g., branching, exception handling, parallelism, termination). As a result, industry standards have advocated the use of flowcharts to facilitate requirements discussions across roles and domains during requirements analysis, architecture design, and test case generation [4, 5]. Requirements Engineering (RE) community has long studied modeling notations for capturing behavior and processes, specifically to enable automated verification and validation (e.g., deriving tests from behavioral models) [6–8]. However, flowcharts frequently remain embedded as static images within documents. This creates a visual specification gap that limits the utility of these artifacts for RE automation [1, 9–11]. To date, RE research has successfully leveraged textual processing, ranging from NLP-based extraction [12, 13] to LLM-driven model generation [14–16]; however, the extraction of structural models from visual artifacts remains a
critical bottleneck. The lack of machine-interpretable representations for flowchart-embedded requirements hinders both core RE tasks—such as traceability checking and change impact analysis—and downstream automation, including model-based test generation and coverage analysis [6–8]. This creates a need for methods capable of converting visual specifications into path-enumerable structures while preserving control-flow semantics. While this visual specification gap affects various notation types, this paper focuses on flowcharts given their widespread application in industrial documentation. Recent Vision Language Models (VLMs) have shown strong multimodal reasoning capabilities across software engineering artifacts; however, their application to flowchart parsing is hindered by a critical limitation: the misperception of topological structures, specifically node connectivity and edge direction [10, 11, 17, 18]. This is particularly consequential for path-oriented analysis in system development process, such as test case generation. While existing mitigation strategies attempt to decompose processing into staged pipelines using OCR or segmentation [1], these approaches remain sensitive to upstream perception failures. A. Motivation Through our collaboration with Huawei’s production-line testing teams across different industrial domains, we observe that requirements documents frequently specify operational procedures and decision logic using flowcharts. For production-line validation, engineers routinely need to derive test cases that cover the feasible paths (e.g., normal flows, exception handling, and alternative branches) encoded in these flowcharts to understand system requirements and perform model-based testing (MBT) [6–8]. Currently, such path enumeration is performed manually—a labor-intensive and errorprone process that scales poorly for complex flowcharts and scenarios with frequent revisions. To bridge this gap, we propose EdgeFlow (VLM- based Flowchart Processing with Edge-Map Augmentation), a training-free framework that augments a VLM’s input with deterministic edge maps. EdgeFlow uses Canny edge detection [19] (Section II) to supply the VLM with high-frequency topological signals, acting as structural priors that bias inference toward geometric features [20]. Unlike staged pipelines
2) Empirical evaluation with statistical rigor. We evaluate EdgeFlow on IndusReqFlow (52 industrial flowcharts) at the
(a) Input flowchart (FlowVQA example)
node, edge, and path levels, using per-flowchart Wilcoxon signed-rank tests and Cliff’s Delta effect sizes. The results demonstrate the effectiveness of EdgeFlow. We also conducted cross-dataset evaluation on a subset of FlowVQA [10] and the results indicate the need for diverse benchmarks for future RE tool evaluation. II. BACKGROUND
(b) Canny edge map: structural skeleton
Fig. 1: Illustrative example from FlowVQA. The edge map isolates the long loop-back connector, providing a strong geometric cue for the VLM to identify the cyclic topology. 1 2 3 4 5 6 7 8 9 10
flowchart LR A([Start]) --> B[/Accept 'data' as input/] B --> C{Start a loop...} C --> D{Does 'self' have...} D -- Yes --> E[/Use 'setattr'.../] D -- No --> F[/Skip setting.../] E --> G{End of loop?} F --> G G -- Yes --> H([End]) G -- No --> C % recovered by edge map
Fig. 2: Qwen3-VL-32B generated Mermaid code for the FlowVQA example (Fig. 1 (a)). that require external object detectors [18] or segmentation models, EdgeFlow’s edge-map extraction is fully deterministic and requires no annotated training data, facilitating industrial deployment. B. Illustrative Example Fig. 1 (a) shows a flowchart from FlowVQA [10]1 representing an attribute-initialization loop. Its critical topological feature is the backward edge from the End of loop? node to the Start of loop node. Missing this edge misrepresents the cyclic requirement as a linear one. The corresponding Canny edge map shown in Fig. 1 (b) provides a structural skeleton that highlights this long loop-back connector as a distinct visual cue. Furthermore, Fig. 2 illustrates the effect: when the edge map is supplied alongside the original image, the VLM correctly recovers the backward edge (G --> C) that is otherwise missed under the baseline condition. C. Contributions The contributions of this article are as follows: 1) EdgeFlow: VLM-based flowchart processing with edge-map augmentation. We propose EdgeFlow, a trainingfree framework that augments a VLM with deterministically extracted Canny edge maps–acting as structural priors–to improve the topological fidelity of flowchart-to-Mermaid conversion without requiring any annotated diagram data. 1 Original vertical layout adjusted to conserve space.
In this study, we use the diagrams broadly to encompass the wide variety of graphical models used in requirements engineering (e.g., UML). Our proposed approach, however, specifically targets flowcharts, a fundamental subset of diagrams characterized by directed graphs that represent sequential control-flow logic. A. Vision Language Models Vision Language Models (VLMs) combine an image encoder with an LLM to support tasks that require jointly interpreting visual content and generating or reasoning in natural language. Many state-of-the-art VLMs utilize a Vision Transformer (ViT) as their visual backbone. ViT architectures represent an image as a sequence of fixed-size patches, applying Transformer self-attention to model interactions among these patches. While this supports globally contextualized visual features, fixed-size patch tokenization is often too coarse to preserve the high-frequency geometric signals critical for flowchart topology. Specifically, thin connectors and small arrowheads, which encode control-flow direction, frequently become fragmented across patch boundaries. This discretization leads to a loss of salience in the pooled visual features, making the resulting graph models prone to missing or incorrect edges. B. Canny Edge Detection and Structural Priors Edge detection is a classical computer vision operation that highlights locations of strong intensity change, producing an edge map that emphasizes boundaries and thin line structures. The Canny detector is a widely adopted method that (i) smooths the image, (ii) computes intensity gradients, (iii) applies non-maximum suppression to localize edges, and (iv) uses hysteresis thresholding to retain coherent edge contours while suppressing noise [19]. As flowcharts encode control-flow primarily through line segments (connectors) and arrowheads, Canny edge maps can isolate these topology-critical features from the surrounding visual content (colors, fills, text). In the computer vision and machine learning literature, such a deterministic, domaininformed signal that is supplied alongside a primary input to bias model inference is called a structural prior [20]. EdgeFlow adapts the same principle to flowchart processing in an RE context. Section III describes how our approach exploits this prior by supplying the Canny edge map as a second visual input alongside the original flowchart image.
III. M ETHODOLOGY
Figure 3 presents an overview of our approach, which consists of four steps: (➊) Image Preprocessing, (➋) Deterministic Structural Prior Extraction, (➌) Mermaid Code Generation, and (➍) Syntax Validation. Step 1) Image Preprocessing To handle the heterogeneous formats, varying resolutions, and compression artifacts typical of industrial documentation, we apply a standardization pipeline formally defined as Iprep = P(Iraw ). This step normalizes visual features to ensure consistent VLM behavior across the dataset: Alpha Channel Normalization: Some industrial flowchart images contain transparency information (a fourth “alpha” channel beyond the standard RGB color channels). When such images are fed to a VLM, transparent regions are rendered as black by default, creating spurious dark areas that the model may misinterpret as diagram elements. We composite all images onto a white background to eliminate this artifact. Adaptive Rescaling: We downscale images so that no dimension exceeds 4,000 pixels, using high-quality interpolation to preserve fine-grained details such as arrowheads and connector text that are critical for topological analysis, while keeping the input image within the resolution limits of VLMs which are deployed practically for Huawei’s test engineers. Step 2) Deterministic Structural Prior Extraction In this step, we extract high-frequency structural signals Iedge from the preprocessed image produced in Step ➊ using the Canny edge detection algorithm introduced in Section II-B. Since Canny detection depends solely on pixel intensity gradients, it ensures that identical visual inputs yield identical structural maps without stochastic inference noise. The process is formally defined as Iedge = Canny(Iprep , θ), where θ represents the hysteresis thresholding and aperture hyperparameters. While Iprep retains semantic content, Iedge acts as a high-contrast topological scaffold that isolates connectivity features–such as thin line segments and arrowheads–from the diagram’s background metadata. The hysteresis thresholds and Sobel aperture size are treated as tunable hyperparameters; their selection through empirical optimization is detailed in Section IV-E. Step 3) Mermaid Code Generation In this stage, we synthesize the machine-readable representation using a composite visual prompting strategy. We construct a multi-image input tuple X = ⟨Iprep , Iedge , Tprompt ⟩, supplying the VLM with both the original semantic context (Iprep ) and the explicit structural scaffold (Iedge ) extracted in Step ➋. We adopt a zero-shot prompting strategy with structured prompts composed of a system role definition and a user task instruction. The prompt templates are as follows:
System Prompt: Mermaid Code Generation Role Definition Role: You are a professional visual analysis agent specialized in flowchart analysis and Mermaid code generation. Guidelines to Follow: (i) Observe the overall structure and layout of flowcharts comprehensively; (ii) Identify main node types and their distributions accurately; (iii) Analyze text labels to understand their meaning and function; (iv) Infer complete flow logic and branching structures based on visual evidence; (v) Generate accurate, executable Mermaid flowchart code.
User Prompt: EdgeFlow (Dual-Image) Mermaid Code Generation Task: Analyze the given flowchart image pair and generate corresponding Mermaid flowchart code. Instruction: Your task involves multiple images–the preprocessed flowchart and its edge-detected version. First, observe the structural edge map to identify connectivity details such as thin lines, long edges, and arrowheads. Second, cross-reference with the preprocessed image to extract node labels and semantic content. Finally, synthesize complete Mermaid code that captures both topological structure and semantic information. Ensure the generated code follows Mermaid syntax conventions and represents the full flow logic including decision branches and loop structures. The Mermaid code must be enclosed in triple backticks with language specifier (i.e., \\\‘mermaid ... \\\‘). Input: [Preprocessed Flowchart Image] [Canny Edge Map Image]
Step 4) Syntax Validation In the final stage, we ensure the syntactic validity of the generated Mermaid code through an iterative validation-correction cycle. The initial code generated in Step ➌ first undergoes automated preprocessing to remove non-functional comments and unsupported syntax. We then validate the cleaned code using the mermaid-ast parser [21]. If parsing succeeds, the syntactically valid Mermaid code is returned as EdgeFlow pipeline’s final output. If parsing fails, the parser produces a structured error log containing diagnostic messages and line numbers, which is passed to a code-specialized LLM with instructions to correct syntax errors while preserving the original business logic, node labels, and edge relationships. This iterative loop within Step ➍ repeats until parsing succeeds or a maximum threshold of 10 iterations is reached–a limit empirically established to ensure timely correction in production environments. IV. E XPERIMENTAL S ETUP This section presents the experimental setup for evaluating our approach, including the research questions, dataset construction, evaluation metrics, baseline configuration, implementation details, and analysis procedures. A. Research Questions To evaluate the effectiveness and generalizability of EdgeFlow, we investigate the following research questions:
RQ1. Does EdgeFlow, by integrating deterministic structural visual priors (Canny edge maps), improve topological extraction correctness (nodes and edges) in industrial flowcharts compared to vanilla VLMs? • RQ2. To what extent does EdgeFlow enhance path generation for downstream model-based testing (MBT) tasks, as measured by path-level correctness? • RQ3. How does the performance gain of EdgeFlow generalize from noisy industrial datasets to publicly available clean synthetic datasets? •
➊
Iraw
Tprompt Prompt
➋
Iprep
Image Preprocessing
Raw Image
Iedge
Canny Edge Detection
Preprocessed
➌
➍
Mermaid Code Generation
Syntax Validator
Edge Map
Mermaid Code
Iterative Correction
Fig. 3: Overview of our four-step approach: (➊) Image Preprocessing standardizes the raw flowchart image Iraw into Iprep ; (➋) Canny Edge Detection extracts the binary structural edge map Iedge ; (➌) VLM-based Mermaid Code Generation synthesizes the machine-readable representation from both Iprep , Iedge , and a structured prompt Tprompt ; (➍) Syntax Validation ensures the generated code conforms to Mermaid specifications. B. Dataset We construct two flowchart datasets for comprehensive evaluation across different domains: (1) IndusReqFlow, a proprietary industrial dataset for in-domain evaluation (RQ1, RQ2), and (2) a subsample of FlowVQA [10], a publicly available synthetic dataset for cross-domain generalization assessment (RQ3). 1) IndusReqFlow: To bridge the synthetic-to-real domain shift gap, we curated IndusReqFlow, a dataset of 52 real-world industrial flowcharts sourced from Huawei’s system-level requirement documents. The dataset spans multiple domains: optical networks, data communications, and electric vehicle systems. The ground truth annotation process involved two phases. First, test engineers individually authored Mermaid code for each flowchart. Second, they validated these annotations by comparing the Mermaid-rendered output against the original image to ensure node and edge consistency. Disagreements were identified in 8 out of 52 flowcharts (15.4%), due to non-standard notations or additional labels; 3 cases were then resolved through discussion between the two primary annotators, while the remaining 5 required consultation with a third test engineer for domain expert judgment. Across the 52 flowcharts, IndusReqFlow contains an average of 11.15 nodes and 11.73 edges per flowchart. Due to confidentiality and proprietary constraints of Huawei’s internal documents, the IndusReqFlow dataset is not publicly available. 2) FlowVQA (Public Dataset): For cross-domain evaluation, we randomly sampled 40 synthetic flowcharts from FlowVQA 2 , a publicly available flowchart dataset[10]. FlowVQA provides ground-truth Mermaid code for each flowchart, eliminating the effort for human annotation. The selection was performed randomly to obtain a representative subset of FlowVQA in terms of node count and diagram layout. The sampled FlowVQA dataset averages 21.35 nodes and 23.70 edges per flowchart. Visual characteristics of IndusReqFlow vs. sampled FlowVQA reflect the challenges of industrial documentation: Higher visual noise: Compared to synthetic diagrams, 2 Samples and results:https://github.com/ZhifeiDou/EdgeFlow-RE2026
industrial flowcharts exhibit higher background noise3 (industrial: σ = 33.79 vs. synthetic: σ = 19.86, ratio = 1.70×) and greater background color instability (industrial: mean= 5.38 vs. synthetic: mean= 2.67, ratio = 2.02×), attributable to scanning artifacts, photocopying degradation, paper aging, and varying illumination conditions across acquisition sessions. Structural ambiguity: Industrial dataset also exhibits greater ambiguity in structural elements, such as overlapping connectors, crossed lines without jump markers, and nonstandard notations, which create interpretation challenges for semantic-reliant models. TABLE I: Comparison of Datasets Used in This Study. Dataset
Source Size Avg N Avg E Noise Noise Metrics
FlowVQA [10] Public IndusReqFlow Indust.
40 52
21.35 11.15
23.70 Low 11.73 High
σ = 19.86, µ = 2.67 σ = 33.79, µ = 5.38
C. Evaluation Metrics We evaluate correctness with three metric levels–node, edge, and path–by comparing the generated Mermaid code against the ground-truth, reporting precision (P ), recall (R), and F1-score at each level. 1) Matching Criteria: All three levels employ exact string matching for label comparison (case-sensitive, without normalization) under a greedy one-to-one constraint. This strict criterion reflects the practical requirements of our collaborating test engineers, as even single-character deviations in industrial flowchart labels (e.g., PortA vs. PortB) can denote distinct subsystems or test conditions. a) Node-Level: A predicted node is a T P if and only if its label is identical to a ground-truth node label. b) Edge-Level: Edges are represented as (source label, target label, edge label) tuples. A T P edge requires all three components to match exactly with a ground truth edge. c) Path-Level: Path-level evaluation corresponds to the downstream MBT workflow in which test engineers derive test cases from flowcharts [6, 7], as each extracted path 3 Background noise (σ): standard deviation of high-frequency components after Gaussian blur subtraction in flat image regions, measuring scanning sensor noise and compression artifacts. Background color instability: mean chromatic variation in light background regions using CIELAB color space, measuring uneven illumination and color inconsistency.
corresponds to a candidate test case. A T P path is a predicted path whose node-label sequence is identical to a ground-truth. 2) Aggregation and Statistical Testing: We report results at two aggregation levels, both computing P , R, and F 1 separately per metric level (node, edge, and path, respectively). a) Global Level: For each metric level, the T P , F P , and F N counts are aggregated across all flowchart–batch pairs, and micro-averaged precision, recall, and F1-score are computed from the aggregated results. b) Per-Flowchart-Level: For a given flowchart, the T P , F P , and F N counts at each metric level are aggregated across all repeated experimental runs. Precision, recall, and F1-score are computed from these per-flowchart aggregates. This yields one score per flowchart per metric level per experimental condition, producing N paired observations that serve as input to the subsequent statistical tests below (N = 52 for IndusReqFlow, N = 40 for FlowVQA). To assess statistical significance, we apply the Wilcoxon signed-rank test [22], a non-parametric paired test requiring no normality assumption. We report one-sided p-values (H1 : EdgeFlow > Baseline) and complement them with Cliff’s Delta (δ) [23] as an effect size measure, using the standard cutoffs: |δ|<0.147 negligible, <0.33 small, <0.474 medium, ≥0.474 large. We additionally report win/tie/loss counts across individual flowcharts. D. Implementation The design and reporting of our LLM-based approach follows the guidelines for empirical studies involving LLMs by Baltes et al. [24]. Specifically, we report model identifiers, parameter counts, generation parameters, complete prompt templates (Section III), and the number of experimental runs. a) Models and Platform: To reflect test engineers’ daily workflow environment, all models are accessed through Huawei’s enterprise infrastructure platform running on Ascend NPUs. From the models available on this platform, we select two VLMs for Mermaid Code Generation step (➌): Qwen3VL-32B-Instruct 4 (dense, 32B parameters) and Qwen3.535B-A3B (sparse MoE, 35B total/3B active parameters), representing dense and mixture-of-experts (MoE) architectures respectively. For syntax validation step (➍), we adopt the code-specialized LLM available on platform during experimentation Qwen3-Coder-Next (sparse MoE, 80B total/3B active parameters). All models run at full precision with fixed generation parameters: temperature=0.3, top_p=0.8, max_tokens=16000, to reduce output variability. b) Baseline: The baseline condition isolates the contribution of the Canny edge map by providing the VLM with only the preprocessed image Iprep —without the edge map— while keeping all other variables identical (i.e., same model, generation parameters, system prompt, and same syntax validation step). The baseline Mermaid code generation user prompt follows the similar structure as the EdgeFlow prompt (in Section III), differing in receiving a single image input. 4 We use Qwen3-VL-32B to represent Qwen3-VL-32B-Instruct for brevity.
User Prompt: Baseline (Single-Image) Mermaid Code Generation Task: Analyze the given flowchart image and generate corresponding Mermaid flowchart code. Instruction: Your task involves a single flowchart image. Observe the image comprehensively to identify nodes (including their labels) and connectivity details such as edges and arrowheads. Generate complete Mermaid code that captures the full flow logic including decision branches and loop structures. Ensure the generated code follows Mermaid syntax conventions. The Mermaid code must be enclosed in triple backticks with language specifier (i.e., \\\‘mermaid ... \\\‘). Input: [Preprocessed Flowchart Image]
E. Analysis Procedure Each research question follows a consistent protocol: five independent experimental runs per condition on the target dataset–where inter-run variability arises from the non-zero sampling temperature (0.3)–with results aggregated and tested for statistical significance as defined in Section IV-C 1) Analysis Procedure for RQ1: RQ1 is addressed in two phases: a) we determine EdgeFlow’s optimal Canny configuration for each VLM; b) we compare EdgeFlow against the baseline. a) Canny Parameter Optimization: We determine EdgeFlow’s Canny hyperparameters via a two-stage optimization, varying one parameter group at a time while holding all other experimental variables from Implementation (Section IV-D) constant (such as VLM architecture, generation parameters, and prompt templates). We evaluate configurations from C1 to C9, with their parameters and rationale listed in Table II. Each configuration is evaluated across five independent runs on IndusReqFlow (52 flowcharts per run, 260 samples total). For each run, flowchart images are converted to Mermaid code by adopting the EdgeFlow pipeline in Methodology (Section III). The resulting Mermaid Code is evaluated against ground-truth using the matching criteria in Section IV-C1. Stage 1 (Threshold Selection). With the Sobel aperture fixed at 3, we test four hysteresis threshold low/high pairs on both VLMs (configurations C1 through C4 in Table II), maintaining the recommended hysteresis ratios of 2:1 and 3:1. For each VLM, the best configuration is determined according to the global-level micro-averaged node and edge F 1 defined in Section IV-C; then serves as reference configuration (C5, omitted in all following tables) in next stage. Stage 2 (Aperture Selection). Using thresholds of Stage 1 optimal configuration for each VLM, we vary the Sobel aperture size to determine the smoothing level that maximizes topological fidelity. For Qwen3-VL-32B, which utilize C3 as threshold reference configuration, we fix low=100/high=200 and test apertures 5 and 7 as C6 and C7. For Qwen3.5-35BA3B, which adopt C2 as threshold reference configuration, we fix low=50/high=150 and test apertures 5 and 7 as C8 and C9. The configuration with highest global-level microaveraged node and edge F 1 across two stages is determined as final optimal configuration and adopted for the baseline comparison in Section IV-E1b. b) Baseline Comparison: For each VLM, we conduct five independent baseline runs defined in Implementation (Section IV-D) on IndusReqFlow. We then compare the result against the result of EdgeFlow’s final optimal configuration
TABLE II: Canny parameter configurations for the two-stage optimization on IndusReqFlow. Config
Low†
High†
Aperture
Model
Rationale
Stage 1: Threshold selection (aperture fixed at 3) C1 C2 C3 C4
30 50 100 100
100 150 200 300
3 3 3 3
Both VLMs Both VLMs Both VLMs Both VLMs
Low thresholds retaining connectors degraded by compression artifacts and resolution variance Intermediate thresholds balancing edge retention against compression noise ControlNet default [20]; reproducible, externally validated starting point Conservative thresholds retaining only prominent edges; tests minimal skeleton sufficiency
Stage 2: Aperture selection (thresholds fixed from Stage 1) C6 C7 C8 C9
100 100 50 50
200 200 150 150
5 7 5 7
Qwen3-VL-32B Qwen3-VL-32B Qwen3.5-35B-A3B Qwen3.5-35B-A3B
Increased smoothing over Stage 1 default (aperture 3) Maximum Sobel aperture; strongest smoothing level Increased smoothing on MoE-optimal thresholds Maximum Sobel aperture on MoE-optimal thresholds
† Canny hysteresis threshold lower and upper bounds.
from Stage 2, following the aggregation and statistical analysis metrics in Section IV-C2. 2) Analysis Procedure for RQ2: RQ2 assesses whether EdgeFlow’s node- and edge-level improvements from RQ1 enable better support for downstream MBT. In MBT workflows that use flowcharts as the behavioral model, each entryto-terminal path through the control-flow graph is used to construct test cases [6, 7]; consequently, path-level correctness reflects the quality of automatically derived test cases. For each VLM, we reuse the Mermaid code produced in RQ1–five independent EdgeFlow runs under the optimal configuration (C3 for Qwen3-VL-32B, C9 for Qwen3.5-35B-A3B) and five independent baseline runs–yielding 260 samples per condition (52 flowcharts × 5 runs). To extract test case paths, each Mermaid Code is parsed into a JSON structure of nodes and edges, from which an adjacency list is constructed. Entry nodes and terminal nodes are identified, and a depth-first search enumerates all entry-to-terminal paths; for flowcharts containing cycles, each loop is unrolled once, which is consistent with the standard MBT practice of requiring at least one iteration through each loop body for minimal path coverage [7]. Ground truth paths are extracted from the groundtruth Mermaid Code using the same procedure. Path-level P , R, and F 1 are computed following path-level metrics defined in Section IV-C1c, with aggregation and statistical testing per Section IV-C2. 3) Analysis Procedure for RQ3: To assess whether EdgeFlow generalizes beyond industrial data, we apply the baseline comparison protocol from RQ1 to the FlowVQA subsample (Section IV-B2), evaluating node- and edge-level P , R, and F 1. Note that the Canny hyperparameters are not re-optimized for FlowVQA – we reuse the optimal configurations identified on IndusReqFlow (C3 for Qwen3-VL-32B, C9 for Qwen3.535B-A3B) to test generalization without dataset-specific tuning. All other variables (VLMs, baseline condition, generation parameters, and evaluation pipeline) remain identical. For both VLMs, we conduct five independent runs (40 flowcharts per run, 200 samples total). V. R ESULTS A. RQ1 Result: Topological Correctness Improvement a) Canny Parameter Optimization Result: Prior to the baseline comparison, we conducted a two-stage Canny hyper-
parameter optimization defined in Section IV-E. Table III summarizes the impact of each Canny configuration on topological extraction performance. For Qwen3-VL-32B, C3 achieved the highest node F1 (81.16%) and edge F1 (65.88%) across both stages. For Qwen3.5-35B-A3B, C9 substantially outperformed all other configurations with node F1 of 66.02% and edge F1 of 46.26%, suggesting that stronger Gaussian smoothing benefits the MoE architecture on IndusReqFlow. Across both models, overly low thresholds inflate false-positive edges while overly high thresholds cause edge loss. b) Baseline Results: Table IV summarizes EdgeFlow’s performance compared to baseline, using the optimal Canny configurations selected above, which are C3 for Qwen3-VL32B, C9 for Qwen3.5-35B-A3B. For Qwen3-VL-32B, EdgeFlow achieved a micro-averaged node F1 of 81.16% and edge F1 of 65.88%, improving over the baseline by 17.39 percentage points (pp) for node F1 (27.3% relative) and 16.94 pp for edge F1 (34.6% relative). The per-flowchart analysis confirms that these improvements are statistically significant across all metrics (p < 0.001, Wilcoxon signed-rank test) with consistently large effect sizes (Cliff’s δ = 0.67 for node F1, δ = 0.75 for edge F1). EdgeFlow outperformed the baseline on 42 of 52 flowcharts for node F1 (win/tie/loss: 42/3/7) and 45 for edge F1 (45/1/6), demonstrating consistent improvement and reduced output variability (edge F1 SD: 27.67 → 20.62), indicating more stable extraction on heterogeneous industrial inputs. Inspection of the loss cases reveals that they correspond to flowcharts where the baseline already achieves high performance, suggesting that edge-map augmentation provides diminishing returns when the VLM’s native perception is already adequate. The larger edgelevel relative improvement (+34.6%) compared to the node level (+27.3%) underscores that EdgeFlow’s Canny edge priors are effective at recovering connectivity relationships–the core topological challenge in industrial flowcharts. For Qwen3.5-35B-A3B, EdgeFlow achieved a microaveraged node F1 of 66.02% and edge F1 of 46.26%, improving over the baseline by 7.81 pp for node F1 (13.4% relative) and 10.00 pp for edge F1 (27.6% relative). Per-flowchart statistical tests confirm significance across all metrics (p < 0.001), with consistently large effect sizes (Cliff’s δ = 0.60 for both node and edge F1). EdgeFlow improved results on 40 of 52
TABLE III: Canny hyperparameter optimization on IndusReqFlow. Bold indicates best metric per model. Node High†
Edge
Model
Config
Low†
Aperture
Precision
Recall
F1
Precision
Recall
F1
Qwen3-VL-32B
C1 C2 C3 C4 C6 C7
30 50 100 100 100 100
100 150 200 300 200 200
3 3 3 3 5 7
81.32% 80.86% 83.51% 83.24% 81.23% 83.16%
70.55% 69.21% 78.93% 76.55% 70.86% 74.59%
75.55% 74.58% 81.16% 79.76% 75.69% 78.64%
65.61% 65.44% 66.53% 67.44% 65.37% 67.10%
58.36% 57.18% 65.25% 64.16% 58.36% 62.20%
61.77% 61.03% 65.88% 65.76% 61.67% 64.56%
Qwen3.5-35B-A3B
C1 C2 C3 C4 C8 C9
30 50 100 100 50 50
100 150 200 300 150 150
3 3 3 3 5 7
60.78% 36.75% 28.49% 24.58% 55.65% 68.73%
23.03% 39.27% 32.14% 34.83% 47.53% 63.52%
33.41% 37.97% 30.21% 28.82% 51.27% 66.02%
41.75% 19.29% 18.80% 18.60% 39.41% 47.97%
15.84% 27.99% 20.49% 25.64% 29.89% 44.66%
22.96% 22.84% 19.61% 21.56% 34.00% 46.26%
† Canny hysteresis threshold lower and upper bounds.
TABLE IV: EdgeFlow vs. baseline on IndusReqFlow: node- and edge-level performance with statistical significance tests. Node Model
Qwen3-VL-32B
Qwen3.5-35B-A3B
Edge
Method
Precision
Recall
F1
Precision
Recall
F1
Baseline (micro-avg) EdgeFlow (micro-avg)
67.02% 83.51%
60.83% 78.93%
63.77% 81.16%
51.07% 66.53%
46.98% 65.25%
48.94% 65.88%
Baseline (per-flowchart) EdgeFlow (per-flowchart)
64.54±25.01% 81.98±13.55%
63.58±23.44% 82.17±13.33%
63.77±24.01% 82.03±13.33%
49.31±28.01% 65.93±20.67%
49.58±28.02% 68.16±21.27%
49.13±27.67% 66.87±20.62%
p-value Cliff’s δ (W/T/L)
<0.001 0.71L (43/3/6)
<0.001 0.62L (40/4/8)
<0.001 0.67L (42/3/7)
<0.001 0.67L (43/1/8)
<0.001 0.67L (42/3/7)
<0.001 0.75L (45/1/6)
Baseline (micro-avg) EdgeFlow (micro-avg)
60.85% 68.73%
55.79% 63.52%
58.21% 66.02%
37.78% 47.97%
34.85% 44.66%
36.26% 46.26%
Baseline (per-flowchart) EdgeFlow (per-flowchart)
27.13±32.54% 66.59±22.78%
27.03±32.50% 67.10±22.88%
27.07±32.50% 66.79±22.75%
17.42±26.14% 49.19±30.22%
17.30±25.86% 50.03±31.02%
17.34±25.94% 49.53±30.47%
p-value Cliff’s δ (W/T/L)
<0.001 0.60L (40/3/9)
<0.001 0.60L (40/3/9)
<0.001 0.60L (40/3/9)
<0.001 0.60L (38/7/7)
<0.001 0.60L (38/7/7)
<0.001 0.60L (38/7/7)
L Large (|δ| ≥ 0.474), M Medium (≥ 0.33), S Small (≥ 0.147).
flowcharts for node F1 (40/3/9) and 38 for edge F1 (38/7/7). Notably, the per-flowchart mean improvement is substantial (+39.72 pp for node F1 vs. +18.26 pp for Qwen3-VL-32B), reflecting EdgeFlow’s ability to recover outputs on flowcharts where the MoE baseline produced near-zero scores. The MoE model’s lower baseline–attributable to limited active parameter capacity (3B active)–provides greater headroom for edge-map augmentation, resulting in larger absolute gains. However, the MoE model shows slightly higher loss counts (9 losses for node F1 vs. 7 for the dense model) and lower absolute performance after augmentation (node F1: 66.02% vs. 81.16%), suggesting that active parameter capacity remains a limiting factor for industrial deployment. Despite these architectural differences, both models benefit from EdgeFlow, which we attribute to the high-frequency topological signals extracted by the Canny edge map. By isolating connectivity features as high-contrast patterns, the edge map makes them more visually prominent to the VLM, compensating for the loss of finegrained geometric detail during ViT patch tokenization. The answer to RQ1: EdgeFlow significantly improves topological correctness compared to baseline on IndusReqFlow.
B. RQ2: Path Generation for MBT Support Path Coverage Results. Using the optimal Canny configurations from RQ1, we evaluated path quality on the full dataset (Table V). For Qwen3-VL-32B, EdgeFlow improved micro-averaged path F1 by 11.06 pp. Per-flowchart Wilcoxon signed-rank tests confirm that all three path-level improvements are statistically significant (p < 0.001), with mediumto-large effect sizes (Cliff’s δ: 0.44 for path F1). Notably, path recall achieved a large effect size (δ = 0.50), indicating that EdgeFlow recovers a substantially higher proportion of ground-truth execution paths. Overall, EdgeFlow outperformed the baseline on 31 of 52 flowcharts for path F1. For Qwen3.5-35B-A3B, EdgeFlow improved microaveraged precision by 7.83 pp and F1-score from 21.13% to 25.06%, though micro-averaged recall decreased by 0.70 pp– indicating that edge-map augmentation does not uniformly improve path coverage for the MoE model. Per-flowchart Wilcoxon tests confirm significant improvements for precision and F1 (p = 0.005) and recall (p = 0.038), all with small effect sizes (Cliff’s δ: 0.17–0.27). EdgeFlow outperformed the baseline on 15–18 flowcharts versus 4–6 losses, though 30–31 ties indicate that a substantial proportion of flowcharts showed equivalent path quality under both conditions. These ties likely reflect identical outputs or equivalently zero path
TABLE V: Path-level test case generation quality on IndusReqFlow with statistical significance tests. Path Model
Qwen3-VL-32B
Qwen3.5-35B-A3B
Method
Precision
Recall
F1
Baseline (micro-avg) EdgeFlow (micro-avg)
21.50% 33.00%
15.94% 26.45%
18.31% 29.37%
Baseline (per-flowchart) EdgeFlow (per-flowchart)
17.63±26.52% 28.78±30.42%
16.24±25.26% 27.35±29.05%
16.47±25.10% 27.30±28.80%
p-value (eff. n = 39) Cliff’s δ (W/T/L)
<0.001 0.40M (30/13/9)
<0.001 0.50L (32/14/6)
<0.001 0.44M (31/13/8)
Baseline (micro-avg) EdgeFlow (micro-avg)
18.52% 26.35%
24.60% 23.90%
21.13% 25.06%
Baseline (per-flowchart) EdgeFlow (per-flowchart)
14.55±24.56% 19.90±30.29%
13.94±24.11% 19.28±30.12%
14.09±23.90% 19.32±29.51%
p-value (eff. n = 22) Cliff’s δ (W/T/L)
0.005 0.27S (18/30/4)
0.038 0.17S (15/31/6)
0.005 0.27S (18/30/4)
L Large (|δ| ≥ 0.474), M Medium (≥ 0.33), S Small (≥ 0.147).
matches under both conditions. We note that the absolute path F1 remains moderate (29.37% for Qwen3-VL-32B), reflecting a fundamental metric cascade: under exact-match path evaluation, a single incorrect node label or missing edge invalidates an entire path. Given that even the best node F1 is 81% and edge F1 is 66%, the combinatorial propagation of element-level errors to path level is expected. The answer to RQ2: EdgeFlow’s node- and edge-level improvements translate into statistically significant pathlevel correctness gains for downstream MBT tasks. C. RQ3: Industrial vs. Synthetic Generalization Table VI reports EdgeFlow’s performance on our subset of FlowVQA[10] using the same protocol as RQ1. On FlowVQA, improvements are small to negligible for both VLMs. Qwen3VL-32B shows statistically significant but small edge-level gains (edge F1: +1.45 pp, p = 0.017, δ = 0.23), while node F1 does not reach significance (p = 0.065). Qwen3.535B-A3B shows no significant difference on any metric (all p ≥ 0.200, δ ≤ 0.10), with 60–75% of flowcharts producing equivalent results under both conditions. The baseline already exceeds 91% node F1 on FlowVQA, leaving minimal room for augmentation. Compared with the large improvements on IndusReqFlow (δ ≥ 0.62 for Qwen3-VL-32B). Thus, EdgeFlow’s structural priors are valuable when visual noise and degradation impair VLM perception of connectivity features. The answer to RQ3: EdgeFlow’s improvements are substantially weaker on clean synthetic data. The contrasting evaluation results on industrial and synthetic data highlight the need for diverse benchmarks including real-world industrial data for the comprehensive evaluation of VLM-based RE tools.
baseline), confirming that VLMs read text well but misperceive connectivity. Investment in mitigations should therefore target geometric perception. (ii) The benefit is largest where it matters most. EdgeFlow’s gains scale with input degradation: large on noisy industrial scans, small on clean synthetic data. Teams whose requirements documents are predominantly scanned, photocopied, or re-rendered should expect the strongest improvements. (iii) Path-level gains translate into MBT support. The 11-pp path-F1 improvement is statistically significant and consistent across 31 of 52 flowcharts, meaning more entryto-terminal sequences arrive correct enough to seed candidate test cases without manual repair—a tangible reduction in testengineer effort given documents that contain dozens of charts under frequent revision. Together, these observations argue that deterministic, training-free image augmentation is a pragmatic first step before considering supervised approaches, and that VLM-based RE tooling should be benchmarked on industrial data rather than synthetic surrogates alone. VI. R ELATED W ORK A. Requirements Modeling Visual notations are fundamental to RE, serving as primary media for design and communication [3]. Despite this, RE research has focused heavily on text-to-model generation, successfully extracting domain models [13], UML models [14– 16] from textual requirements. Recovery of structured models from visual specifications remains less explored [9, 11], as static images effectively strip diagrams of their underlying topological logic–connectivity, branching, and edge direction [4]. EdgeFlow addresses this gap by recovering pathenumerable, machine-readable representations from visual flowchart artifacts. B. Flowchart and Diagram Processing
D. Implications for RE Practice Three observations from the results above carry directly into industrial deployment. (i) Topological errors, not label errors, dominate. Node F1 is consistently higher than edge F1 across both VLMs (e.g., 63.77% vs. 48.94% at the Qwen3-VL-32B
Flowchart benchmarks [2, 10] reveal significant VLM limitations, notably “topological blindness” [17] and directional biases favoring standard reading conventions over actual connectivity [10]. Evaluations expose critical barriers to industrial adoption, particularly a brittleness to domain shift where
TABLE VI: Cross-dataset evaluation on FlowVQA: node- and edge-level performance with statistical significance tests. Node Model
Qwen3-VL-32B
Qwen3.5-35B-A3B
Edge
Method
Precision
Recall
F1
Precision
Recall
F1
Baseline (micro-avg) EdgeFlow (micro-avg)
91.66% 93.02%
91.64% 93.02%
91.65% 93.02%
88.39% 89.87%
89.47% 90.90%
88.93% 90.38%
Baseline (per-flowchart) EdgeFlow (per-flowchart)
91.19±23.17% 92.73±18.21%
91.14±23.14% 92.73±18.21%
91.16±23.15% 92.73±18.21%
88.28±25.95% 90.05±21.33%
88.88±25.98% 90.63±21.30%
88.54±25.90% 90.31±21.25%
p-value Cliff’s δ (W/T/L)
0.069ns 0.15S (8/30/2)
0.037* 0.18S (8/31/1)
0.065ns 0.15S (8/30/2)
0.029* 0.20S (11/26/3)
0.016* 0.23S (11/27/2)
0.017* 0.23S (12/25/3)
Baseline (micro-avg) EdgeFlow (micro-avg)
93.39% 93.57%
93.30% 93.49%
93.34% 93.53%
90.62% 90.52%
91.85% 91.65%
91.23% 91.08%
Baseline (per-flowchart) EdgeFlow (per-flowchart)
93.07±21.11% 93.11±20.05%
92.98±21.07% 93.02±20.01%
93.02±21.09% 93.07±20.02%
90.63±22.76% 90.37±23.20%
91.36±22.72% 91.02±23.15%
90.96±22.67% 90.65±23.10%
p-value Cliff’s δ (W/T/L)
0.333ns 0.05N (6/30/4)
0.333ns 0.05N (6/30/4)
0.333ns 0.05N (6/30/4)
0.216ns 0.10N (10/24/6)
0.200ns 0.10N (8/28/4)
0.208ns 0.10N (10/24/6)
ns Not significant (p ≥ 0.05). *Significant (p < 0.05). S Small (|δ| ≥ 0.147), N Negligible (|δ| < 0.147).
models struggle with noise, compression artifacts, and nonstandard notations typical of industrial requirements [2, 17]. Furthermore, they reveal a prevalence of layout–text discrepancy errors, where models hallucinate connectivity by over-relying on label proximity rather than following actual geometric signals like lines and arrowheads [10, 17]. Existing mitigations utilize multi-stage pipelines combining detection, OCR, and structural parsing. These systems generate descriptive narratives [1], encode arrow directions into prompts [18], or output Mermaid diagrams [9] or BPMN representations [11]. However, these approaches introduce overhead and error propagation through reliance on detectors and specialized training. In contrast, EdgeFlow adopts deterministic Canny edge detection as a training-free structural prior. Inspired by ControlNet’s use of edge-map scaffolds for image generation [20], we adapt structural input augmentation for lightweight, deployment-ready flowchart understanding in industrial RE settings. VII. T HREATS TO VALIDITY A. Internal Validity Parameter selection bias. Canny hyperparameters were optimized and evaluated on the same IndusReqFlow dataset (52 flowcharts), as no held-out validation split was employed. This introduces a potential risk of configuration overfitting: the selected parameters (C3 for Qwen3-VL-32B; C9 for Qwen3.535B-A3B) may partially reflect dataset-specific characteristics rather than universally optimal settings. We reduce this concern by evaluating only a small, interpretable parameter space (two hysteresis thresholds and one aperture size). The selected configurations are also interpretable: C3 (100/200, aperture 3) corresponds to the ControlNet default [20], while C9 (50/150, aperture 7) applies stronger smoothing for noisier MoE outputs. We further reuse these configurations on FlowVQA without re-optimization to examine out-of-domain behavior. Nevertheless, we acknowledge this as a methodological limitation. Future work should validate Canny parameter robustness through cross-validation or evaluation on additional industrial datasets from different organizations.
VLM non-determinism. VLM outputs vary across runs due to the non-zero temperature. Mitigation: We use a low temperature and fixed top_p=0.8 to reduce output variability, and run each experiment across 5 independent runs to quantify robustness. Results are aggregated via microaveraging for global metrics and via per-flowchart Wilcoxon signed-rank tests for statistical inference. Model versions and experiment timestamps are recorded to support reproducibility. Sample size. IndusReqFlow comprises 52 industrial flowcharts, which limits statistical power. Mitigation: We apply the Wilcoxon signed-rank test on 52 per-flowchart paired observations complemented by Cliff’s Delta effect sizes, both of which are appropriate for modest sample sizes. We further report win/tie/loss counts for per-flowchart transparency. For RQ3, we complement our evaluation with 40 synthetic flowcharts from FlowVQA to strengthen cross-domain analysis. We acknowledge that observed trends should be interpreted with this sample size constraint. Model selection. All experiments use models from the Qwen family, constrained by the requirements of the enterprise deployment platform (Section IV-D). While EdgeFlow has not yet been tested on other VLM families, we mitigate this by evaluating two architecturally distinct models: a dense model (Qwen3-VL-32B) and a sparse MoE model (Qwen3.5-35BA3B)–to assess robustness across architectural paradigms. B. External Validity Dataset representativeness. IndusReqFlow covers three distinct industrial domains (optical networks, data communications, and electric vehicles) but may not generalize to all domains. Mitigation: RQ3 complements the industrial evaluation with a public synthetic benchmark to assess crossdomain behavior. Diagram types. We evaluate EdgeFlow exclusively on flowcharts. Whether EdgeFlow’s deterministic structural prior transfers to other behavioral diagrams–such as sequence diagrams, state machines, or BPMN–remains an open question, as those diagram types rely on different visual conventions for representing connectivity.
Choice of visual prior. Canny edge detection is a classical, well-understood algorithm, but it is not the only possible structural prior. Generic learned contour detectors could capture different visual cues. We selected Canny for its determinism, zero training cost, and reproducibility; a systematic comparison of alternative priors is left for future work. C. Construct Validity Topological metrics vs. downstream utility. Node and edge F1 capture structural correctness, but do not directly measure usefulness for downstream RE tasks. A graph with correct nodes and edges, but incorrect control-flow ordering may score well yet produce unusable test cases. Mitigation: We address this gap in RQ2 by evaluating path-level correctness, which directly models the MBT workflow of enumerating paths as candidate test cases. Exact-match strictness. Our evaluation uses case-sensitive exact string matching with no normalization (Section IV-C1). A VLM that generates a semantically correct, but superficially different label (e.g., extra whitespace, minor capitalization differences) would be penalized. Mitigation: This strict criterion is deliberately chosen to reflect the industrial requirement of our collaborating test engineers, where even minor label deviations can reference distinct subsystems. VIII. P RACTICAL C ONSIDERATIONS Three deployment-oriented questions tend to appear in industrial adoption discussions. Latency. The time for Canny extraction is negligible compared with the multi-second VLM call. Training-free vs. fine-tuning. A fine-tuned VLM could in principle outperform EdgeFlow but requires annotated flowchart data, rarely available in proprietary RE settings; EdgeFlow is therefore a strong low-cost baseline that future supervised approaches must clear. Beyond MBT. The recovered Mermaid representation also supports other RE activities— traceability between text and visual specifications, change impact analysis on flowchart revisions, and consistency checking across document versions—tasks that currently rely on manual inspection in our partner teams. IX. C ONCLUSION AND F UTURE WORK This paper proposes EdgeFlow, a training-free framework that augments VLMs with deterministically extracted Canny edge maps to improve topological correctness in flowchart-toMermaid conversion. We evaluated EdgeFlow on the industrial dataset IndusReqFlow and the synthetic dataset FlowVQA; the results show statistically significant improvements across the node, edge, and path levels for industrial cases exhibiting visual noise and degradation issues. For the dense Qwen3-VL-32B, EdgeFlow improves node F1 by 17.39 pp and edge F1 by 16.94 pp (p < 0.001, large effect sizes), with consistent gains on 42–45 of 52 flowcharts. At the path level, EdgeFlow improves path F1 from 18.31% to 29.37%, translating structural gains into measurably better candidate test cases for MBT. On clean synthetic data (FlowVQA), improvements are small to negligible, confirming that EdgeFlow’s structural priors are most valuable when
visual noise and degradation impair VLM perception. Key insights: (1) VLMs exhibit systematic topological errors on industrial flowcharts–misperceiving connectivity rather than misidentifying labels–and deterministic edge-map augmentation effectively compensates for this limitation; (2) Trainingfree, deterministic approaches are immediately deployable in industrial settings. Moreover, this finding suggests the necessity of integrating real-world industrial data for the accurate evaluation of VLM-based RE tools. For future work, we will generalize the structural-prior idea to other behavioral diagrams; note that state machines and sequence diagrams encode connectivity through different visual conventions, so a learned, notation-aware contour detector may be required. Our experiences shows that a community-curated, multi-organization benchmark would change how VLM-based RE tools are evaluated; to create benchmarks that would let the community fairly compare future tools on industrial flowcharts, we are extending IndusReqFlow along these lines. R EFERENCES [1] A. Arbaz, H. Fan, J. Ding, M. Qiu, and Y. Feng, “GenFlowchart: Parsing and understanding flowchart using generative AI,” in KSEM’24, pp. 99–111. [2] S. Tannert, M. G. Feighelstein, J. Bogojeska, J. Shtok, A. Arbelle, P. W. Staar, A. Schumann, J. Kuhn, and L. Karlinsky, “FlowchartQA: The first large-scale benchmark for reasoning over flowcharts,” in LIMO workshop’23, pp. 34–46. [3] D. Moody, “The “physics” of notations: Toward a scientific basis for constructing visual notations in software engineering,” IEEE Transactions on Software Engineering, vol. 35, no. 6, pp. 756–779, 2009. [4] S. Baltes and S. Diehl, “Sketches and diagrams in practice,” in FSE’14. ACM, pp. 530– 541. [5] International Organization for Standardization, “Information processing – documentation symbols and conventions for data, program and system flowcharts, program network charts and system resources charts,” 1985. [6] L. Briand and Y. Labiche, “A UML-based approach to system testing,” Software and systems modeling, vol. 1, no. 1, pp. 10–42, 2002. [7] M. Utting and B. Legeard, Practical model-based testing: A tools approach. Morgan Kaufmann, 2007. [8] I. K. El-Far and J. A. Whittaker, “Model-based software testing,” Encyclopedia of software engineering, 2002. [9] P. Deka and B. Devereux, “Flowchart2Mermaid: A vision-language model powered system for converting flowcharts into editable diagram code,” arXiv:2512.02170, 2025. [10] S. Singh, P. Chaurasia, Y. Varun, P. Pandya, V. Gupta, V. Gupta, and D. Roth, “FlowVQA: Mapping multimodal logic in visual question answering with flowcharts,” in Findings of ACL’24, 2024, pp. 1330–1350. [11] P. Deka and B. Devereux, “Structured extraction from business process diagrams using vision-language models,” in SAC’26. ACM. [12] L. Zhao, W. Alhoshan, A. Ferrari, K. J. Letsholo, M. A. Ajagbe, E.-V. Chioasca, and R. T. Batista-Navarro, “Natural language processing for requirements engineering: A systematic mapping study,” ACM Computing Surveys, vol. 54, no. 3, pp. 1–41, 2021. [13] C. Arora, M. Sabetzadeh, L. Briand, and F. Zimmer, “Extracting domain models from natural-language requirements: approach and industrial evaluation,” in MODELS’16. ACM, pp. 250–260. [14] D. De Bari, G. Garaccione, R. Coppola, M. Torchiano, and L. Ardito, “Evaluating large language models in exercises of uml class diagram modeling,” in ESEM’24, p. 393–399. [15] T. Eisenreich, N. Friedlaender, and S. Wagner, “Leveraging large language models for use case model generation from software requirements,” in ASEW’25, pp. 221–227. [16] A. Ferrari, S. Abualhaija, and C. Arora, “Model generation with LLMs: From requirements to UML sequence diagrams,” in REW’24, 2024, pp. 291–300. [17] H. Pan, Q. Zhang, C. Caragea, E. Dragut, and L. Latecki, “FlowLearn: Evaluating large vision-language models on flowchart understanding,” ECAI, pp. 73–80, 2024. [18] T. Omasa, R. Koshihara, and M. Morishige, “Arrow-guided VLM: Enhancing flowchart understanding via arrow direction encoding,” arXiv:2505.07864, 2025. [19] J. Canny, “A computational approach to edge detection,” TPAMI, vol. PAMI-8, no. 6, pp. 679–698, 1986. [20] L. Zhang, A. Rao, and M. Agrawala, “Adding conditional control to text-to-image diffusion models,” in ICCV’23, 2023, pp. 3813–3824. [21] Emily, “mermaid-ast: Parse and render mermaid diagrams to/from ast,” 2026. [22] F. Wilcoxon, “Individual comparisons by ranking methods,” Biometrics Bulletin, vol. 1, no. 6, pp. 80–83, 1945. [23] N. Cliff, “Dominance statistics: Ordinal analyses to answer ordinal questions,” Psychological Bulletin, vol. 114, no. 3, pp. 494–509, 1993. [24] S. Baltes, F. Angermeir, C. Arora, M. M. Barón, C. Chen, L. Böhme, F. Calefato, N. Ernst, D. Falessi, B. Fitzgerald, D. Fucci, J. He, C. Treude, M. Kalinowski, S. Lambiase, D. Russo, M. Lungu, C. M. Montes, L. Prechelt, P. Ralph, R. van Tonder, and S. Wagner, “Guidelines for Empirical Studies in Software Engineering involving Large Language Models,” arXiv:2508.15503, 2025.