Paper deep dive
Synthetic data generation framework for quality control automation in gravure printing
Korota Arsène Coulibaly, Mohamed Hamlich, Khalid Hmali, Andrea Trombin
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 94%
Last extracted: 7/25/2026, 1:22:58 AM
Summary
This paper presents a synthetic data generation framework for automating quality control in rotogravure printing. Addressing the scarcity of real-world defect images, the framework simulates defects such as creases, streaks, misregistration, and fisheyes to create a labeled dataset. A synthetic dataset of 7,533 images was used to train the RFDETR object detection model, achieving an 80.9% Mean Average Precision (mAP) on real industrial samples, offering a zero-cost solution for defect inspection.
Entities (12)
Relation Signals (10)
RFDETR → achievesmetric → Mean Average Precision
confidence 95% · Experimental results demonstrate that the model trained on our synthetic data achieves a Mean Average Precision (mAP) of 80.9%
Synthetic Data Generation Framework → addressesproblem → Scarcity of Real-World Defect Images
confidence 95% · To overcome this limitation, this paper introduces a novel synthetic data generation framework... heavily hindered by the extreme scarcity of real-world industrial defects images.
Synthetic Data Generation Framework → appliedto → Rotogravure Printing
confidence 95% · This paper introduces a novel synthetic data generation framework tailored for rotogravure printing quality control.
Synthetic Data Generation Framework → generates → Fisheyes
confidence 95% · To model gravure printing defects(misregistration, creases, streaks, and fisheyes) we drew inspiration...
Synthetic Data Generation Framework → generates → Misregistration
confidence 95% · The proposed pipeline automatically generates high-fidelity images of specific printing defects (creases, streaks, misregistration, etc.)
Synthetic Data Generation Framework → generates → Creases
confidence 95% · The proposed pipeline automatically generates high-fidelity images of specific printing defects (creases, streaks, misregistration, etc.)
Synthetic Data Generation Framework → generates → Streaks
confidence 95% · The proposed pipeline automatically generates high-fidelity images of specific printing defects (creases, streaks, misregistration, etc.)
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Quality control in printing, particularly in rotogravure printing, still depends on slow, costly, and subjective manual inspection. Automated surface defect detection is critical for maintaining high-quality standards in rotogravure printing. Deep learning models give prospects for automation. However, training robust deep learning models, such as YOLO or Vision Transformers, is heavily hindered by the extreme scarcity of real-world industrial defects images. To overcome this limitation, this paper introduces a novel synthetic data generation framework tailored for rotogravure printing quality control. The proposed pipeline automatically generates high-fidelity images of specific printing defects (creases, streaks, misregistration, etc.) and outputs corresponding bounding boxes and annotations. To validate the framework, a synthetic dataset of 7533 images was generated and used to train the state-of-the-art object-detection model RFDETR. Experimental results demonstrate that the model trained on our synthetic data achieves a Mean Average Precision (mAP) of 80.9\% on real industrial testing samples. This framework provides a zero-cost, rapid-deployment solution for automating defect inspection in printing lines without requiring massive manual data collection.
Tags
Links
- Source: https://arxiv.org/abs/2607.21577v1
- Canonical: https://arxiv.org/abs/2607.21577v1
Trouble viewing inline? Open PDF directly →
Full Text
48,633 characters extracted from source content.
Expand or collapse full text
Synthetic data generation framework for quality control automation in rotogravure printing11footnotemark: 1 Korota Arsène COULIBALY korota.colibaly-etu@etu.univh2c.ma https://github.com/Korotaa/STAGE-PLASTIMA Mohamed HAMLICH Khalid HMALI Andrea TROMBIN Abstract Quality control in printing, particularly in rotogravure printing, still depends on slow, costly, and subjective manual inspection. Automated surface defect detection is critical for maintaining high-quality standards in rotogravure printing. Deep learning models give prospects for automation. However, training robust deep learning models, such as YOLO or Vision Transformers, is heavily hindered by the extreme scarcity of real-world industrial defects images. To overcome this limitation, this paper introduces a novel synthetic data generation framework tailored for rotogravure printing quality control. The proposed pipeline automatically generates high-fidelity images of specific printing defects (creases, streaks, misregistration, etc.) and outputs corresponding bounding boxes and annotations. To validate the framework, a synthetic dataset of 7533 images was generated and used to train the state-of-the-art object-detection model RFDETR. Experimental results demonstrate that the model trained on our synthetic data achieves a Mean Average Precision (mAP) of 80.9% on real industrial testing samples. This framework provides a zero-cost, rapid-deployment solution for automating defect inspection in printing lines without requiring massive manual data collection. keywords: synthetic data , semantic segmentation , gravure printing defects , computer vision, , quality control , Industry 4.0 †journal: Journal of Computers Graphics [1]organization=LCCPS Lab, ENSAM, Hassan I University of Casablanca, addressline=150 Bd du Nil, city=Casablanca, postcode=20670, state=, country=Morocco [2]organization=Plastima, addressline=Commune Chellalat, Route Secondaire 3002, Mohammedia, city=Casablanca, postcode=, state=, country=Morroco 1 Introduction Maintaining good print quality is a fundamental pillar of the gravure printing industry. It directly impacts customer satisfaction and the company’s reputation. Traditionally, quality control is based on visual inspection by expert operators on dedicated machines called viewing machines. This manual process has inherent limitations: it is slow, labor-intensive, and subject to operator subjectivity and tiredness. The advent of Industry 4.0, computer vision, and deep learning, particularly semantic segmentation models, offers an unprecedented opportunity to automate and objectify this inspection [21], [22]. These technologies not only detect the presence of an anomaly in an image, but also locate and classify it with pixel-level accuracy, providing crucial information for the diagnosis of root causes [3],[4],[7]. A real-time defect detection system presented in [17], analyzes print images captured by CCD cameras, scanned via a frame grabber, and compared to a gold master image with no defects. Defect detection is based on the identification of Regions of Interest (ROI) by contour detection algorithms based on pixel intensity differences. A correlation subtraction ensures image synchronization for accurate comparison. Defective pixels are grouped by correlation analysis and then classified according to their size and structure. However, the deployment of these computer vision systems is confronted with a major obstacle, well-known in the field of industrial vision: the difficulty in obtaining sufficient training data [1]. The creation of a sufficiently large, diversified, and, especially, precisely labeled dataset at the pixel level in gravure printing is a very complex process, often due to the very small nature of defects (fisheyes). Collecting thousands of examples of real defects, which are by nature rare events, and annotating them manually and accurately represents an investment in time and resources that is often incompatible with the constraints of an industrial project (deadlines, budgets). This challenge is amplified by another reality of our production: the constant variability of printed patterns to meet customer orders. This dynamic makes anomaly detection approaches based on comparison to a reference pattern or AI models that learn all patterns extremely complex to implement, constantly changing the reference model. The need for a flexible system capable of adapting to this continuous flow of new designs is therefore essential. To respond to these challenges, this article presents a comprehensive framework for synthetic data generation, designed to enable the training of an automated, accurate, and flexible computer vision quality control system. The main contributions of this work are as follows: 1. A multi-class print defect simulation framework. We propose a methodology for modeling and generating a diverse range of physically realistic defects (streaks, creases, misregistration, etc.), enabling large-scale dataset creation for deep Convolutional Neural Networks (CNN) systems. 2. An automatic labeling method for semantic segmentation. Our approach generates defective images and their perfect pixel-level segmentation masks, eliminating the need for costly and error-prone manual annotation. This paper is structured as follows: Section 2 (Materials and Methods) provides an overview of the related works and describes our innovative framework for generating synthetic data. The simulation results are presented in Section 3 (Results). Section 4 (Discussion) provides an in-depth analysis of these results, exploring their implications for the gravure printing industry, current constraints, and potential improvements, before concluding in Section 5. 2 Material and methods Our framework is applied in the field of rotogravure printing or roll-to-roll printing. This is an industrial printing technique that involves transferring gravure-printed ink onto a continuous substrate, such as paper, plastic, or metal film, which is rolled from one cylinder to another. It is widely used in areas such as packaging, decoration, publishing, and printed electronics, where precision and consistency are essential [13]. 2.1 Related Works [19] presents a methodology that uses a factory’s digital twin to generate synthetic data for training CNNs, enabling the simulation of various scenarios and increasing the diversity of data available for online quality control. Similarly, in [12] authors introduce MicroFactory, an autonomous digital twin that generates synthetic data to optimize the production of photovoltaic cells printed with a roll-to-roll printer. Their approach combines high-throughput device manufacturing with the use of machine learning models to simulate a wide range of production configurations, facilitating the identification of optimal parameters and illustrating the potential of synthetic data for the optimization of complex processes. In [20], the authors developed a pioneering approach to pixel-level defect mapping. Their framework, based on semantic segmentation with DeepLab-v3+, was characterized by an innovative method of synthetic data generation. Faced with the scarcity of real annotated datasets, they synthesized dark streaks and banding defects by integrating advanced techniques for optical and color reconstruction. More specifically, the simulation of defects included the insertion of textured dark streaks whose colorimetric intensity varied through the application of Perlin noise, as well as the superimposition of rectangular color bands obtained by manipulating the CMYK (Cyan, Magenta, Yellow, Black) channels and modeling pixel intensity variations via a bimodal Gaussian distribution. To accurately reproduce the effect of printing and scanning, they calibrated the RGB (Red, Green, Blue) tone curves of actual devices and established a color transformation model using linear least squares regression. This study extends and adapts these principles of synthetic data generation specifically to the inspection of defects in gravure printing on roll-to-roll printers. The modified image and its corresponding segmentation mask are generated simultaneously. We focus on the pixel-level identification and mapping of a specific range of defects critical to this type of production, including misregistrations, fisheyes, streaks, and creases. This approach allows us to quickly build a large, varied dataset (we control all parameters) that is accurately annotated, which is essential for training a segmentation model. The goal is to leverage the benefits of semantic segmentation and the flexibility of synthetic data generation to develop high-precision, fully automated inspection systems, which are essential in a challenging industrial environment. 2.2 Synthetic data generation Framework This framework is a direct response to the constraints of the project. The difficulty lies in acquiring and labeling a sufficient volume of real data within the deadline (five months). By modeling defects, we turn this constraint into an advantage. We have complete control over the variety and quantity of data generated. We obtain perfect labels because the mask for each defect is created at the same time as the defect itself. To model gravure printing defects(misregistration, creases, streaks, and fisheyes) we drew inspiration from the work in [6],[9],[10],[23],[5] on cylinder dynamics and registration control in roll-to-roll systems and adapted it to our case study. Based on these principles, we have developed appropriate simulation models, combining the mechanical parameters of the cylinders and ink deposition, in order to generate realistic synthetic data for training computer vision systems and evaluating quality control strategies. 2.2.1 Framework architecture Our Framework shown in Figure 1, operates in three steps: 1. Setup: We configure the storage folders, the types of defects to simulate (number of defects per image, etc), and initialize the other necessary parameters. 2. Defect generation: for each image, a random defect is applied. The framework then generates a segmentation mask (precise location of the defect), the image with the defect, and a visual mask (to facilitate visualization). 3. Store: We constructed the synthetic dataset by storing all generated components, namely the defective images, segmentation masks, and visual masks. Figure 1: Framework architecture 2.2.2 Framework algorithm The process, formalized in Algorithm 1, iterates over a set of healthy images to apply modeled defects to them. For each image, a random number of defects are applied sequentially. At each step, a simulation function (crease, shift, etc) is chosen at random with random parameters (size, position) to ensure diversity (lines 10-12). 1 Data: DcleanD_clean: Set of file paths to the input images Data: FdefectsF_defects: Set of defect simulation functions f1,f2,…,fk\f_1,f_2,...,f_k\ Data: NmaxN_max: Maximum number of defects to apply per image 2 Result: DdefectiveD_defective: Set of synthetic defective images Result: MsegmentationM_segmentation: Set of corresponding segmentation masks 3 4 Function GenerateSyntheticDataset(Dclean,Fdefects,NmaxD_clean,F_defects,N_max) 5 Ddefective←∅D_defective← 6 Msegmentation←∅M_segmentation← 7 8 foreach image_pathimage\_path in DcleanD_clean do 9 Ioriginal←LoadImage(image_path)I_original← LoadImage(image\_path) 10 height,width←GetDimensions(Ioriginal)height,width← GetDimensions(I_original) 11 Ifinal←Copy(Ioriginal)I_final← Copy(I_original) 12 Mfinal←CreateZeroMatrix(height,width)M_final← CreateZeroMatrix(height,width) 13 14 ndefects←RandomInteger(1,Nmax)n_defects← RandomInteger(1,N_max) 15 16 for i←1i← 1 to ndefectsn_defects do 17 fselected←ChooseRandomly(Fdefects)f_selected← ChooseRandomly(F_defects) 18 parameters←GenerateRandomParameters(fselected,width,height)parameters← GenerateRandomParameters(f_selected,width,height) 19 // Apply the defect and retrieve the modified image and mask 20 Itemp,Mtemp←fselected(Ifinal,parameters)I_temp,M_temp← f_selected(I_final,parameters) 21 // Update the final image and the global mask 22 Ifinal←ItempI_final← I_temp Mfinal←Mfinal∨MtempM_final← M_final M_temp // Logical OR operation to merge masks 23 24 end for 25 26 Add(Ddefective,IfinalD_defective,I_final) 27 Add(Msegmentation,MfinalM_segmentation,M_final) 28 29 end foreach 30 31 return Ddefective,MsegmentationD_defective,M_segmentation 32 33 end Algorithm 1 Synthetic print defect dataset generation 2.2.3 fisheye defect These are small circular or oval spots resulting from incomplete ink deposit, usually caused by foreign contamination introduced during the calendering process. The white spot defect, or fisheye, is simulated by modeling the effect of a single chemical contamination on the printing surface. The algorithm modifies the original image I0I_0 by applying a crater effect to N positions, thus generating a final defective image IfI_f. The effect of a single point of contamination centered at (cx,cy)(c_x,c_y) is described by the following equation, which alters the value of a pixel I0(x,y)I_0(x,y) according to its distance from the center of the defect: If(x,y)=Cgroundif d(x,y)≤rcI0(x,y)⋅βif rc<d(x,y)≤rI0(x,y)elseI_f(x,y)= casesC_ground&if d(x,y)≤ r_c\\ I_0(x,y)·β&if r_c<d(x,y)≤ r\\ I_0(x,y)&else cases (1) Each term in equation 1 represents a part of the crater effect: 1. If(x,y)I_f(x,y) is the pixel value of the modified image at the (x,y)(x,y) position. 2. I0(x,y)I_0(x,y) is the pixel value of the original image. 3. d(x,y)d(x,y) is the euclidean distance of the pixel (x,y)(x,y) from the center of the defect (cx,cy)(c_x,c_y), defined by d(x,y)=(x−cx)2+(y−cy)2d(x,y)= (x-c_x)^2+(y-c_y)^2. 4. r is the total radius of the defect. 5. rcr_c is the radius of the crater’s bright center, typically rc≈0.7⋅r_c≈ 0.7· r. 6. CgroundC_ground is the average color of the image background, simulating a complete lack of ink. 7. β is the darkness factor for the ink bead, with β<1β<1 (e.g., 0.85). For each contamination point, the algorithm defines a circular area. If a pixel is in the inside circle (the crater center, d≤rcd≤ r_c), its color is replaced by the background color. If it’s in the outside circle (the rim, rc<d≤r_c<d≤ r), its color is darkened. Pixels outside the circle are not affected by this defect. The implementation of this model is detailed in Algorithm 2. 1 Data: I0I_0: The original RGB image Data: N_spots: The number of defects to generate Data: R_range: The range [rmin,rmax][r_ ,r_ ] for the spot radius Data: C_value: The integer class value for the segmentation mask 2 Result: IfI_f: The final image with fisheye defects Result: M_seg: The corresponding segmentation mask 3 4 5 Function GenerateFisheyeDefect(I0,N,R,CI_0,N_spots,R_range,C_value) 6 If←ConvertToFloat(I0)I_f← ConvertToFloat(I_0) 7 h,w←GetDimensions(I0)h,w← GetDimensions(I_0) 8 M←CreateZeroMatrix(h,w)M_seg← CreateZeroMatrix(h,w) 9 C←CalculateBackgroundColor(I0)C_fond← CalculateBackgroundColor(I_0) 10 11 for i←1i← 1 to N_spots do 12 cx←RandomInteger(0,w−1)c_x← RandomInteger(0,w-1) 13 cy←RandomInteger(0,h−1)c_y← RandomInteger(0,h-1) 14 r←RandomInteger(R,min,R,max)r← RandomInteger(R_range, ,R_range, ) 15 rc←⌊r×0.7⌋r_c← r× 0.7 16 β←0.85β← 0.85 17 // Create masks for the defect areas 18 M←CreateCircleMask((cx,cy),rc)M_center← CreateCircleMask((c_x,c_y),r_c) 19 M←CreateRingMask((cx,cy),rc,r)M_ring← CreateRingMask((c_x,c_y),r_c,r) 20 // Apply visual effects based on the equation 21 SetValueWhere(If,M,CI_f,M_center,C_fond) 22 MultiplyValueWhere(If,M,βI_f,M_ring,β) 23 // Update the final segmentation mask 24 M←M∨M_spot← M_center M_ring 25 SetValueInMask(M,M,CM_seg,M_spot,C_value) 26 27 end for 28 29 If←ClipAndConvertToUInt8(If,0,255)I_f← ClipAndConvertToUInt8(I_f,0,255) 30 return If,MI_f,M_seg 31 32 end Algorithm 2 Fisheye Algorithm 2.2.4 Streak defect These are fine lines or undesirable streaks resulting from non-uniform ink distribution or mechanical failure of the cylinder or squeegee. The streak defect is modelled as a localized photometric alteration in a vertical band. To avoid the artificial appearance of a simple line of uniform color, our simulation combines three components to define the intensity of the darkness at each point. The final defective image IfI_f is obtained by multiplying the pixel values of the original image I0I_0 by an attenuation factor S(x,y)S(x,y) within the streak area. If(x,y)=I0(x,y)⋅(1−S(x,y))si (x,y)∈AreastreakI0(x,y)elseI_f(x,y)= casesI_0(x,y)·(1-S(x,y))&si (x,y) _streak\\ I_0(x,y)&else cases (2) The intensity factor of the stripe S(x,y)S(x,y) is the product of three distinct functions: S(x,y)=A⋅P(x)⋅Π(y)S(x,y)=A· P(x)· (y) (3) Each term in equation 3 models a physical characteristic of the streak: 1. A is the base intensity of the streak, a global parameter. 2. P(x)P(x) is the cross-profile function, which smooths the edges of the stripe. It is represented by a parabolic function that reaches its maximum at the center of the streak (x=xcx=x_c) and becomes zero at its edges. For a streak of width W centered at xcx_c, it is defined by: P(x)=1−(2(x−(xc−W/2))W−1)2P(x)=1- ( 2(x-(x_c-W/2))W-1 )^2 3. Π(y) (y) is the longitudinal texture function, which simulates the variation in ink density along the streak. It is generated by 1D Perlin noise, normalized between 0 and 1. This function gives the streak its organic and non-uniform appearance [11]. This composite approach allows synthetic streaks to be generated with a high degree of realism, as detailed in Algorithm 3. 1 Data: I0I_0: The original RGB image Data: xcx_c: The center x-coordinate of the streak Data: W: The width of the streak Data: A: The base intensity of the streak Data: C_value: The integer class value for the segmentation mask 2 Result: IfI_f: The final image with the streak defect Result: M_seg: The corresponding segmentation mask 3 4 5 Function GenerateStreakDefect(I0,xc,W,A,CI_0,x_c,W,A,C_value) 6 If←ConvertToFloat(I0)I_f← ConvertToFloat(I_0) 7 h,w←GetDimensions(I0)h,w← GetDimensions(I_0) 8 M←CreateZeroMatrix(h,w)M_seg← CreateZeroMatrix(h,w) 9 // Step 1: Generate the longitudinal texture Π←GeneratePerlinNoise1D(h) ← GeneratePerlinNoise1D(h) // Returns a vector of size h 10 // Step 2: Apply the effect column by column 11 x←xc−⌊W/2⌋x_start← x_c- W/2 12 x←xc+⌈W/2⌉−1x_end← x_c+ W/2 -1 13 14 for x←x← x_start to x_end do 15 if 0≤x<w0≤ x<w then // Calculate the transversal profile 16 Px←1−(2(x−x)W−1)2P_x← 1- ( 2(x-x_start)W-1 )^2 17 // Calculate the final intensity vector for the column 18 S→x←A⋅Px⋅Π S_x← A· P_x· 19 // Apply the darkening effect to the image column 20 If[:,x]←If[:,x]×(1−S→x)I_f[:,x]← I_f[:,x]×(1- S_x) 21 // Update the segmentation mask 22 M[:,x]←CM_seg[:,x]← C_value 23 24 end if 25 26 end for 27 28 If←ClipAndConvertToUInt8(If,0,255)I_f← ClipAndConvertToUInt8(I_f,0,255) 29 return If,MI_f,M_seg 30 31 end Algorithm 3 Streak Algorithm 2.2.5 Misregistration defect Misregistration is caused by misalignment of the printing cylinders, resulting in incorrect color superposition. To simulate the misregistration defect in a physically coherent form, we developed a composite mathematical model. This model is based on the prediction results of a contour detection CNN [2],[18] that we trained to detect the contours of any pattern with very high accuracy. This mathematical model defines the final defective image, denoted IfI_f(shown in equation 4), as a function of the original image, I0I_0. The approach consists of transparently superimposing one or more simulated ink streaks onto the base image, as described by the following synthesized equation: If(x,y)=(1−α)I0(x,y)+α∑i=1NCci⋅(Dk∘Tvi→)(Medges∧Mcolor(ci))(x,y)I_f(x,y)=(1-α)I_0(x,y)+α _i=1^NC_c_i·(D_k T_ v_i)(M_edges M_color(c_i))(x,y) (4) Each equation term in 4 corresponds to a specific step in our simulation algorithm, which mimics the actual printing process. We break down the equation as follows: 1. I0(x,y)I_0(x,y) and α: The term I0(x,y)I_0(x,y) represents the substrate (our PVC film) already printed correctly by the well-aligned cylinders. The term α⋅(…)α·(…) simulates the offset ink deposit, where α is the transparency factor of this superimposed defect layer. 2. Medges∧Mcolor(ci)M_edges M_color(c_i): This term represents the information scribed on a specific cylinder. To obtain it, we proceed in two steps. First, MedgesM_edges identifies all the edges of the patterns in the final image. Second, Mcolor(ci)M_color(c_i) isolates the color area specific to a cylinder. The logical intersection (∧ ) of these two masks retains only the edges of the shapes that must be printed with the color of cylinder cic_i. 3. (Dk∘Tvi→)(D_k T_ v_i): This operator simulates the mechanical defect and its consequences. Tvi→T_ v_i (Translation) simulates the mechanical shift itself, while DkD_k (Dilation) simulates the slight spreading of the ink. 4. ∑i=1NCci⋅(…) _i=1^NC_c_i·(…): This term simulates the multi-cylinder [14] printing process. CciC_c_i is the ink color, and ∑Σ (Sum) calculates and adds the fringes for each offset cylinder to obtain the complete defect layer. The mathematical model breaks down the defect into its physical causes. It isolates the information from a cylinder, simulates its incorrect mechanical alignment, and applies the corresponding ink to the final image (see Algorithm 4 for the implementation). 1 Data: I0I_0: The original RGB image Data: S: A list of shift tasks, where each task is (ci,vi→)(c_i, v_i) Data: MedgeM_edge: The pre-trained edge detection model 2 Result: IfI_f: The final image with the defect Result: MsegM_seg: The corresponding segmentation mask 3 4 5 Function GenerateMisregistrationDefect(I0,S,MedgeI_0,S,M_edge) h,w←GetDimensions(I0)h,w← GetDimensions(I_0) // Get dimensions first 6 If←Copy(I0)I_f← Copy(I_0) 7 Mseg←CreateZeroMatrix(h,w)M_seg← CreateZeroMatrix(h,w) 8 Lcombined←CreateZeroMatrix(h,w,3,float)L_combined← CreateZeroMatrix(h,w,3,float) 9 // Step 1: Extract clean main contours from the entire image 10 Mcontours←ExtractCleanContours(I0,Medge)M_contours← ExtractCleanContours(I_0,M_edge) 11 // Step 2: Generate and accumulate fringes for each shift task 12 for each (ci,vi→)(c_i, v_i) in S do // Isolate, shift, and paint the fringe for the current cylinder 13 Lfringe,Mfringe←CreateShiftedFringe(I0,Mcontours,ci,vi→)L_fringe,M_fringe← CreateShiftedFringe(I_0,M_contours,c_i, v_i) 14 15 Lcombined←Lcombined+LfringeL_combined← L_combined+L_fringe Mseg←Mseg∨MfringeM_seg← M_seg M_fringe // Logical OR to merge masks 16 17 end for 18 // Step 3: Superimpose the combined fringes onto the original image 19 If←AlphaBlend(If,L,α)I_f← AlphaBlend(I_f,L_combined,α) 20 21 return If,MI_f,M_seg 22 23 end Algorithm 4 Misregistration Algorithm 2.2.6 Crease defect The crease defect is an anomaly that affects both the geometry of the pattern and its photometric appearance. Our simulation models both of these effects. The final defective image, IfI_f(equation 5), is obtained by applying a layer of visual effects E to a geometrically distorted version of the original image,IdI_d. If(x,y)=clip0255(Id(x,y)+E(x,y))I_f(x,y)=clip_0^255 (I_d(x,y)+E(x,y) ) (5) The defect image IdI_d, shown in equation 6, is obtained by applying a non-linear remapping function R to the original image I0I_0, which simulates the pinching of the substrate towards the crease line. Id(x,y)=I0[(x,y)+Amaxexp(−d(x,y)22σ2)v^(x,y)],I_d(x,y)=I_0 [(x,y)+A_ (- d(x,y)^22σ^2 ) v(x,y) ], (6) Where: 1. AmaxA_max is the maximum amplitude of pixel displacement. 2. d(x,y)d(x,y) is the Euclidean distance from pixel (x,y)(x,y) to the fold line segment. 3. exp(−d(x,y)22σ2) (- d(x,y)^22σ^2 ) is a Gaussian function that ensures that the deformation force is maximum on the fold line and decreases with distance. 4. v^(x,y) v(x,y) is the unit vector pointing from pixel (x,y)(x,y) to the nearest point on the fold line, defining the direction of the pinch. The effects layer E(x,y)E(x,y) simulates the relief of the crease by adding shadows and reflections along a curved trajectory P(t)P(t) for greater realism. For each point pip_i on this trajectory, brightness modifications are added to the E layer. The intensity of these effects, F(pi)F(p_i), is modulated by the saturation of the underlying color and by Perlin noise for a more natural rendering as shown in. F(pi)=V⋅Π(ti)⋅S(pi)F(p_i)=V· (t_i)· S(p_i) (7) Where V is a base intensity, Π(ti) (t_i) is the Perlin noise value, and S(pi)S(p_i) is the color saturation at point pip_i. Three effects are applied: a drop shadow, a specular reflection, and a center line simulating ink wear. The implementation of this model is detailed in Algorithm 5. 1 Data: I0I_0: The original RGB image Data: P1,P2P_1,P_2: The start and end points of the crease line Data: AmaxA_max: The maximum pixel displacement for the distortion Data: β: The brightness factor for the centerline Data: CvalueC_value: The integer class value for the segmentation mask 2 Result: If,MsegI_f,M_seg: The final and segmentation mask images 3 4 5 Function Crease defect(I0,P1,P2,Amax,β,CvalueI_0,P_1,P_2,A_max,β,C_value) // Step 1: Geometric Distortion 6 h,w←GetDimensions(I0)h,w← GetDimensions(I_0) 7 Rx,Ry←CreateIdentityRemap(h,w)R_x,R_y← CreateIdentityRemap(h,w) 8 for each pixel (x,y)(x,y) in I0I_0 do 9 d,v^←CalculateDistanceAndVectorToSegment((x,y),P1,P2)d, v← CalculateDistanceAndVectorToSegment((x,y),P_1,P_2) 10 Δ→←Amax⋅exp(−d2/(2σ2))⋅v ← A_max· (-d^2/(2σ^2))· v 11 Rx[y,x]←x+Δ→xR_x[y,x]← x+ _x 12 Ry[y,x]←y+Δ→yR_y[y,x]← y+ _y 13 14 end for 15 Id←Remap(I0,Rx,Ry)I_d← Remap(I_0,R_x,R_y) 16 // Step 2: Photometric Effects Layer 17 E←CreateZeroMatrix(h,w,3,float)E← CreateZeroMatrix(h,w,3,float) 18 Smap←GetSaturationMap(I0)S_map← GetSaturationMap(I_0) 19 Lpath←Length(P1,P2)L_path← Length(P_1,P_2) // Decompose the operation 20 Πnoise←GeneratePerlinNoise1D(Lpath) _noise← GeneratePerlinNoise1D(L_path) 21 22 Ppath←CalculateWobblePath(P1,P2,Amax)P_path← CalculateWobblePath(P_1,P_2,A_max) 23 24 for each point pip_i at step tit_i along PpathP_path do 25 F←CalculateEffectStrength(Smap[pi],Πnoise[ti])F← CalculateEffectStrength(S_map[p_i], _noise[t_i]) 26 AddShadowEffect(E,pi,FE,p_i,F) 27 AddHighlightEffect(E,pi,FE,p_i,F) 28 AddCenterlineEffect(E,pi,F,βE,p_i,F,β) 29 30 end for // Step 3: Final Composition and Mask Generation 31 If←Id+EI_f← I_d+E 32 If←ClipAndConvertToUInt8(If,0,255)I_f← ClipAndConvertToUInt8(I_f,0,255) 33 M←CreateMaskFromDistortion(offset_scale,C)M_seg← CreateMaskFromDistortion(offset\_scale,C_value) 34 35 return If,MI_f,M_seg 36 37 end 38 Algorithm 5 Crease Algorithm 3 Results 3.1 Experimental setup Figure 2 shows a complex pattern to which white dot defects have been added. What makes this simulation particularly successful is the finesse of the defects (circled in red). They are not coarse white holes, but small imperfections that could easily be missed by an inefficient detection system. The characteristic crater effect can be observed: a very light center (simulating the lack of ink) and a slightly darker edge (the bead of repelled ink). Their random distribution across the surface perfectly mimics contamination by particles such as dust or silicone during the calendering process. Figure 2: Some fisheye defects bounded by the red circles Figure 3 shows the segmentation mask associated with the defective image in Figure 5. It is a black-and-white binary image that identifies and localises precisely the fisheyes added to the reference image to form the defective image(see Figure 2) during the simulation. Figure 3: Fisheye mask (a) Reference image (b) Streak defect, located in the red rectangle. Figure 4: Streak defect The application of algorithm 3 on Figure 4(a) gives the result shown in Figure 4(b). This simulation shows a repeating floral pattern on a light background affected by a streak defect, visible as a thin dark or slightly saturated vertical line, bounded by the red rectangle 4(b). This narrow, linear, and uniform defect does not alter the pattern itself and indicates an ink deposit anomaly rather than physical deformation. In gravure printing, a streak is an undesirable, continuous or repetitive line or band that is darker (excess ink, smudging, debris) or lighter (lack of ink, obstruction), usually related to the gravure cylinder, squeegee, particles, or ink. The simulation reproduces these industrial characteristics accurately by highlighting the linearity, contrast, uniformity, and vertical orientation of the defect. Our framework also offers the possibility to control these parameters. Figure 5: Streak mask, a binary image that isolates the exact area of the streak, confirming its linear nature and precise location. The input image in Figure 6(a) is a clean pattern with no defects. The first step in our method is to extract a precise map of the main contours of the pattern, McontoursM_contours, using a structured contour detection model. The result of this operation is a binary mask that represents the skeleton of all the shapes present. (a) Reference image (b) Misregistration defect. Figure 6: Misregistration defects. Cylinders offset alignment causes incorrect superposition of corresponding colors. When we apply the misregistration algorithm to Figure 6(a) we obtain the result shown in Figure 6(b). For this simulation, the framework selected five cylinders in the order: magenta, black, direct orange, direct green, and varnish/white, with the black cylinder serving as the reference. The algorithm then chose to apply an offset to four of these cylinders, each with its own random translation vector: Direct Green and Magenta were offset by (−3,4)(-3,4) pixels, Varnish/White by (3,5)(3,5) pixels, and Direct Orange by (−1,1)(-1,1) pixels. Several semi-transparent overlapping color fringes can be observed. A golden fringe, corresponding to the Direct Orange cylinder, is particularly visible on the edges of the patterned sheets. These fringes precisely follow the extracted contours, creating a composite and very realistic ink smear effect, characteristic of poor mechanical alignment of several cylinders on the press. Figure 7: Misregistration defect mask. The mask corresponds to the walls (drawings or outlines) of all the cylinders that were shifted during the simulation. (a) Reference image (b) Crease defect, located in the red rectangle. Figure 8: Crease defect. Figure 9: Crease mask defect. The corresponding segmentation mask is pertinent. Instead of a fine line, it represents an area of influence with soft edges, capturing the entire extent of the deformation. This (image, mask) pair thus constitutes an ideal field truth, accurately simulating the complexity of a real crease defect. 3.2 Quantitative To evaluate the effectiveness of the proposed synthetic data generation framework, a comprehensive dataset consisting of 7,533 synthetically generated images was used. The generated dataset was structured and split on the Roboflow platform to ensure a rigorous evaluation process. For the defect detection and segmentation task, a state-of-the-art Roboflow RF-DETR Instance Segmentation (Large) architecture[15] was deployed. The model was trained using the synthetic samples to evaluate how successfully the generated annotations and defect features could transfer to robust industrial vision models. Testing was strictly performed on an independent, real-world test set consisting of authentic defect images captured directly from the production line during live manufacturing operations. Model Type Precision Recall F1-Score mAP@50 RF-DETR (Large) 85.6% 78.3% 81.7% 80.9% Table 1: Performance metrics of the RF-DETR Large model trained on synthetic data The defective image in Figure 8(b) obtained by applying Algorithm 5 to the image in Figure 8(a), does not simply show a single line, but presents a convincing geometric distortion (see inside the red rectangle) where the patterns underneath are visibly pinched along a natural, non-perfectly straight trajectory. This distortion is enhanced by subtle photometric effects of light and shadow that give the defect a sense of physical volume. The qualitative performance of the framework is further substantiated in Fig. 11, which illustrates a representative inference result on a real-world printing line defect. The model successfully detects and segments the boundary anomalies with high confidence, visually confirming the high precision metric of 85.6% obtained during the testing phase. (a) Real production line or streak defect (b) Synthetically generated line or streak defect Figure 10: Visual samples from the evaluation dataset: (a) a real printing streak defect image captured directly from the live production line, and (b) a synthetic streak sample generated by the proposed framework to train the RF-DETR model. Figure 11: Inference sample of the RF-DETR model evaluated on a real production streak defect. The visualization demonstrates successful instance segmentation and bounding box regression, contributing to the overall test precision of 85.6%. 4 Discussion The results of our synthetic data generation framework, illustrated by simulations of misregistration, crease, streak, and fisheye artifacts, demonstrate the ability of our approach to create a rich, varied, and high-fidelity dataset. Analysis of these simulations shows several key points that validate our methodology. Our main objective was not only to create visually realistic defects, but to simulate the physical signature of each anomaly. The crease simulation, for example, does not simply add a line; it applies a nonlinear geometric deformation that pinches the underlying patterns, mimicking the actual stretching of the substrate. Similarly, the simulation of misregistration does not simply move blocks of color, but generates semi-transparent ink fringes on the precise contours of the shapes, which correspond to the effect of imperfect cylinder overlap. This approach, based on modeling physical causes, ensures that the training data exposes the AI model to complex and realistic characteristics, far beyond simple artificial artifacts. The quality of simulations, in particular for misregistration defects, is based on the use of advanced analysis tools as an intermediate step. By using a structured edge detection model to identify the skeleton of patterns and a CMYK space decomposition to isolate color areas, we ensure that defects are applied consistently with the underlying pattern. A cyan color fringe will only appear on the edges of a shape containing cyan. This intelligence upstream is crucial: it avoids the generation of impossible defects and enhances the credibility of the dataset. One of the most significant results of our work is the simultaneous generation of perfect segmentation masks. As the figures show, these masks are not simple approximations. The mask of a fold captures its Gaussian influence area, that of a shift delimits the exact shape of the fringe, and that of a fisheye represents the crater. This pixel-level accuracy, achieved without any manual annotation costs, represents a major strategic advantage. Not only does it enable us to bypass the main bottleneck in computer vision projects, but it also provides the model with ground truth of a quality that cannot be achieved by manual means, which is a prerequisite for achieving high performance in segmentation. By configuring each simulation function, our framework gives us complete control over the diversity of defects generated. We can create subtle, barely visible defects as well as very pronounced ones. We can simulate misalignments on a single cylinder or on several cylinders simultaneously. This ability to generate a variety of scenarios, including extreme cases rarely seen in production, is essential for training a robust model capable of generalizing to unforeseen situations. The experimental results validate the industrial viability of the proposed framework for automating quality control in rotogravure printing. Achieving a Precision of 85.6% under strict industry-standard settings proves that the synthetic images generated by our framework provide realistic textures and bounding regions. This high precision minimizes false positives, which is crucial in real-world printing lines to avoid unnecessary machine stops. Furthermore, the model reached an mAP@50 of 80.9% and an F1-Score of 81.7%. This robust performance is particularly significant considering that the RF-DETR model was trained entirely on synthetic data and evaluated on a distinct test set. The Recall of 78.3% indicates that the network successfully learned the diverse geometric variations and color anomalies of printing defects without suffering from severe overfitting. These outcomes confirm that the 7533 synthetically generated samples successfully bridge the reality gap in industrial vision, offering a zero-cost, rapid-deployment solution to bypass the data scarcity bottleneck in smart manufacturing. 5 Conclusion In this paper, we have presented a comprehensive framework for generating synthetic data, designed to solve the fundamental problem of the scarcity and cost of collecting labeled data for quality control in rotogravure printing. Faced with the difficulty of acquiring examples of real defects and the constant variability of patterns, we have demonstrated that a simulation-based approach is a viable and effective solution that provides a basis for the application of deep learning(computer vision). This work is a robust methodology for modeling the physical signature of a wide range of printing defects. By simulating complex features such as geometric distortion of creases, color fringing from misregistration, splashes, or the texture of streaks, our framework automatically generates defective images and their corresponding segmentation masks(if we want to train a segmentation model) with pixel-level accuracy. The generated datasets can also be adapted to alternative vision models, such as YOLO and RT-DETR. The proposed approach enables the low-cost generation of realistic datasets for training computer vision systems. This facilitates the deployment of AI-based quality control solutions in sectors such as packaging, decoration, or printed electronics, where precision, productivity, and defect prevention are essential. This study simplifies the modeling of the roll-to-roll printing system for defect modeling. In practice, this type of machine includes a complex set of cylinders, scrapers, motors, and tension mechanisms, which interact to ensure precise and uniform ink deposition [24],[16],[8]. Current work focuses on ink deposition, the origin of defects, and the designs found on each cylinder, but does not take into consideration their kinematic parameters, motor speed, or film tension. These results account for the 80.9% mAP50 accuracy rate achieved by the proposed RT-DETR model on the synthetic dataset. The integration of these factors could be explored in future work. Consequently, our future work will focus on utilizing this synthetic dataset to train and validate a state-of-the-art segmentation model, specifically YOLOv8-seg. This model will subsequently be deployed in real-world production environments on resource-constrained embedded systems, such as Raspberry Pi and NVIDIA Jetson Orin Nano, for automated quality control of print defects in high-speed rotogravure processes. References [1] H. M. Ahmad and A. Rahimi (2022) Deep learning methods for object detection in smart manufacturing: a survey. Journal of Manufacturing Systems 64, p. 181–196. Cited by: §1. [2] G. Bertasius, J. Shi, and L. Torresani (2015) DeepEdge: a multi-scale bifurcated deep network for top-down contour detection. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), p. 4380–4389. Cited by: §2.2.5. [3] J. Chen, Y. Lu, Q. Yu, X. Luo, E. Adeli, Y. Wang, L. Lu, A. L. Yuille, and Y. Zhou (2021) TransUNet: transformers make strong encoders for medical image segmentation. arXiv preprint arXiv:2102.04306. Cited by: §1. [4] L. Chen, G. Papandreou, F. Schroff, and H. Adam (2017) Rethinking atrous convolution for semantic image segmentation. arXiv preprint arXiv:1706.05587. Cited by: §1. [5] W. Chen, X. Sun, W. Chen, G. Xie, S. Chen, and J. Wang (2022) Nonlinear web tension control of a roll-to-roll printed electronics system. Precision Engineering 76, p. 88–94. Cited by: §2.2. [6] Z. Chen, L. Shan, and T. Zhang (2025) Hybrid modeling and compensation register control for the speed-up phase of roll-to-roll (R2R) gravure printing presses. ISA Transactions. Note: In press Cited by: §2.2. [7] A. Hatamizadeh, Y. Tang, V. Nath, D. Yang, A. Myronenko, B. Landman, H. R. Roth, and D. Xu (2022) UNETR: transformers for 3D medical image segmentation. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision (WACV), p. 574–584. Cited by: §1. [8] C. Kang and B. Lee (2008) Design parameter analysis of a roll-to-roll printing machine. IFAC Proceedings Volumes 41 (2), p. 11883–11888. Cited by: §5. [9] H. Kang and R. R. Baumann (2014) Mathematical modeling and simulations for machine directional register in hybrid roll-to-roll printing systems. International Journal of Precision Engineering and Manufacturing 15 (10), p. 2109–2116. Cited by: §2.2. [10] Y. Lee, M. Kim, J. Noh, G. Cho, and C. Lee (2024) Data-driven fault detection and positioning of eccentric rolls in roll-to-roll systems using wrap angle and sensor proximity. Results in Engineering 24, p. 103629. Cited by: §2.2. [11] D. Li, S. Jabbireddy, Y. Zhang, C. Metzler, and A. Varshney (2024) Instant-SFH: non-iterative sparse Fourier holograms using Perlin noise. Sensors 24 (22), p. 7358. Cited by: item 3. [12] L. W. T. Ng, N. G. An, L. Yang, Y. Zhou, D. W. Chang, J. Kim, L. J. Sutherland, T. Hasan, M. Gao, and D. Vak (2024) A printing-inspired digital twin for the self-driving, high-throughput, closed-loop optimization of roll-to-roll printed photovoltaics. Cell Reports Physical Science 5 (6), p. 102038. Cited by: §2.1. [13] J. Noh, D. Yeom, C. Lim, H. Cha, J. Han, J. Kim, Y. Park, V. Subramanian, and G. Cho (2010) Scalability of roll-to-roll gravure-printed electrodes on plastic foils. IEEE Transactions on Electronics Packaging Manufacturing 33 (4), p. 275–283. Cited by: §2. [14] J. Noh, D. Yeom, C. Lim, H. Cha, J. Han, J. Kim, Y. Park, V. Subramanian, and G. Cho (2010) Scalability of roll-to-roll gravure-printed electrodes on plastic foils. IEEE Transactions on Electronics Packaging Manufacturing 33 (4), p. 275–283. Cited by: item 4. [15] I. Robinson, P. Robicheaux, M. Popov, D. Ramanan, and N. Peri (2025) RF-DETR: neural architecture search for real-time detection transformers. arXiv preprint arXiv:2511.09554. Cited by: §3.2. [16] A. Seshadri, P. R. Pagilla, and J. E. Lynch (2013) Modeling print registration in roll-to-roll printing presses. Journal of Dynamic Systems, Measurement, and Control 135 (3), p. 031016. Cited by: §5. [17] N. G. Shankar, N. Ravi, and Z. W. Zhong (2009) A real-time print-defect detection system for web offset printing. Measurement 42 (5), p. 645–652. Cited by: §1. [18] W. Shen, X. Wang, Y. Wang, X. Bai, and Z. Zhang (2015) DeepContour: a deep convolutional feature learned by positive-sharing loss for contour detection. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), p. 3982–3991. Cited by: §2.2.5. [19] M. Urgo, W. Terkaj, and G. Simonetti (2024) Monitoring manufacturing systems using AI: a method based on a digital factory twin to train CNNs on synthetic data. CIRP Journal of Manufacturing Science and Technology 50, p. 249–268. Cited by: §2.1. [20] A. C. Valente, C. Wada, D. Neves, D. Neves, F. V. M. Perez, G. A. S. Megeto, M. H. Cascone, O. Gomes, and Q. Lin (2020) Print defect mapping with semantic segmentation. In Proceedings of the IEEE Winter Conference on Applications of Computer Vision (WACV), p. 3540–3548. Cited by: §2.1. [21] J. Villalba-Diez, D. Schmidt, R. Gevers, J. Ordieres-Meré, M. Buchwitz, and W. Wellbrock (2019) Deep learning for industrial computer vision quality control in the printing industry 4.0. Sensors 19 (18), p. 3987. Cited by: §1. [22] W. Wu, W. Ma, X. Wu, and X. Chen (2026) Weakly supervised learning for 3D mesh segmentation via pixel-level labeling. Computer-Aided Design 199, p. 104109. External Links: ISSN 0010-4485, Document Cited by: §1. [23] T. Zhang, Y. Zheng, and Z. Chen (2024) Model based precise register control method for shaft-driven roll-to-roll (R2R) systems. Control Engineering Practice 147, p. 105937. Cited by: §2.2. [24] Q. Zhao, N. Hong, D. Chen, and W. Li (2022) A dynamic system model for roll-to-roll dry transfer of two-dimensional materials and printed electronics. Journal of Dynamic Systems, Measurement, and Control 144 (7), p. 071004. Cited by: §5.