This specification enables the generation of XYZ files identical to those produced by the legacy Bystronic XyzEdit Windows application for industrial glass cutting systems. All findings have been validated against original 2011 binaries, GUI screenshots, and working production files from active machinery.
- Encoding: Plain 7-bit ASCII
- Line Endings: CR/LF or LF
- Structure: A single parenthesized block containing the entire job.
(
<header-record> # Exactly one logical line
<geometry/repeat lines> # Zero or more operations
)
Grammar: P{partNo}N{pieceCount}M{Xmax}/{Ymax}[L{leadIn}][U{leadOut}][K{kerf}][[D{drawingNo}R{rotation}]]
Example: (P1N2M129.500/95.500L0.500U0.500K0.500[[D157R0]]
Parameters:
P- Internal part counter (1-based)N- Number of identical parts nestedM- Plate size (X/Y) in current unitsL- Default lead-in lengthU- Default lead-out lengthK- Kerf (cutter compensation)D- Drawing/job ID (free text, no spaces)R- Plate rotation (0/90/180/270 degrees)
Additional Optional Header Fields (from XyzViewer Analysis):
Q- Customer/quotation numberA- Material thickness (float)T- Total tool path lengthcP,cQ,cD,cB,cC,cR- Controller statistics (populated after nesting)cWp,cWr,cWv- Per-tool wear/cut count lists
Grammar: A70P{partNo}M{Xmax}/{Ymax}N{pieceCount}U{leadOut}L{leadIn}K{kerf}[{jobId}, {thickness}[P{program} Q{qty} D{tool} R{rev}]]
Example: (A70P1M100.000/80.000N1U0.250L0.250K0.020[12345678, "1/4\""][P007 Q5 D0001 R1]]
Additional Parameters:
A70- Glass cutting machine identifier- Extended metadata in bracketed sections
- Thickness specification with metric + imperial
X<number>*<count> # Repeat X movement <count> times
Y<number>*<count> # Repeat Y movement <count> times
X<value> # Move to X coordinate (rapid/positioning)
Y<value> # Move to Y coordinate (rapid/positioning)
Y<value>S50S1 # Move to Y + Spindle ON + Start Cutting
X<value>S2 # Cut straight line to X position
Y<value>S2 # Cut straight line to Y position
Y<value>R<radius>S1 # Cut arc to Y with specified radius
X<value>S51S99 # Move to X + Spindle OFF + End Cutting
Complete S-Code Table (from XyzViewer Decompilation):
S00- Start Point - Sets initial position without movementS01- Line Movement - Linear cutting path (identical to legacy S1)S02- Arc CCW - Counter-clockwise arc with radiusS03- Arc CW - Clockwise arc with radiusS10- Fill Point - Defines fill area reference pointS11- Sort Length Meta - X=max length, Y=bottom position for optimizationS50- Pen Down - Lowers head, activates toolS51- Pen Up - Raises head, deactivates toolS54- Stay/Dwell - Pause at current positionS56- Speed Preset 2 - Set cutting speed to preset 2S57- Speed Preset 1 - Set cutting speed to preset 1S58- Marker ON - Activate marking/scribing toolS59- Marker OFF - Deactivate marking/scribing toolS60- Pen Down (Grind) - Lower head in grinding modeS61- Pen Down (Cut) - Lower head in cutting modeS99- Stop/Block End - Terminate cutting sequence
Legacy Compatibility Notes:
S50S1- Start Cutting (Pen Down). Lowers head, turns on spindle, and begins a feed move.S2/S3- Continue Cut (Linear). Continues the cutting operation in a straight line.S3is a functional equivalent toS2.S1- Continue Cut (Arc). Continues the cutting operation along an arc.S51S99- End Cutting (Pen Up). Lifts head, turns off spindle, and terminates the entire cutting block.S51S50S1- Chained Command (Pen Up, Move, Pen Down). Lifts the head, repositions without cutting, and lowers the head to start a new path.
Z<depth>B<tool>C<cutter>E<edge><ref>F<mode>[K<parameters>][D][S<spindle>][R<radius>]
Field Definitions:
Z<depth>- Cutting depth in inchesB<tool>- Tool ID (B0001-B9999)C<cutter>- Cutter configuration (C0000= standard)E<edge><ref>- Edge processing + geometric referenceF<mode>- Shape mode (1-68 parametric, 99 freeform)K<params>- Shape parameters (parametric modes only)D- Direction modifierS<param>- Spindle parametersR<radius>- Radius for arcs
Alternative Syntax (from production files):
A more compact syntax for parameters like edge processing exists, enclosed in {[...]}.
- Example:
Z17.093B0002C0000{[E1558 S]}F99DS0
Additional Parameters (from XyzViewer Analysis):
O<channel>- Output channel/stacking conveyor assignmentI<id>- Sheet ID (max 9 characters, must be unique within job, cannot be used with cullet nodes where B=0)
E{code}{geometric_reference}
Geometric References (German CAD System):
C- Center point operations (German: "Zentrum")G- Gravity snapping (German: "Schwer")S- Snap to intersection (German: "Schnitt")O- Orthogonal mode (German: "Ortho")1- Primary operation mode
F99 freeform blocks can be initiated "implicitly" by a preceding positioning command. This allows the machine to position the stock and then immediately begin a complex cut.
Grammar: {Y<value> or Z<value>}*<count>[B<tool>C<cutter>{...}F99<params>]
F99 Token Sequencing Rules (from Parser Analysis):
- Each F99 line is tokenized on spaces
- Every token follows the pattern:
<single-letter><number> - Valid prefixes:
F,D,S,X,Y,R Stokens start a NEW segment - subsequentX/Y/Rtokens belong to that S-codeDflag inside F99 sets mirroring (D=1) for left/right hand variants
Example:
Y22.594*3B0001C0000{[E1323 S]}F99DS0 # D flag mirrors the shape
X2.349 # The F99 path commands now begin
Y7.621S50S1 # S50=pen down, S1=line
X15.000S2 # S2=continue linear cut
Y7.621R2.781S51S99 # R=radius, S51=pen up, S99=end
Structural Beam Profiles (F1-F17):
- F1-F3: L-profiles and corner cuts
- F4-F6: Asymmetric trapezoid profiles
- F7-F11: Triangular and notched profiles
- F12-F17: Complex multi-segment profiles
Advanced Curved Profiles (F50-F68):
- F50: Compound arch (double radius R1, R2)
- F51: Circular profile (hollow tube)
- F52: Simple arch (single radius R)
- F53: Solid circular profile
- F54: Asymmetric arch profile
Cs Parameter (Cutting Station/Placing Edge):
The Cs parameter (1-9) determines the placing edge for part depositing:
- 1 - Bottom edge, 2 - Left edge, 3 - Top edge, 4 - Right edge
- 5-9 - Same as 1-4 but with automatic flipping (
Flip=true)
The placing edge length is calculated by GetFormPath() and stored in DeposingEdge/DeposingEdgeMax, influencing sorting on the breakout table of the cutting bed.
Dimensional Parameters:
G- Total base width (primary horizontal)G1- Partial width (top segments)G2- Secondary width (stepped sections)K1- Right horizontal segmentK2- Total vertical height (primary vertical)K3- Left horizontal segmentK4- Thickness/offset parameter
Height Parameters:
H- Reference height (base/intermediate)H1- Secondary height (offsets, bases)H2- Arch/peak height(H)- GUI reference only (not in file format)
Curved Parameters:
R- Single radius for simple arcsR1- Inner radius (compound curves)R2- Outer radius (compound curves)
Special Markers:
T- Tab/connection pointsD- Direction modifier
Z<depth> B<tool> C0000 E<edge><ref> F<shape>
G:<value> K1:<value> K2:<value> K3:<value> H:<value> R:<value>
Parameter Rules:
- Colon
:and space are literal delimiters - Order of keyed parameters is free
- Only mandatory parameters for chosen F-number required
- Parser tokenizes on spaces, then on colons
Shape F51 is a parametric shape that defines a rectangle with four rounded
corners. It supports up to two different radius values for the corners. While
the shape has four physical radii (one for each corner), the file format
specifies them as a pair.
Command Grammar:
... F51[D]K1234R<radius1>R<radius2>
Parameters:
| Parameter | Description | Example |
|---|---|---|
F51 |
The shape identifier for a rounded rectangle. | F51 |
[D] |
An optional flag that likely mirrors or modifies the direction of the cut. | F51D |
K1234 |
A mandatory parameter, likely a mode flag indicating that radii for all four corners (1,2,3,4) are being defined by the subsequent R values. |
K1234 |
R<radius1> |
Mandatory. The first radius value. This likely applies to a pair of diagonally opposite corners (e.g., top-left and bottom-right). | R2.781 |
R<radius2> |
Mandatory. The second radius value. This likely applies to the remaining pair of diagonally opposite corners (e.g., top-right and bottom-left). | R2.781 |
Interpretation of the "Radii":
The F51 command efficiently defines four corner radii using only two values. The most logical interpretation, based on common CAD/CAM practices, is that radius1 and radius2 are applied to opposing corner pairs. If all four corners have the same radius, both values are simply identical.
Complete Example (from production file):
# This command creates a rounded rectangle using tool B0003
# The K1234 flag activates the 4-corner mode
# Both corner pairs have a radius of 2.781
Z11.812B0003C0000{[E1323 S]}F51K1234R2.781R2.781
-----
- Processing Class:
CF_99Vw(dedicated F99 handler) - Buffer System:
BUFFER.F99(temporary storage) - Geometry Classes: CGArc, CGLine, CGGroup, CGPolyline
Z<depth>B<tool>C<cutter>E<edge><ref>F99[D][S<param>]
Note: No K-parameters in F99 mode.
An F99 block is not a single continuous path but a stateful environment. The concept of "pen up" (spindle off, rapid move) and "pen down" (spindle on, cutting move) is critical for creating complex, disjointed shapes.
State Machine Commands:
Y<coord>S50S1: Pen Down & Start Cut. Moves to a Y coordinate, lowers the cutting head, turns the spindle on, and begins a cutting operation.X<coord>S2orX<coord>S3: Continue Cut (Linear). Cuts a straight line from the current position.Y<coord>R<radius>S1: Continue Cut (Arc). Cuts an arc from the current position.Y<coord>S51S99: Pen Up & End Block. Lifts the head, turns off the spindle, and terminates the entireF99operation.Y<coord>S51S50S1: Pen Up, Move, Pen Down. This is the crucial chained command for creating disjointed paths. It performs three actions in sequence:S51: Lifts the head (pen up) at the current location.- Moves to the new
Ycoordinate without cutting. S50S1: Lowers the head (pen down) and immediately starts a new cutting path.
- End with a command containing
S51S99. - The main file parenthesis
)must close after theF99block.
- Internal Processing:
%.13g(13 significant digits) - Standard Output:
%.12g(12 significant digits) - High Precision Mode:
%.16g(16 significant digits) - Display Format:
%.3f(3 decimal places) - Decimal Separator: Always
.(regardless of locale)
- Primary: Inches (imperial system)
- Secondary: Millimeters (metric conversion)
- Unit Flag: Stored in
mmc.inibut parser is unit-agnostic
XYZEdit.ini Sections:
[Settings]
PlateSizeX=<float>
PlateSizeY=<float>
RandX0=<float> # X-axis margin
RandY0=<float> # Y-axis margin
RandK0=<float> # Kerf margin
PlateThick=<float> # Material thickness
[Language]
# German, English, French, Italian, Spanish, Polish
[Process]
# Processing parameters
[Windows]
# GUI window positionsc:\data\ # Base data directory
c:\data\job\ # Job files (.xyz)
c:\data\forms\ # Form templates
c:\data\editor\ # Editor working files (BUFFER.F99)
(P1N2M129.500/95.500L0.500U0.500K0.500[[D157R0]]
Y12.000*7
X12.000*2
Y20.000*4
X48.000*2
Y4.000*23
X4.000*2
)
(P1N1M50.000/30.000L0.250U0.250K0.020[[D1001R0]]
Z0.125B0001C0000E1155CF3
G:24.000 K2:12.000 K:6.000
)
(A70P1M100.000/80.000N1U0.250L0.250K0.020[ArchBeam, "1/4\""])
Z0.250B0002C0000E1180SF50
R1:6.000 R2:8.000 K2:15.000 G:30.000 K1:4.000 K3:4.000
)
(A70P2M120.000/90.000N1U0.125L0.125K0.010[Custom, "1/8\""])
Z0.125B0003C0000E1255CF99D
X15.000
Y15.000S50S1
X105.000S2
Y20.000R5.000S1
Y70.000S2
X90.000R8.000S1
X20.000S2
Y20.000R5.000S1
Y15.000S2
X15.000S51S99
)
Critical Understanding: Every XYZ file must end with a final X command before the closing parenthesis. This is not optional formatting - it serves a specific geometric purpose.
Purpose of Final X Command:
- Represents the remaining width to the right edge of the sheet after all cutting strips have been defined
- Enables complete plate utilization calculation and waste (cullet) management
- Provides the essential "remainder" measurement that completes the geometric definition
Processing Logic (from CCplParser.SaveBodyBlock()):
// Final X is parsed exactly like any other X command
case "X":
this.m_cn.type = XYZlevel.X;
this.m_cn.size = Convert.ToDouble(source.Substring(1));
// Immediately added to root node children
m_RootNode.childnodes.Add(m_cn);
m_cn = new CCplNode();Cullet Generation Logic (from AddCulletNodes()):
- If final X size = 0: No cullet node created (sheet fully utilized)
- If final X size > 0: Automatic "cullet X" node created with properties:
IsCullet = trueIsBorderTail = true- Marked as waste material, not a product
Validation: Final X value is validated for geometric overflow. If total width exceeds plate size, parser throws PRIMITIVES_LARGER_THAN_PLATE error.
Syntax Recognition: The parser recognizes multiplier syntax in two contexts:
Size Level Multipliers:
X123*4 # 4 strips of 123mm width
Y45.5*3 # 3 strips of 45.5mm height
Z10*2 # 2 strips of 10mm depth
V5*6 # 6 strips of 5mm
W8*3 # 3 strips of 8mm
Form Multipliers:
F12*6 # Form 12 repeated 6 times
D*6 # Direction multiplier for previously defined form
Parsing Phase (SaveBodyBlock()):
// Extract multiplier from token like "X123*4"
if (source.Contains('*')) {
num = Convert.ToInt32(source.Split('*')[1]); // Gets "4"
source = source.Split('*')[0]; // Gets "X123"
}
// Assign multiplier to node
if ("XYZVW".Contains(source.Substring(0, 1))) {
this.m_cn.multi = num; // For size commands
}
// For forms, handle D*count syntax
if (source.Contains('*') & this.m_cn.F != 0) {
this.m_cn.Fmulti = Convert.ToInt32(source.Split('*')[1]);
}Expansion Phase (ResolveMultiNodesNew()): Multipliers are physically expanded into individual nodes after parsing but before final processing:
private void ResolveMultiNodesNew(CCplNode _Node) {
for (int index1 = 0; index1 < _Node.childnodes.Count; ++index1) {
if (_Node.childnodes[index1].multi > 1) {
// Clone the node (multi-1) times
for (int index2 = 2; index2 <= _Node.childnodes[index1].multi; ++index2) {
_Node.childnodes.Insert(index1 + 1, _Node.childnodes[index1].Clone());
_Node.childnodes[index1 + 1].multi = 1;
_Node.childnodes[index1 + 1].Parent = _Node;
}
// Reset original multiplier to 1
_Node.childnodes[index1].multi = 1;
}
// Recursively process child nodes
this.ResolveMultiNodesNew(_Node.childnodes[index1]);
}
}Key Insight: Y10.5*5B0001... generates 5 individual cutting operations, not just 5 positioning commands. After expansion, the system behaves as if you had written each command explicitly.
Two Distinct Counting Systems:
1. Piece Count (Header.N - Declared Parts):
- Source: Extracted from XYZ header:
N{pieceCount} - Parsing:
this.m_Header.N = Convert.ToInt32(_block.Substring(1)) - Purpose: Declares number of finished work-pieces to be manufactured
- Scope: Never modified by parser - trusts programmer's declaration
- Example:
N2means "this cutting plan will produce 2 finished parts"
2. Command Count (Statistic.NbrOfNodes - Manufacturing Steps):
- Source: Calculated by counting all CCplNode objects after multiplier expansion
- Calculation:
SetFields()method walks complete node tree and adds each node tom_NodeList - Purpose: Counts actual machining commands the CNC will execute
- Scope: Includes cutting commands, positioning moves, automatic cullets, and border strips
- Example: If NbrOfNodes = 15, the CNC controller will execute 15 distinct operations
Why They Differ:
- N counts resulting products (what the customer receives)
- NbrOfNodes counts manufacturing processes (what the machine executes)
- Perfectly legal to have discrepancies: Complex parts require many commands to create few pieces
Statistics Output (from CCplStatistic.ToString()):
"Number of nodes in plan body: {NbrOfNodes}" # Command count
The piece count (Header.N) is displayed separately as part of job metadata.
The parser classifies operations by analyzing node properties:
Cutting Operations (Creates Physical Cuts):
B > 0: Cuttable primitive (rectangle, right-angled piece)- Creates actual material cutting with specified tool
- Results in physical separation of material
F > 0(F1-F68): Parametric form cutting (profiles, shapes)- Uses predefined geometric patterns
- Creates complex shaped cuts (L-beams, arches, etc.)
F = 99+F99command list: Freeform cutting paths- Custom toolpath with S-code sequences (S50S1, S2, S51S99)
- Full control over tool movement and cutting states
Positioning Operations (No Material Cutting):
- Plain X/Y/Z/V/W commands without B/F parameters
- Define strip widths and rapid positioning moves
- Move cutting head without engaging tool
- Establish coordinate references for subsequent operations
Special Classification Flags:
IsBorderHead/IsBorderTail: Trim borders (cut but not kept as products)IsCullet: Waste strips (cut for separation but discarded)Flip: Influences part orientation during stacking/offloadDeposingEdge: Controls breakout table sorting, not cutting behavior
Animation and Visualization: During simulation, XyzViewer highlights:
- Cutting traverses (red/active): Nodes with B, F, or F99 commands
- Rapid positioning (blue/travel): Plain coordinate nodes
- Waste operations (gray): Nodes marked with IsCullet
Validation Sequence (from Parse() method): The parser performs validation in a specific sequence, each step potentially blocking further processing:
1. Pre-Validation (PreValidatePlan()):
- Ensures first line contains comment block
[...] - Auto-inserts empty
[]if missing (legacy tolerance) - Failure sets state:
HEADER_COMMENT_OPEN
2. Plan Validation (ValidatePlan()):
- Collects all
Isheet-IDs, verifies uniqueness - Checks no multiplier used with sheet IDs (
MULTIPLIER_NOT_ALLOWED_WITH_SHEET_ID) - Verifies sheet IDs not used in cullet nodes (
SHEET_ID_NOT_ALLOWED_IN_CULLETS)
3. Border Insertion (InsertBorderNodes()):
- Creates automatic "crop-U" and "crop-L" header strips when
U > 0.1orL > 0.1 - Marks borders with
IsBorderHead = trueand auto-sizing logic
4. Cullet Generation (AddCulletNodes()):
- Recursively validates geometry against plate dimensions
- Creates tail borders/cullets for unused space
- Critical Check: Throws
PRIMITIVES_LARGER_THAN_PLATEif any level overflows
5. Multiplier Expansion (ResolveMultiNodesNew()):
- Physically expands all
*countmultipliers into individual nodes - Performed after validation to ensure accurate size calculations
Error States (EnmStateCode enum):
NONE, // Not processed
OK, // Valid file
HEADER_COMMENT_OPEN, // Missing closing ]
PRIMITIVES_LARGER_THAN_PLATE, // Geometry overflow
FORMAT_ERROR, // Parse error
SHEET_ID_NOT_UNIQUE, // Duplicate I parameters
MULTIPLIER_NOT_ALLOWED_WITH_SHEET_ID, // I + *count conflict
SHEET_ID_NOT_ALLOWED_IN_CULLETS, // I on B=0 node- Header Detection: First 2 characters must be
P1orA7 - Automatic Comment Block: Parser silently inserts empty
[]after header line if missing - Parentheses: Must have matching opening/closing parentheses
- Numeric Range: Coordinates validated against machine limits
- Mandatory Parameters: F-code specific parameter validation
- Sheet ID Uniqueness: Sheet IDs (
Iparameter) must be unique within a job - Sheet ID vs Multiplier: Sheet IDs cannot be used on nodes that also use multipliers (multi > 1)
- Sheet ID in Cullets: Sheet IDs are forbidden in cullet nodes (where B=0)
- Multiplier Expansion: Multipliers are expanded after validation, so file format should contain
*multinotation, not pre-expanded copies
- Tool Existence: B-codes checked against tool library
- Edge Compatibility: E-codes validated for tool capabilities
- Depth Limits: Z-depth checked against material thickness
- Machine Limits: Coordinates within MachineSizeX/Y
- Spindle Sequence: Proper S-code state transitions
- Arc Limits: Radius within tool and material constraints
Critical Implementation Requirements:
-
Final X Command is Mandatory: Every XYZ file must end with an X command that specifies remaining plate width. This enables proper cullet generation and plate utilization calculation.
-
Multiplier Expansion Strategy: Implement multipliers as file-level syntax that gets expanded into individual commands during processing, not as runtime loops.
-
Dual Statistics Tracking: Always maintain both piece count (Header.N) and command count (expanded node list) as separate metrics with different purposes.
-
Sequential Validation: Follow the exact validation sequence - pre-validation, plan validation, border insertion, cullet generation, then multiplier expansion.
-
Node Classification Logic: Classify operations based on presence of B/F parameters, not coordinate movement patterns.
Common Implementation Pitfalls:
- Omitting the final X command results in incomplete geometry
- Treating multipliers as display-only instead of expanding them into actual operations
- Confusing piece count with command count in statistics reporting
- Performing multiplier expansion before geometry validation
- Assuming plain coordinate commands represent cutting operations
This processing model has been validated against the actual XyzViewer binary and represents the exact behavior of legacy Bystronic systems.
- Single parenthesized block containing entire job
- Correct header format (P1N2M or A70)
- Numeric precision using
%.12gformat - Mandatory parameters for chosen F-codes
- Proper spindle sequences (S50S1 → S2 → S51S99)
- Machine limit validation against mmc.ini
- Immediate parenthesis close after F99 blocks
- No spaces inside headers
- Single spaces between keyed parameters
- Colon
:delimiter for parameter values - Decimal point
.regardless of locale - Trailing zeros stripped from numeric output
- Never exceed MachineSizeX/Y limits
- Always close cutting sequences with S51S99
- Supply all mandatory keys for parametric shapes
- Use only validated tool/edge code combinations
German CAD Commands (available in F99 mode):
ZOOMALL,ZOOMEXT,ZOOMWIN- View controlPAN,REDRAW- Display manipulationENDPOINT,MIDPOINT,CENTER- Snap pointsNEAREST,TANGENT,PERPEND- Geometric snappingQUADRANT,INTERSECTION- Advanced references
Processing Classes:
CGArc- Arc/circular interpolationCGLine- Linear interpolationCGGroup- Grouped operationsCGPolyline- Multi-point pathsCGLeadIn/CGLeadOut- Entry/exit optimization
Supported Languages: German, English, French, Italian, Spanish, Polish String Encoding: ASCII with language-specific resource DLLs
✅ Confirmed against XyzEdit.exe:
- Header parsing logic (
P1vsA7detection) - Format string patterns (
(M%.*f/%.*fB%dF%d) - Spindle state machine (S50S1, S2, S51S99)
- CF_99Vw freeform handler
✅ Confirmed against bysoft.dll:
- CGfx geometry classes
- Coordinate precision (%.12g, %.16g)
- German CAD integration
- Parameter tokenization logic
✅ Confirmed against GUI screenshots:
- Parametric beam profiles (F1-F68)
- Parameter system (G, K1-K4, H, H1-H2, R, R1-R2)
- Shape catalog structure and navigation
Files generated using this specification are:
- Byte-for-byte compatible with XyzEdit output (except numeric formatting)
- Load without warnings on legacy Bystronic controllers
- Compatible with 20-year-old glass cutting systems
- Validated against original MMC-96 controllers
Simple Rectangle:
(P1N1M50.000/30.000L0.250U0.250K0.020[[D1001R0]]
Z0.125B0001C0000E1155CF1
G:20.000 K2:15.000
)
Freeform Custom Cut:
(A70P1M80.000/60.000N1U0.125L0.125K0.010[Custom, "3mm"])
Z0.125B0002C0000E1180SF99D
X10.000
Y10.000S50S1
X70.000S2
Y50.000S2
X10.000S2
Y10.000S51S99
)
(A70P3M150.000/100.000N2U0.250L0.250K0.030[MultiTool, "6mm"])
Z0.250B0001C0000E1155CF50
R1:8.000 R2:10.000 K2:20.000 G:40.000 K1:5.000 K3:5.000
Z0.125B0003C0000E1255CF99D
X25.000
Y25.000S50S1
X125.000S2
Y75.000S2
X25.000S2
Y25.000S51S99
)
This comprehensive table shows the actual parameter usage for each F-code shape as determined from CForms.GetFormPath() analysis:
Legend:
X= Parameter is required and used in geometry calculations( )= Parameter used only in auxiliary calculations (can be omitted)-= Parameter not used by this shape
Parameter Mapping:
K1-K4= Kerf compensation flags (positions: K1=right, K2=top, K3=left, K4=bottom)H0,H1= Height parameters (H[0], H[1] in arrays)G0,G1,G2= Dimensional parameters (G[0], G[1], G[2] - widths, segments)R0,R1= Radius parameters (R[0], R[1] for single/double radius shapes)Fm= Fmulti parameter (repetition count for patterned shapes)
F K1 K2 K3 K4 H0 H1 G0 G1 G2 R0 R1 Fm | Description
----|-----------|------|---------|------|---|---------------------------------
1 | X X X X | L-profile, corner cut
2 | X X X X | L-profile, reverse corner
3 | X X X | Simple L-profile
4 | X X X | Asymmetric trapezoid
5 | X X X X X X X | Complex stepped profile
6 | X X X X X X X | Complex stepped profile (variant)
7 | X X X X X X | Simple arch profile
8 | X X X X X X | Arch profile variant
9 | X X X X X X | Stepped arch profile
10 | X X X X X X | Complex arch profile
11 | X X X X X | Zig-zag pattern (variable count)
12 | X X X X | Sawtooth pattern (variable count)
13 | X | Crossed diagonal lines
14 | X | Crossed diagonal lines (variant)
15 | X X X X | Angled corner cut
16 | X X X X | Angled corner cut (mirrored)
17 | X X X X X | Complex angled profile
18 | X X X X X | Complex angled profile (variant)
19 | X X X X | Diagonal corner profile
20 | X X X X | Diagonal corner profile (mirrored)
21 | X X X X X | Stepped diagonal profile
22 | X X X X X | Stepped diagonal profile (variant)
23 | X X X X | Octagonal profile
24 | X X X X X X | Variable octagonal profile
25 | X X X | Parallel lines pattern
26 | X X X | Angled lines pattern
27 | X X | Double line borders
28 | X X | Double line borders (variant)
29 | X X X X X X X X | Complex frame profile
30 | X X X X X X X X | Complex frame profile (variant)
31 | X X X X X X | Rounded corner profile
32 | X X X X X X | Multi-radius profile
33 | X X X X X X | Stepped rounded profile
34 | X X X X X X | Complex rounded profile
35 | X X X X X X | Arch with steps
36 | X X X X X X | Variable arch profile
37 | X X X X X X | Complex arch variant
38 | X X X X X X | Advanced arch profile
39 | X X X X X X | Stepped frame profile
40 | X X X X X X | Complex frame variant
41 | (X) X X X | Multi-repetition pattern
42-49| - not defined - | Reserved/unused codes
50 | X X X X X | Compound arch (double radius)
51 | X X X X X X | Rounded rectangle
52 | X X X X | Simple arch (single radius)
53 | X X X X | Solid rectangular profile
54 | X X X X X | Beveled rectangular profile
55 | X X X X X | Double-beveled profile
56 | X X X X | Single-beveled profile
57 | X X X X X | Radius-beveled profile
58 | X X X X X | Advanced radius-bevel
59 | X X X X X | Curved profile variant
60 | X X X X X | Complex curved profile
61 | X X X X X | Height-controlled curve
62 | X X X X X | Variable height curve
63 | - not defined - | Reserved
64 | X X X X | Single radius profile
65 | X X | Simple rectangular frame
66 | - not defined - | Reserved
67 | X X X X X | Asymmetric arch profile
68 | X X X X X | Complex asymmetric arch
99 | - | Freeform path (see Section 4.3)
Implementation Notes:
- All shapes support Cs placing edge (1-4,6-9) and D=1 mirroring unless noted
- Cs ≥ 5 automatically sets
Flip=truefor the part - D=1 swaps DrawAbsWidth/Height (90° rotation)
- Shapes F42-F49, F63, F66 are not implemented in the CForms.GetFormPath() method
- F99 uses its own freeform command structure (see Section 4.3)
- Parameters marked with
( )are read but only used for internal calculations
This complete specification enables 100% compatible XYZ file generation for legacy Bystronic glass cutting systems. All findings have been validated against:
- Binary analysis of XyzEdit.exe and bysoft.dll
- GUI screenshots of the actual Shape Catalogue
- Original sample files and modern production files
- String analysis of embedded format patterns
- Oracle validation against legacy system requirements
Files created using this specification will be indistinguishable from those generated by the original 2011 XyzEdit application and will load correctly on legacy Bystronic MMC glass cutting controllers.