A NURBS surface editing method, system, and computing device

Through NURBS surface editing in a human-computer collaborative mode, designers and AI work together to achieve efficient NURBS surface modeling, solving the problems of low efficiency in manual modeling and poor controllability in fully automatic modeling, and improving modeling efficiency and editing smoothness.

CN123069472APending Publication Date: 2026-11-10SHENZHEN SHENZHEN CREATION TECHNOLOGY CO LTD
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202610994209.7
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-07-03
Publication Date
2026-11-10

AI Technical Summary

Technical Problem

In existing technologies, during NURBS surface modeling, manual CAD modeling involves a large amount of manual work and is inefficient, making it difficult to balance the accuracy of parametric constraints with the shaping effect of freeform surfaces. On the other hand, fully automatic AI modeling has poor modeling controllability and cannot meet the needs of high-precision customization.

Method used

It adopts a human-machine hierarchical collaborative model, where designers are responsible for multimodal editing input and decision control, and AI automatically completes standardized geometric operations. It integrates parametric constraints and free surface manipulation through a unified anchor point data model, and supports seamless switching between 2D orthogonal editing mode and 3D CV editing mode.

Benefits of technology

It achieves improved efficiency in NURBS surface modeling under the high-level decision-making control of designers, while balancing the accuracy of parametric constraints with the shaping effect of freeform surfaces. It solves the data fragmentation problem in traditional modeling methods and improves editing fluency and controllability.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123069472A_ABST
    Figure CN123069472A_ABST
Patent Text Reader

Abstract

This application provides a NURBS surface editing method, system, and computing device to achieve efficient interactive editing of NURBS curves. The method includes: receiving multimodal editing input for a target NURBS curve; responding to the multimodal editing input, interactively editing the target NURBS curve based on a unified anchor point data model, where the anchor point data model includes anchor point positions, input handles, output handles, and continuity constraints; the interactive editing supports seamless switching between 2D orthogonal editing mode and 3D CV editing mode; under the designer's decision control, an AI agent executes standardized geometric operations corresponding to the interactive editing to obtain the target NURBS curve data; and the target NURBS curve data is rendered and displayed. Thus, under the designer's high-level decision control, efficient interactive editing of curves is achieved by integrating parametric constraints and freeform surface manipulation through a unified anchor point data model.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This application relates to the field of computer technology, and in particular to a NURBS surface editing method, system, and computing device. Background Technology

[0002] In computer-aided design (CAD) surface modeling technology, the modeling process of non-uniform rational B-spline (NURBS) surfaces is mainly achieved through manual CAD modeling mode or fully automatic AI modeling mode. Among them, manual CAD modeling mode requires designers to simultaneously undertake high-end styling decisions and a large number of repetitive and mechanized geometric modeling operations. The modeling process has a large workload, low modeling efficiency, and it is difficult to balance the accuracy of parametric constraints and the shaping effect of freeform surfaces. The fully automatic AI modeling mode completes the entire process of NURBS surface modeling autonomously by AI. Designers cannot intervene in the modeling process, resulting in poor modeling controllability and making it difficult to meet the high-precision and customized industrial design requirements of automotive A-class surfaces. Summary of the Invention

[0003] This application provides a NURBS surface editing method, system, and computing device, which enables efficient interactive editing of NURBS curves by integrating parametric constraints and freeform surface manipulation through a unified anchor point data model under the high-level decision control of designers.

[0004] In a first aspect, embodiments of this application provide a NURBS surface editing method, applied to a NURBS surface editing system. The method includes: receiving multimodal editing input from a designer for a target NURBS curve; responding to the multimodal editing input, interactively editing the target NURBS curve based on a unified anchor point data model, wherein the anchor point data model includes at least anchor point positions, input handles, output handles, and continuity constraints; wherein the interactive editing supports seamless switching between 2D orthogonal editing mode and 3D CV editing mode; under the designer's decision control, an AI agent executes at least one standardized geometric operation corresponding to the interactive editing to obtain the target NURBS curve data; and rendering and displaying the target NURBS curve data.

[0005] In the above solution, NURBS surface modeling is achieved through a hierarchical human-machine collaborative model. The designer is only responsible for the multimodal editing input of the target NURBS curve and the control of the modeling process. AI automatically completes various standardized geometric operations, replacing traditional repetitive and mechanical standardized geometric operations. This improves the efficiency of NURBS surface modeling while maintaining human control over the modeling process. Furthermore, under the designer's high-level decision-making control, efficient interactive editing of NURBS curves can be achieved by integrating parametric constraints and freeform surface manipulation through a unified anchor point data model. Seamless switching between 2D orthogonal editing mode and 3DCV editing mode enhances editing fluency and solves the problem of fragmented modeling paradigms in traditional techniques, balancing parametric constraint accuracy with surface modeling freedom. Thus, efficient interactive editing of NURBS curves can be achieved through the efficient collaboration between AI execution and designer decision-making.

[0006] In one possible implementation, the multimodal editing input includes drawing operations on anchor points in 2D orthogonal editing mode or dragging operations on control points in 3D CV editing mode. In response to the multimodal editing input, based on a unified anchor point data model, interactive editing of the target NURBS curve is performed, including: in response to the drawing operation on anchor points in 2D orthogonal editing mode, converting the screen coordinates of multiple anchor points corresponding to the drawing operation into canvas-relative coordinates, and back-projecting the canvas-relative coordinates onto the dragging plane through an orthogonal camera to obtain the 3D world coordinates corresponding to each anchor point; the 3D world coordinates corresponding to each anchor point are used to fit the target NURBS curve; or, in response to the dragging operation on a CV in 3D CV editing mode, if the dragging operation is in 3D CV editing mode, using the position of the dragged CV as a reference point, converting the screen pixel movement corresponding to the drawing operation into the displacement increment of the 3D world coordinates in the projection plane where the CV is located; the displacement increment of the 3D world coordinates is used for fine-tuning the target NURBS curve. This implementation method achieves a precise mapping from screen displacement to 3D world coordinates.

[0007] In one possible implementation, the 2D orthogonal editing mode and the 3D CV editing mode share the same anchor point data model. Thus, editing the anchor points of a NURBS curve in 2D orthogonal editing mode automatically maps to the CV control points of the NURBS curve. Similarly, editing the CV control points of a NURBS curve in 3D CV editing mode also automatically maps to the anchor points. This synchronous update between the two editing modes solves the problem of data fragmentation between different editing modes in traditional editing methods.

[0008] In one possible implementation, the multimodal editing input includes drawing or dragging operations on a target anchor point, which can be any anchor point on the target NURBS curve. Under the designer's decision control, at least one standardized geometric operation corresponding to the interactive editing is executed, including: in response to the drawing or dragging operation on the target anchor point, calculating the angle between the tangents on both sides of the target anchor point and the curvature difference; recommending the continuity level of the target anchor point based on the angle between the tangents on both sides of the target anchor point and the curvature difference, where C2 is recommended when the angle is close to 180 degrees, C0 is recommended when the angle is acute, and C1 is recommended in other cases, and updating the anchor point data model corresponding to the target anchor point according to the continuity level of the target anchor point. Through this implementation, the system can automatically analyze the geometric features of adjacent curves and match the optimal smoothness level for each anchor point, thereby achieving intelligent assisted decision-making on the continuity level of the anchor point.

[0009] In one possible implementation, the multimodal editing input includes a modification operation on the continuity level of the target anchor point; under the designer's decision control, at least one standardized geometric operation corresponding to the interactive editing is executed, including: in response to the modification operation on the continuity level of the target anchor point, applying linkage constraints to the input handle and output handle of the anchor point according to continuity constraints, the continuity constraints including C0 independent, C1 collinear, and C2 collinear and equidistant; wherein, when dragging the output handle under C1 / C2 continuity, the input handle automatically reverses the collinearity and maintains the distance relationship; when upgrading from C0 to C1, the tangent direction is calculated using the chord length weighted angle bisector and the handle distance is set to 0.33 times the adjacent chord length; when upgrading from C0 to C2, the chord length weighted angle bisector and symmetrical distance are used; when upgrading from C1 to C2, the distance between the two handles is equalized and the collinear direction is maintained; and updating the input handle and output handle in the anchor point data model of the target anchor point. This implementation method balances the precision of parametric constraints with the shaping effect of freeform surfaces through the C0 / C1 / C2 continuity linkage rules. When designers modify the continuity level of anchor points, the system can automatically calculate the handle position without requiring designers to manually adjust the handle position, thus improving the efficiency of curve editing.

[0010] In one possible implementation, multimodal editing input includes operations on the active viewport; under the designer's decision control, at least one standardized geometric operation corresponding to the interactive editing is executed, including: determining at least one semantic layer corresponding to the active viewport based on the layer mask configured for the active viewport and the mapping relationship between the layer mask and semantic layers, wherein the semantic layers include a default layer, a boundary curve layer, a horizontal section layer, a vertical section layer, and an editing handle layer; rendering at least one semantic layer corresponding to the active viewport, and at least one semantic layer being visible in the active viewport. This implementation, through the semantic layer system and four-viewport orthogonal constraints, can reduce visual interference for the designer and significantly improve editing efficiency.

[0011] In one possible implementation, under the designer's decision control, at least one standardized geometric operation corresponding to interactive editing is executed, including: filtering the displayed curve type and locking the legal editing coordinate axes in a four-viewport environment based on the semantic layer system and viewport orthogonal orientation constraints, and according to the orthogonal orientation of the active viewport; restricting displacement to within the drawing plane during orthogonal viewport dragging, prohibiting spatial offset in the vertical plane direction; extracting anchor points according to the anchor point extraction strategy corresponding to the type of NURBS curve; wherein, if the NURBS curve type is a closed curve, the curvature abrupt change corner points are located based on the Greville horizontal coordinate, and four corner points with fixed indices are extracted as visible anchor points; if the NURBS curve type is an open curve, the curvature extreme points are filtered based on the Greville horizontal coordinate, retaining the curve's beginning and end endpoints and limiting the maximum number of intermediate anchor points to six. In this implementation, adaptive anchor point extraction based on the Greville horizontal coordinate, extracting the extreme points corresponding to the Greville horizontal coordinate as anchor points, can ensure that the anchor point positions are consistent with the parameterized structure of the NURBS curve.

[0012] In one possible implementation, the method further includes: determining the next state to jump to based on the state transition path corresponding to the design intent and the current state; executing a state transition legality verification process through an edit state manager, wherein the state transition legality verification process includes: verifying the legality of the jump from the current state to the next state according to a pre-stored legal transition table, the legal transition table including the target state that each state is allowed to jump to as defined by the finite state machine; if the jump from the current state to the next state is legal, performing at least one standardized geometric operation to merge the incremental payload corresponding to the jump from the current state to the next state into the global context, and distributing a global state change event to complete the state transition and enter the editing process corresponding to the next state, the global state change event being used by the subscription module that receives the event to update local data and views; or, if the jump from the current state to the target state is illegal, intercepting and terminating the jump to the target state. In this implementation, controlling the legality of the editing process through a finite state machine can prevent illegal operations in the curve editing process.

[0013] In one possible implementation, the multimodal editing input includes editing operations on the target NURBS curve; under the designer's decision control, at least one standardized geometric operation corresponding to the interactive editing is executed, further including: in response to the editing operation, obtaining the 3D world coordinates of the current anchor point; and executing a differentiated YOZ plane symmetry constraint propagation strategy according to the curve type, wherein the differentiated symmetry constraint propagation strategy includes: if the target NURBS curve is a horizontal cross section, obtaining a paired mirror curve, performing a YOZ plane mirror transformation on the 3D world coordinates of the current anchor point to obtain the mirror anchor point coordinates, and updating the anchor point of the corresponding index of the paired mirror curve; if the target NURBS curve is a vertical cross section, determining that the target NURBS curve is located in the YOZ symmetry plane, not performing a mirror transformation, and updating the anchor point of the target NURBS curve; if the target NURBS curve is a boundary curve, performing a YOZ plane mirror transformation on the current anchor point to obtain mirror coordinates, traversing all Greville anchor points inside the target NURBS curve, determining the index of the matching anchor point closest to the mirror coordinates, and updating the matching anchor point to the mirror coordinates. In this implementation, the efficiency of editing symmetric models is improved by real-time propagation of YOZ plane symmetry constraints.

[0014] In one possible implementation, the target NURBS curve data is rendered and displayed, including: determining in real time the bounding box of the curves enclosing the coordinates of each anchor point, the corresponding input handle, and the output handle; calculating the spatial diagonal length of the bounding box enclosing the positions of each anchor point, input handle, and output handle; mapping the spatial diagonal length to obtain the UI rendering scaling factor according to the following formula, and clamping the scaling factor to the range of [0.4, 4.0]: scale = diag 0.015 / 3.5; where diag is the length of the spatial diagonal and scale is the scaling factor; based on the scaling factor, the rendering sizes of the anchor points, input handles, and output handles corresponding to the target NURBS curve data are adaptively adjusted. In this implementation, bounding box adaptive rendering scaling adapts to models of different scales.

[0015] Secondly, embodiments of this application provide a NURBS surface editing system, including: Anchor Data Model Manager is used to store and maintain anchor positions, input handles, output handles, and continuity constraints in the anchor data model; A multi-mode editor, responding to the multi-modal editing input, interactively edits the target NURBS curve based on a unified anchor point data model. The anchor point data model includes at least anchor point positions, input handles, output handles, and continuity constraints. The interactive editing supports seamless switching between 2D orthogonal editing mode and 3D CV editing mode. The multi-mode editor includes an orthogonal camera adapter and a 3D control point editor. The orthogonal camera adapter receives multi-modal editing input for the target NURBS curve in 2D orthogonal mode, and the 3D control point editor receives multi-modal editing input for the target NURBS curve in 3D CV editing mode. An AI agent is used to execute at least one standardized geometric operation corresponding to the interactive editing under the designer's decision control to obtain the target NURBS curve data; The NURBS rendering engine is used to render and display target NURBS curve data.

[0016] In one possible implementation, the NURBS surface editing system also includes at least one of the following: A continuity constraint linkage is used to apply linkage constraints to the input and output handles according to the C0 / C1 / C2 continuity levels. The semantic layer manager is used to determine the visible semantic layers based on the layer mask of the active viewport and the mapping relationship between the layer mask and the semantic layers. Viewport axis locker, used to lock valid editing axes based on orthogonal viewport orientation; Symmetry constraint propagator, used to perform differentiated YOZ plane symmetry constraint propagation based on curve type; An edit state manager is used to control the legality of the editing process through a finite state machine; The bounding box adaptive scaler is used to adaptively adjust the rendering size of anchor points and handles based on the diagonal length of the curve bounding box.

[0017] Thirdly, embodiments of this application also provide a NURBS surface editing device, comprising: The receiving module is used to receive multimodal editing input from designers for the target NURBS curve; The editing module is used to respond to multimodal editing input and interactively edit the target NURBS curve based on a unified anchor point data model. The anchor point data model includes at least anchor point position, input handle, output handle, and continuity constraint. The interactive editing supports seamless switching between 2D orthogonal editing mode and 3D CV editing mode. The geometric operation execution module is used to have an AI agent perform at least one standardized geometric operation corresponding to the interactive editing under the designer's decision control, so as to obtain the target NURBS curve data. The rendering module is used to render and display the target NURBS curve data.

[0018] Fourthly, embodiments of this application also provide a computing device, including: a memory for storing program instructions; and a processor for calling the program instructions stored in the memory and executing the method described in the first aspect or any possible implementation thereof according to the obtained program.

[0019] Fifthly, embodiments of this application also provide a computer-readable storage medium storing a computer program or instructions, which, when executed by a processor, implement the methods in various possible designs as described in the first aspect.

[0020] In a sixth aspect, embodiments of this application also provide a computer program product that, when run on a computer, causes the computer to perform the methods in various possible designs as described in the first aspect above.

[0021] Other features and advantages of this application will be set forth in the following description. Attached Figure Description

[0022] Figure 1 A schematic diagram of the structure of a NURBS surface editing system provided in this application embodiment; Figure 2 A flowchart illustrating a NURBS surface editing method provided in this application embodiment; Figure 3 A schematic diagram of a cubic Bezier curve provided for an embodiment of this application; Figure 4 A timing diagram of orthogonal camera adaptation provided for embodiments of this application; Figure 5 This is a schematic diagram illustrating the mapping relationship between layer masks and semantic layers provided in an embodiment of this application; Figure 6 A schematic diagram of the path selection strategy provided in the embodiments of this application; Figure 7 A finite state machine editing process transition diagram provided for embodiments of this application; Figures 8A to 8D A timing diagram showing the complete process of editing the recessed features of a vehicle hood provided in this application embodiment; Figures 9A to 9B This is a schematic diagram of the timing sequence for symmetrical editing of the basic shape of the automobile shell provided in the embodiments of this application; Figure 10This application also provides a schematic diagram of a NURBS surface editing device; Figure 11 This application provides a schematic diagram of the structure of a computer device. Detailed Implementation

[0023] To make the objectives, technical solutions, and advantages of this application clearer, the application will be further described in detail below with reference to the accompanying drawings. The specific implementation methods in the method embodiments can also be applied to the device embodiments or system embodiments. In the description of this application, unless otherwise stated, "multiple" means two or more.

[0024] It should be noted that the term "and / or" in this document is merely a description of the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can represent: A existing alone, A and B existing simultaneously, or B existing alone. Furthermore, the character " / " in this document, unless otherwise specified, generally indicates that the preceding and following related objects have an "or" relationship. Also, in the description of the embodiments in this application, words such as "first" and "second" are used only for descriptive purposes and should not be construed as indicating or implying relative importance or order.

[0025] Figure 1 A schematic diagram of the structure of a NURBS surface editing system 100 provided in this application embodiment is shown below. Figure 1 As shown, the NURBS surface editing system 100 includes: a human-computer collaboration layer, an editing paradigm fusion layer, a dual-mode editing layer, a constraint and rendering layer, and a front-end NURBS engine layer. The NURBS surface editing system 100 may also include a back-end geometry kernel layer (not shown in the diagram). Figure 1 (As shown in the image), the functions of each layer are explained below: The human-machine collaboration layer defines the division of labor between the designer and the AI ​​agent. The designer makes complex, high-level decisions, while the AI ​​agent performs mechanical execution. The designer outputs natural language commands (such as "draw details," "done," "groove," "execute," etc.) to the AI ​​agent. The AI ​​agent performs geometric calculations during the interactive editing process and outputs the results, which are then sent back to the designer for review and adjustment. The human-machine collaboration layer employs a "AI execution + human decision-making" Human-in-the-Loop (HITL) model to implement the NURBS surface editing modeling process. The designer holds top-level, high-level design decision-making authority, while the AI ​​agent handles all standardized, repetitive geometric calculations / operations. The entire modeling process is subject to real-time intervention, verification, and adjustment by the designer. Compared to traditional CAD tools that rely entirely on manual or AI-automated surface editing, this embodiment forms a closed loop of human decision-making, AI execution, and human preview and correction.

[0026] The editing paradigm fusion layer integrates parametric modeling (e.g., C0 / C1 / C2 continuity constraints) and freeform surface modeling (e.g., handle / CV dragging) paradigms. The parametric modeling paradigm is driven by C0 / C1 / C2 continuity constraints, oriented towards standardized, high-precision industrial parametric design, and includes built-in continuity constraint rules. The freeform surface modeling module supports handle dragging and CV control point dragging, oriented towards organic, irregular freeform surface shapes, without strong parametric constraints. This application converts the data from both modeling paradigms into a unified anchor point data model (also called an anchor point data structure), including four attributes: anchor point position, output handle (outHandle), input handle (inHandle), and continuity constraint. By unifying CATIA-style parametric constraints and Alias-style free manipulation within the same anchor point data model, a single data structure can simultaneously carry parametric constraints and free deformation information. For example, the editing paradigm fusion layer includes an anchor data model manager for storing and maintaining anchor positions, input handles, output handles, and continuity constraints in the anchor data model.

[0027] The dual-mode editing layer comprises a finite state machine (EditStateManager), an orthogonal camera adapter (OrthoCameraAdapter), and a 3D control point editor (CV3DEditor). The OrthoCameraAdapter enables interactive editing in 2D orthogonal anchor point editing mode, while the CV3DEditor enables interactive editing in 3D control vertex (CV) editing mode. The dual-mode editing layer outputs NURBS curve data (including anchor point sequences and continuity constraints) to the front-end NURBS engine layer and the constraint and rendering layer. The OrthoCameraAdapter outputs 2D anchor point coordinates (projected onto the drag plane via the orthogonal camera), the CV3DEditor outputs 3D CV position increments (transformed via _screenDeltaToWorld), and the finite state machine (FSM) outputs state transition events and context payloads. The dual-mode editing layer also includes an editing state manager, used to control the legality of the editing process via the finite state machine.

[0028] It should be understood that the dual-mode editing layer can be extended to a multi-mode editing layer. The multi-mode editing layer includes a finite state machine and a multi-mode editor. Besides orthogonal camera adapters and 3D control point editors, the multi-mode editor can also include editors for other modes, such as a VR / AR immersive editor, used to implement interactive editing in VR / AR immersive editing mode. In VR / AR immersive editing mode, designers can directly drag anchor points and handles with gestures in the immersive 3D space, and the 6-DOF controller provides more intuitive 3D control. Designers drag anchor points and handles with gestures in the VR / AR environment, and orthogonal editing is achieved through a virtual plane in VR.

[0029] The 2D orthogonal anchor point editing mode, 3D CV editing mode, and VR / AR immersive editing mode share the same set of NURBS data (anchor point data model) and switch between them through state transitions using a finite state machine. Only one editing state can be active at a time to ensure data consistency. The VR / AR immersive editing mode offers intuitive 6-DOF control, suitable for immersive design reviews; the 2D orthogonal editing mode is suitable for precise cross-section drawing; and the 3D CV editing mode is suitable for fine-tuning surfaces. Designers can choose the most suitable mode from among the multiple editing modes based on task requirements.

[0030] In practical implementation, in 2D orthogonal editing mode and 3D CV editing mode, designers use ordinary personal computers (PCs), monitors, and mice / keyboards for editing input. Designers operate on the screen using the mouse, and the system maps screen coordinates to 3D space. In VR / AR immersive editing mode, designers use VR headsets (such as Meta Quest) or AR glasses, 6DOF controllers, and gesture recognition devices for editing input. The VR headset's built-in camera captures the designer's hand posture (using Inside-Out tracking technology), or an external camera captures gestures (such as Leap Motion). The 6DOF controller provides spatial positioning and button input. Regardless of whether the editing input source is mouse coordinates, VR gesture coordinates, or 6DOF controller coordinates, it is ultimately mapped to a unified anchor point data model. The editing process is driven by the state transition of the FSM. This unified architecture allows the system to flexibly adapt to different hardware devices, while the core NURBS editing logic remains unchanged. For ease of description, the following embodiments use 2D orthogonal anchor point editing mode and 3D CV editing mode as examples, but do not limit the number of editing modes supported by interactive editing, which will not be elaborated further below.

[0031] The constraint and rendering layer includes SymmetryManager, QuadViewportManager, and HandleRenderer. SymmetryManager outputs symmetry anchor point update instructions, QuadViewportManager outputs viewport-layer mask mappings, and HandleRenderer outputs adaptively scaled rendering parameters. For example, the constraint and rendering layer may include a continuity constraint linkage mechanism, a semantic layer manager, a viewport axis locker, and a symmetry constraint propagator. The continuity constraint linkage mechanism is used to perform linkage constraints on input and output handles based on C0 / C1 / C2 continuity levels. The semantic layer manager is used to determine visible semantic layers based on the layer mask of the active viewport and the mapping relationship between the layer mask and semantic layers. The viewport axis locker is used to lock valid edit axes based on the orthogonal viewport orientation. The symmetry constraint propagator is used to perform differential YOZ plane symmetry constraint propagation based on curve type.

[0032] The front-end NURBS engine layer includes an anchor-based curve editor (AnchorBasedCurveComposer, used to convert anchor points to NURBS curve data), a NURBS curve evaluator (NURBSCurveEvaluator, used to perform DeBoor evaluation), and a bridge adapter (BridgeAdapter, used to bridge the front-end and back-end). AnchorBasedCurveComposer outputs NURBS curve data (e.g., degree=3, cvs, knots), NURBSSCurveEvaluator outputs the coordinates of sampling points on the curve, and BridgeAdapter outputs the front-end and back-end communication protocol data. For example, the front-end NURBS engine layer may include a bounding box adaptive scaler to adaptively adjust the rendering size of anchor points and handles based on the diagonal length of the curve bounding box.

[0033] The backend geometry kernel layer is bridged by BridgeAdapter; PythonOCC performs operations such as surface projection, clipping, and feature construction, and outputs the clipped NURBS surface.

[0034] Figure 2 A flowchart illustrating a NURBS surface editing method provided in this application embodiment is shown below. Figure 2 As shown, the method includes the following steps: Step 201: Receive multimodal editing input from the designer for the target NURBS curve.

[0035] Multimodal editing input includes, but is not limited to, at least one of the following input methods: natural language text commands, voice commands, mouse drag-and-drop input, gesture operations, sketch input, visual annotation, and other input methods.

[0036] Natural language text commands use text input, while voice commands use voice input. Examples of these commands are: draw details, finished drawing, groove, execute.

[0037] Mouse drag-and-drop input is an example of how designers can drag and drop input using the mouse in a specific editing mode. For instance, in 2D orthographic editing mode, designers can click to place anchor points in the orthographic view and precisely control the anchor point's position using the mouse. Or, in 3DCV editing mode, designers can drag CVs in the 3D perspective viewport and adjust control points using the mouse.

[0038] Gesture operation (VR / AR): Designers use gestures to drag anchor points in VR / AR space.

[0039] The sketch input allows designers to freely draw curve sketches on the canvas using a stylus or mouse. The system uses a sketch recognition algorithm to identify feature points on the hand-drawn curves, such as inflection points, endpoints, and curvature extrema. Then, the feature points are converted into NURBS anchor point sequences, and the continuity level is automatically recommended based on curvature changes.

[0040] Multimodal editing input is mapped to the state transitions of the FSM through a unified intent resolution layer. Regardless of whether the input source is mouse coordinates, VR gestures, sketch curves, or voice commands, it is ultimately mapped to a unified anchor data model to ensure data consistency across different input methods.

[0041] Visual annotation is an extended input method for multimodal editing input fusion. Its annotation objects include specific locations / areas on the surface of the 3D model or in the viewport. Designers can add visual markers on the surface of the 3D model or in the viewport. The annotation content can include: (1) Location annotation: mark a point or area on the model surface to indicate "add a feature here" (e.g., "add a groove here"); (2) Direction annotation: draw an arrow on the model to indicate the extension direction of the feature (e.g., "the groove extends in this direction"); (3) Range annotation: draw a closed area on the model to indicate the range of the feature (e.g., "add muscle lines in this area"); (4) Text annotation: add text annotations in the viewport to describe the design intent (e.g., "R5 rounded corners are needed here"). The visual annotation is implemented as follows: Designers create annotations (position points, arrow lines, closed areas, text labels) in the 3D viewport by clicking / dragging with the mouse. The annotation data is converted into a finite state machine (FSM) payload through a unified intent resolution layer. For example, position annotations are converted into a payload of the FACE_SELECTED state (face information + annotation position), and range annotations are converted into a payload of the ORTHO_EDIT state (anchor point initial position). The system automatically selects the corresponding editing mode and operation sequence according to the annotation content. The difference between visual annotation and sketch input is that sketch input generates curved shapes, while visual annotation generates design intent indicators (e.g., position, direction, range, text). Both are mapped to a unified editing process through the intent resolution layer.

[0042] Step 202: In response to multimodal editing input, interactive editing of the target NURBS curve is performed based on a unified anchor data model. The anchor data model includes at least anchor position, input handle, output handle, and continuity constraint. The interactive editing supports seamless switching between 2D orthogonal editing mode and 3D CV editing mode.

[0043] In some embodiments, the curve between the two anchor points is a cubic Bezier curve. Figure 3A schematic diagram of a cubic Bezier curve provided for an embodiment of this application, as shown below. Figure 3 As shown, anchor point A and anchor point B form a cubic Bezier curve, and the four control points of this cubic Bezier curve are: P0 = position_A (position of anchor point A) P1 = outHandle_A (Output handle of anchor point A) P2 = inHandle_B (Input handle of anchor point B) P3 = position_B (anchor point B position) Multiple Bezier curves are combined into a complete NURBS curve by chord length parameterization and clamped node vectors.

[0044] The anchor point data model corresponding to anchor point A includes position_A (position), outHandle_A (output handle, controlling the out direction tangent), inHandle_A (input handle, controlling the in direction tangent), and continuity constraints. When the continuity of anchor point A is C0, the two handles are completely independent; when the continuity of anchor point A is C1, inHandle_A and outHandle_A are collinear (opposite direction); when inHandle_A and outHandle_A are C2, they are collinear and equidistant.

[0045] Among them, the continuity constraints include C0 being independent, C1 being collinear, and C2 being collinear and equidistant.

[0046] C0 indicates that two curve segments are only positionally continuous (endpoints coincide) at the anchor point, but their tangent directions are not continuous. That is, the two handles (inHandle and outHandle) of the anchor point are completely independent, and dragging one handle does not affect the other handle. The initial values ​​of inHandle and outHandle for newly created anchor points with a continuity level of C0 are null, and they are created only when dragged for the first time.

[0047] C1 collinearity indicates that the tangent directions of the two curve segments are continuous at the anchor point, the handles are collinear (in opposite directions), and the distances are independent. When dragging outHandle, inHandle automatically reverses the collinearity, maintaining the original distance. C1 corresponds to the CATIA-style parameter constraint mode.

[0048] C2 indicates that the two curve segments are collinear and equidistant, meaning their curvature is continuous at the anchor point, and their handles are collinear and equidistant. When dragging outHandle, inHandle automatically reverses the collinearity, and the equidistant constraint is applied all at once during the switch. C2 corresponds to the strongly parametric constraint mode.

[0049] When C0 is active, the handles are completely independent (freeform surface mode); when C1 / C2, the handles are collinear (parametric constraint mode); the handle positions are automatically calculated during continuous upgrades / downgrades.

[0050] In this embodiment, C0 corresponds to Alias-style free manipulation, and C1 / C2 corresponds to CATIA-style parameter constraints. Designers can set different continuity levels for different anchor points on the same curve, achieving a balance between local constraints and global freedom. In traditional CAD systems, continuity constraints are either checked retrospectively (Alias) or solved globally (CATIA), making flexible control at the single-point level impossible. This embodiment treats continuity as an attribute of anchor points, allowing different anchor points on the same curve to have different continuity levels.

[0051] In some embodiments, the switching path from 2D orthogonal editing mode to 3D CV editing mode includes: ORTHO_EDIT → CONFIRMED_2D → PROJECTING → EDITING_3D. The descriptions of the four editing states on this switching path are detailed in Table 1 below. This switching path is a finite state machine implementation for seamless switching between the two modes, which can ensure that the switching from 2D orthogonal editing mode to 3D CV editing mode is executed in a legal order, preventing errors caused by skipping the projection step and directly performing 3D CV editing.

[0052] Table 1

[0053] After 2D editing confirmation, the anchor point data is converted into NURBS curve data through the anchor point curve synthesizer and sent to the backend for projection onto the target surface. The projected CV data is then loaded into the 3D control point editor, achieving a seamless switch between 2D anchor point editing and 3D CV editing. Both editing paradigms share the same set of NURBS data. In 2D orthogonal editing mode, the anchor point position and handle direction determine the shape of the NURBS curve, while in 3D CV editing mode, the CV position directly corresponds to the control points of the NURBS curve.

[0054] Figure 4 A timing diagram for orthogonal camera adaptation, such as Figure 4 As shown, the process is divided into four stages according to the time sequence, which include: Phase 1: Enter 2D orthogonal editing mode.

[0055] S401, Designer initiates operation: Selects a 3D facet and sends a request to switch to 2D orthogonal editing to the editing state manager; S402, the edit state manager triggers entry into 2D orthogonal editing; For example, the edit state manager calls the core interface enterOrtho(faceGeom) according to the finite state machine, and fully delegates the orthogonal environment initialization to the orthogonal camera adapter, internally executing five logic steps S403~S406 serially; S403, Orthographic camera adapter saves the current perspective camera parameters (to be restored upon subsequent exit); S404, Orthogonal camera adapter calculates the center point and normal vector of a patch; S405, Orthogonal Camera Adapter Creates Orthogonal Camera: Sets the normal vector of the facet to the line of sight of the orthogonal camera to eliminate perspective distortion where objects appear larger when they are closer and smaller when they are farther away. S406, Orthogonal camera adapter constructs drag plane: the plane passes through the center of the patch, and the plane normal vector coincides with the patch normal vector; After the orthogonal environment is initialized, the 2D drawing channel is opened, allowing anchor point curves to be drawn on the orthogonal drag plane.

[0056] Phase 2: Backprojection of screen pixel coordinates to generate 3D anchor point coordinates.

[0057] S407, the designer drew sample points on the orthogonal plane: S408, the curve editing adapter calls the adapter method unprojectToPlane(clientX, clientY); S409 converts the screen NDC normalized coordinates into a ray, and finds the intersection point of the ray with the pre-created drag plane; S410 converts the intersection points into 3D world coordinates, and the curve editing adapter sends them back to the upper CurveEditController to generate anchor point data. In this step, the designer only performs 2D flat hand-drawn sketches, and the system automatically converts them into real 3D spatial geometric points.

[0058] Phase 3: 2D drawing completed, state machine switches to edit mode.

[0059] S411, the designer confirmed that the 2D curve drawing was complete; S412, send a state transition command to the edit state manager: transition(CONFIRMED_2D →PROJECTING); Among them, CONFIRMED_2D: 2D orthogonal drawing completed; PROJECTING: switch to 3D CV editing state; the state machine acts as the global scheduling center to complete the mutual exclusion switching of modes: lock 2D orthogonal editing and open 3D CV editing permissions.

[0060] Phase 4: 2D anchor point data is synchronized to the 3D CV editor, enabling dual-mode data sharing.

[0061] S413, the 3D CV editor loads projected CV data from the edit state manager; 2D anchor point data and 3D CV control points share the same underlying NURBS / anchor point data model; anchor points generated by 2D rendering are automatically mapped to the corresponding four NURBS CV control points, and changes to one point are updated synchronously on both sides, without data fragmentation.

[0062] S414, the designer drags and shapes CV control points in 3D space; S415, the 3D CV editor uses the _screenDeltaToWorld() method to convert the 3D view's mouse pixel offset into 3D world coordinate increments, enabling drag-and-drop editing of 3D freeform surfaces. The _screenDeltaToWorld() method can be found in the previous description and will not be repeated here.

[0063] The interactive editing of NURBS curves in this application supports both 2D orthogonal editing mode and 3D CV mode, with both modes sharing the same anchor point data model. To avoid data modification conflicts or errors caused by simultaneous editing of the anchor point data model in both modes, corresponding mutual exclusion rules can be defined using a finite state machine: only one mode is allowed to operate on the anchor point data model at a time. Taking anchor point modification as an example, when the anchor point data model is in 2D anchor point drag state, 3D CV editing operations are locked, prohibiting changes to the anchor point in the 3D perspective view; when the anchor point data model is in AI batch calculation state, all manual drag operations are locked to prevent manual interruption of the AI ​​agent's batch updates of the anchor point.

[0064] Step 203: Under the designer's decision control, the AI ​​agent performs at least one standardized geometric operation corresponding to the interactive editing to obtain the target NURBS curve data.

[0065] Step 204: Render and display the target NURBS curve data.

[0066] In some embodiments, the target NURBS curve data can be pushed to the front-end NURBS rendering module for rendering, and the rendering size of the anchor points and handles can be adaptively adjusted based on the curve bounding box. Then, the rendering result can be output to the display module for visualization.

[0067] In this embodiment, NURBS surface modeling is achieved through a hierarchical human-machine collaborative model. The designer is responsible for the multimodal editing input of the target NURBS curve and the control of the modeling process. AI automatically completes various standardized geometric operations, replacing traditional repetitive and mechanical standardized geometric operations. This improves the efficiency of NURBS surface modeling while maintaining human control over the modeling process. Furthermore, under the designer's high-level decision-making control, efficient interactive editing of NURBS curves can be achieved by integrating parametric constraints and freeform surface manipulation through a unified anchor point data model. Seamless switching between 2D orthogonal editing mode and 3DCV editing mode enhances editing fluency and solves the problem of fragmented modeling paradigms in traditional techniques, balancing parametric constraint accuracy with surface shape freedom. Thus, efficient interactive editing of NURBS curves can be achieved through the efficient collaboration between AI execution and designer decision-making.

[0068] This application also provides a method for accurately converting screen pixel increments to 3D world coordinate increments. The method calculates the world distance corresponding to each pixel based on the camera type (e.g., orthographic camera or perspective camera), achieving accurate mapping from screen displacement to 3D spatial displacement. For example, this can be achieved through a conversion algorithm.

[0069] In some embodiments, the multimodal editing input in step 201 above includes drawing operations on anchor points in 2D orthogonal editing mode; step 203 above can be implemented in the following way: in response to the drawing operation on anchor points in 2D orthogonal editing mode, the screen coordinates of multiple anchor points corresponding to the drawing operation are converted into canvas relative coordinates, and the canvas relative coordinates are back-projected onto the drag plane through an orthogonal camera to obtain the 3D world coordinates corresponding to the multiple anchor points respectively; the 3D world coordinates corresponding to the multiple anchor points are used to fit the target NURBS curve.

[0070] In some other embodiments, the multimodal editing input in step 201 above includes a drag operation on control points in 3D CV editing mode. Step 203 above can be implemented in the following way: in response to a drag operation on a CV in 3D CV editing mode, if the drag operation is in 3D CV editing mode, the screen pixel movement corresponding to the drawing operation is converted into the displacement increment of 3D world coordinates in the projection plane where the CV is located, with the position of the dragged CV as the reference point; the displacement increment of 3D world coordinates is used to finely adjust the target NURBS curve.

[0071] Below is an example of a method for calculating the world distance per pixel based on camera type, such as... Figure 4 As shown, examples of this method include: (1) Obtain the editing camera and canvas dimensions for the current viewport; (2) Calculate the camera coordinate system using the following three formulas; camRight = Right direction of the camera (after X-axis rotation); camUp = Camera's upward direction (after Y-axis rotation); camForward = The forward direction of the camera (negative Z after rotation along the Z-axis).

[0072] (3) If the editing camera is an orthographic camera, the horizontal world distance per pixel and the vertical world distance per pixel are calculated using the following two formulas: worldPerPixelX = (camera.right - camera.left) / canvas width, where worldPerPixelX is the horizontal world distance per pixel, and camera.right - camera.left is the total width of the orthographic viewport; worldPerPixelY = (camera.top - camera.bottom) / canvas height; where worldPerPixelY is the vertical world distance per pixel, and camera.top - camera.bottom is the total height of the orthographic viewport; The world distance per pixel of an orthographic camera is constant and independent of depth.

[0073] (4) If the editing camera is a perspective camera, then calculate: toRef = Dragged CV position - Camera position (reference vector) distToPlane = toRef·camForward (CV to camera line of sight distance) vFOV = Camera vertical field of view (radians) frustumHeight = 2 tan(vFOV / 2) |distToPlane| (view frustum height), where distToPlane is the distance from the CV control point to the camera along the camera's line of sight; frustumWidth = frustumHeight Aspect Ratio World distance per pixel (worldPerPixel) = View frustum size / Canvas size (world distance per pixel varies with distance) (5) Output world increment: return camRight (dxPixels worldPerPixelX) + camUp (-dyPixels worldPerPixelY) The screen X increment is mapped to the right direction of the camera, and the screen Y increment is mapped to the top direction of the camera (the Y-axis is inverted because the screen Y is downward). The dragged CV position is used as the reference point (rather than the scene center) to ensure dragging accuracy; a unified orthogonal / perspective algorithm is used for adaptive switching.

[0074] In this embodiment, the viewing distance is calculated using the dragged CV position (rather than the camera target point) as the reference point to ensure that the drag displacement corresponds precisely to the mouse movement; View plane projection: A projection plane is constructed with the CV position as the origin and the camera direction as the normal vector, and the 3D displacement is constrained within this plane; Orthogonal / perspective dual-mode adaptation: The world distance per pixel is constant under orthogonal camera, and dynamically calculated according to the viewing distance under perspective camera.

[0075] In this embodiment, the editing system can automatically analyze the geometric features of adjacent curves and match the optimal smoothness level for each anchor point, thereby achieving intelligent auxiliary decision-making on the continuity level of the anchor points.

[0076] In some embodiments, the multimodal editing input in step 201 above includes drawing or dragging operations on the target anchor point, where the target anchor point is any anchor point on the target NURBS curve; step 203 above can be implemented in the following way: in response to the drawing or dragging operation on the target anchor point, calculate the included angle and curvature difference between the tangents on both sides of the target anchor point; recommend the continuity level of the target anchor point based on the included angle and curvature difference between the tangents on both sides of the target anchor point, wherein C2 is recommended when the included angle is close to 180 degrees, C0 is recommended when the included angle is acute, and C1 is recommended in other cases, and update the anchor point data model corresponding to the target anchor point according to the continuity level of the target anchor point.

[0077] In some embodiments, the recommended continuity levels of the target anchor points are displayed as visual cues (e.g., changes in anchor point color). Designers can confirm the continuity levels recommended by the system with one click. Of course, designers can also choose not to accept the continuity levels recommended by the system and instead modify the continuity levels themselves.

[0078] In one possible implementation, the multimodal editing input in step 201 above includes modifying the continuity level of the target anchor point; this modification operation can be a one-click confirmation of the continuity level of the target anchor point recommended by the system, or it can be a manual modification of the continuity level of the target anchor point by the designer. Step 203 above can be implemented as follows: In response to the modification operation of the continuity level of the target anchor point, linkage constraints are executed on the input handle and output handle of the anchor point according to the continuity constraints, to obtain the input handle and output handle corresponding to the modified continuity constraints. The continuity constraints include C0 independent, C1 collinear, and C2 collinear and equidistant; wherein, when dragging the output handle under C1 / C2 continuity, the input handle automatically reverses the collinearity and maintains the distance relationship; when upgrading from C0 to C1, the tangent direction is calculated using the chord length weighted angle bisector and the handle distance is set to 0.33 times the adjacent chord length, wherein upgrading from C0 to C1 indicates continuity. The continuity level is upgraded from C0 to C1; when upgrading from C0 to C2, the chord length weighted angle bisector and symmetrical distance are used, where C0→C2 upgrade means the continuity level is upgraded from C0 to C2; when upgrading from C1 to C2, the distances of the two handles are equalized and collinear directions are maintained, where C1→C2 upgrade means the continuity level is upgraded from C1 to C2; when downgrading from C2 to C1, the current handle distance remains unchanged, only the equidistant constraint is removed, allowing the handle distance to change independently during subsequent drags, where C2→C1 downgrade means the continuity level is downgraded from C2 to C1; then, the input handle and output handle in the anchor point data model of the target anchor point are updated.

[0079] In some embodiments, the handle linkage rule formula for C1 continuity (tangential continuity) includes: (1) Formula for calculating the tangent direction of the anchor point: dir = normalize(outHandle - position); where outHandle - position is the direction vector from the anchor point to the output handle, and normalize() normalizes it to the unit vector dir. This formula is used to extract the tangent reference direction extending outward from the anchor point.

[0080] (2) Formula for calculating the input handle position based on the tangent direction and the original distance: inHandle = position + dir (-inDist); where inDist is the original distance from the input handle to the anchor point, the negative sign indicates that the input handle is in the opposite direction of the tangent (symmetrical to the output handle), position is the anchor point position, and dir is the tangent reference direction. In this formula, starting from the anchor point position, a distance inDist is extended along the opposite direction of dir to generate the new inHandle input handle coordinates.

[0081] When the anchor point continuity is C1, after dragging outHandle, inHandle automatically reverses its collinearity (is on the same straight line as outHandle but in the opposite direction), while maintaining the original distance inDist. This ensures that the tangent directions of the two curve segments are continuous at the anchor point.

[0082] In some embodiments, the C2 continuity (curvature continuity) handle linkage rule formula includes: (1) Calculate the tangent direction of the anchor point (see the handle linkage rule formula for C1 continuity).

[0083] (2) Calculate the average distance between the input handle and the output handle, where outDist is the distance from the output handle to the anchor point and inDist is the distance from the input handle to the anchor point.

[0084] (3) Recalculate the position of the output handle based on the tangent direction and average distance.

[0085] (4) Recalculate the input handle position based on the tangent direction and average distance (opposite direction).

[0086] When the anchor point continuity is C2, after dragging outHandle, inHandle automatically reverses the collinearity, and the distance between the two handles is equalized to the average value avgDist. C2 continuity has an additional "equidistance constraint" compared to C1 continuity, which can ensure that the two curve segments are not only tangentially continuous at the anchor point, but also have continuous curvature (curvature is related to the handle distance).

[0087] Through the above embodiments, the system automatically calculates the handle position when switching continuity levels. Designers do not need to adjust manually. They only need to select the continuity level (C0 / C1 / C2), and the system automatically calculates the optimal handle position based on the curve's geometric features (chord length, tangent direction).

[0088] In another possible implementation, multimodal editing input includes operations on the active viewport; step 203 above can be implemented by: determining at least one semantic layer corresponding to the active viewport based on the layer mask configured for the active viewport and the mapping relationship between the layer mask and semantic layers, the semantic layers including a default layer, a boundary curve layer, a horizontal section layer, a vertical section layer and an editing handle layer; rendering at least one semantic layer corresponding to the active viewport, and at least one semantic layer being visible in the active viewport.

[0089] Figure 5 This is a schematic diagram illustrating the mapping relationship between layer masks and semantic layers provided in the embodiments of this application, such as... Figure 5As shown, the five semantic layers define the categories of curve types: Layer 0 (default), Layer 1 (boundary curves), Layer 2 (cross-sections), Layer 3 (longitudinal sections), and Layer 4 (edit handles). The viewport layer mask layer defines which types of curves are visible in each viewport: Front viewport: 0|2|4, indicating that the semantic layers corresponding to masks 0, 2, and 4 are visible in the front viewport; Side viewport: 0|3|4, indicating that the semantic layers corresponding to masks 0, 3, and 4 are visible in the side viewport; Top viewport: 0|1|4, indicating that the semantic layers corresponding to masks 0, 1, and 4 are visible in the top viewport; Perspective viewport: 0|1|3|4, indicating that the semantic layers corresponding to masks 0, 1, 3, and 4 are visible in the perspective viewport.

[0090] For example, layer masks are implemented using the camera.layers.mask mechanism of the WebGL rendering engine: each viewport's camera only renders the layer objects contained in its mask, where the editing handle (Layer 4) is visible in all viewports, ensuring that editing operations across viewports are always visible. In this embodiment, when designers edit cross-sections in the front viewport, they are not disturbed by boundary curves and longitudinal sections, significantly improving editing efficiency.

[0091] In another possible implementation, step 203 above can be achieved as follows: based on the semantic layer system and viewport orthogonal orientation constraints, and according to the orthogonal orientation of the active viewport, filter the displayed curve types and lock the legal editing coordinate axes in a four-viewport environment. When dragging in the orthogonal viewport, restrict the displacement to only within the drawing plane and prohibit spatial offset in the vertical plane direction. In a specific implementation, other curve types can be filtered according to the visible curve types corresponding to each viewport in Table 2, and the legal editing coordinate axes can be locked according to the locked axes corresponding to each viewport in Table 2. Table 2

[0092] In some embodiments, anchor points are extracted according to the anchor point extraction strategy corresponding to the type of NURBS curve. Specifically, if the NURBS curve is a closed curve, the curvature abrupt change corners are located based on the Greville abscissa, and four corner points with fixed indices (e.g., indices 0, 5, 10, 15) are extracted as visible anchor points. If the NURBS curve is an open curve, the curvature extremes are filtered based on the Greville abscissa, the beginning and end endpoints of the curve are retained, and the maximum number of intermediate anchor points is limited to six.

[0093] The Greville x-coordinate is calculated as follows: x i = (t i+1 + t i+2 + ... + ti+p ) / p; Where p is the degree of the B-spline curve, for example, p=3 for a cubic curve; t i+1 Let be the value of the (i+1)th node in the node vector, where the node vector U = {t0, t...} 1, t2, ...} is the sequence of parameter nodes for the B-spline basis functions; t i+2 t is the value of the (i+2)th node in the node vector; i+p x is the value of the (i+p)th node in the node vector; i For the i-th control point (P) i The corresponding Greville x-coordinate is the representative position of the control point in the parameter domain.

[0094] The Greville abscissa determines the correspondence between control points and parameter positions. In this embodiment, adaptive anchor point extraction is performed based on the Greville abscissa, extracting the poles corresponding to the Greville abscissa as anchor points, which ensures that the anchor point positions are consistent with the parameterized structure of the NURBS curve.

[0095] This application also proposes a real-time propagation method for YOZ plane symmetry constraints, which executes a differentiated symmetry strategy based on the curve type (horizontal / vertical / boundary) to achieve automatic synchronization on the other side when one side is edited.

[0096] In another possible implementation, the multimodal editing input includes editing operations on the target NURBS curve; step 203 above can be implemented as follows: in response to the editing operation, obtain the 3D world coordinates of the current anchor point; execute a differentiated YOZ plane symmetry constraint propagation strategy according to the curve type, wherein the differentiated symmetry constraint propagation strategy includes: if the target NURBS curve is a horizontal cross section, obtain the paired mirror curve, perform a YOZ plane mirror transformation on the 3D world coordinates of the current anchor point to obtain the mirror anchor point coordinates, and update the anchor point of the corresponding index of the paired mirror curve; if the target NURBS curve is a vertical cross section, determine that the target NURBS curve is located in the YOZ symmetry plane, do not perform a mirror transformation, and update the anchor point of the target NURBS curve; if the target NURBS curve is a boundary curve, perform a YOZ plane mirror transformation on the current anchor point to obtain the mirror coordinates, traverse all Greville anchor points inside the target NURBS curve, determine the index of the matching anchor point closest to the mirror coordinates, and update the matching anchor point to the mirror coordinates.

[0097] In this implementation, a symmetry strategy is automatically selected based on the curve semantic type to avoid redundant calculations in global mirroring. Lateral cross-section mirroring across curves (L1) R1), the longitudinal section does not need to be mirrored (on the plane of symmetry), and the boundary curve and the curve search for symmetrical anchor points.

[0098] Based on any of the above embodiments, after step 201, semantic parsing can be performed on the multimodal editing input to obtain the design intent. The design intent includes the shape design information, parametric constraint design information, and feature design information corresponding to the target NURBS surface. By performing semantic parsing on different modal inputs and converting them into standardized design intents, the differences in data formats of various inputs can be eliminated. Among them, the shape design information includes, for example, 3D CV freeform surface shaping; the parametric constraint design information includes, for example, symmetry constraint modification, continuity parameter adjustment, viewport orthogonal switching, and rendering scale scaling; and the feature design information includes, for example, feature trimming and shaping.

[0099] Furthermore, based on the knowledge graph and design intent, the standardized modeling procedures corresponding to the design intent can be determined. These standardized modeling procedures are then broken down into at least one standardized geometric operation, and this operation is output to the AI ​​agent. The knowledge graph includes a mapping relationship between preset design intents and preset standardized modeling procedures. By identifying standardized modeling procedures matching the design intent from the knowledge graph, and then breaking down these procedures into at least one standardized geometric operation, the AI ​​agent can obtain the desired standardized modeling procedure.

[0100] Optionally, the standardized modeling process can be broken down into at least one standardized geometric operation in the following way: the orchestrator breaks down the standardized modeling process into a target execution path that matches the path selection strategy according to the path selection strategy. The target execution path includes at least one standardized geometric operation.

[0101] Optionally, the orchestrator can select the target execution path based on natural language instructions, giving priority to trying advanced combination operation paths, such as hole rounded corner flanging builder and groove builder, and automatically falling back to the atomic API path if it fails. Figure 6 This is a schematic diagram of the path selection strategy provided in the embodiments of this application, such as... Figure 6As shown, the system receives natural language instructions, parses these instructions, and after receiving the parsed results, the orchestrator can choose between path 1 (combined operations) and path 2 (atomic APIs). In the path selection strategy of this embodiment, the combined operations of path 1 are preferentially selected, including: combined operations HFB (hole rounding and flanging builder) / RB (groove builder) / PB (boss builder), which are high-level operations encapsulating multiple atomic operations. If path 1 is successfully selected, the result is returned; if path 1 fails, it automatically falls back to the atomic API path (or atomic path) of path 2, then executes the atomic operation sequence and returns the result. An atomic path refers to an execution path composed of a sequence of atomic operations (meta-operations), each atomic operation encapsulating a single geometric function. In the meta-operation framework of this application, atomic operations are the smallest operational units, with unified input (Context) and output (Result) interfaces. An atomic path is a sequence of atomic operations executed sequentially. For example, the atomic operation sequence corresponding to path 2 is: ECP (Exact Curve Projection) → WCE (Wireframe Curve Extension) → FBS (Fillet Corner Transition Surface Construction) → RSB (Ruled Surface Construction) → IHO (Inner Hole Trimming) → BS (BRep Stitching) → SF (Shape Repair). The arranger's fallback mechanism prioritizes combined operation paths (high efficiency), and falls back to atomic API paths (high stability) after failure. Although atomic paths have more steps and take longer, each step is an independent atomic operation. Failure allows for precise problem localization and retrying, resulting in a higher overall success rate.

[0102] Optionally, during the process of determining standardized geometric operations based on standardized modeling procedures, an orchestrator based on reinforcement learning can be configured to achieve dynamic optimization of the modeling execution path. For example, the orchestrator continuously iterates the path selection strategy by combining historical operation success rate, computation time, and designer interaction satisfaction feedback. For complex curved surface scenarios such as high curvature, atomic geometric operation paths are prioritized to improve the stability of modeling operations. Finally, the optimized execution path scheme is output to determine at least one standardized geometric operation that needs to be performed for each modeling segment.

[0103] The execution of at least one of the above standardized geometric operations depends on the current editing state. Different states allow different sets of geometric operations to be executed. In an illegal state, the corresponding geometric operation will be intercepted and not allowed to be executed; only in a legal state will the geometric operations obtained by decomposing the standardized modeling process be scheduled and executed.

[0104] Before performing at least one standardized geometric operation, the design intent can be encapsulated as a target trigger event and passed to the edit state manager. The edit state manager contains a built-in finite state machine and a mapping rule table. The mapping rule table contains predefined mapping relationships between state transition paths and trigger events. By mapping the target trigger event to the edit state manager, for example, an AI agent sends a jump request to the edit state manager, which includes the next state and an incremental payload. The edit state manager performs a state transition validity verification process on the jump path corresponding to the target trigger event. The jump paths corresponding to the target trigger event are shown in Table 1 below. The state transition validity verification process includes: according to the pre-stored valid transition table, verifying the validity of the jump from the current state to the next state in the jump path corresponding to the target trigger event, and validating the transition. The table change includes the target state that each state defined by the finite state machine is allowed to jump to. If the jump from the current state to the next state is legal, at least one standardized geometric operation is executed to merge the incremental payload corresponding to the jump from the current state to the next state into the global context, distribute the global state change event, complete the state jump, and enter the editing process corresponding to the target state. For example, the global state change event includes from (original state), to (target state), payload (additional data), and context (current context). The global state change event is used by the subscription module that receives the event to update local data and view. The UI layer listens for this event through the subscription mechanism and updates the interface state. Alternatively, if the jump from the current state to the next state is illegal, the jump to the target state is terminated, and the corresponding geometric operation is intercepted.

[0105] The `_context` parameter serves to persist editing context information between state transitions, storing face geometry, anchor data, curve data, and closure states. For example, in the `FACE_SELECTED` state, the payload carries `{faceGeom: face geometry information}`; in the `ORTHO_EDIT` state, the payload carries `{anchors: anchor array, isClosed: closure state}`; in the `CONFIRMED_2D` state, `_context` already contains complete 2D editing data; and in the `PROJECTING` state, anchor data is read from `_context` for projection. Through the context passing mechanism of this application, each state transition can carry a payload, which is automatically merged into `_context`. This ensures data continuity across states, allowing each state to access the editing data accumulated in previous states without needing to re-transmit the data.

[0106]

[0107] The above valid conversion table can be as follows: Figure 3 The representation of the finite state machine editing process flow diagram shown is set in the edit state manager. It should be understood that a valid transition table can also be represented in other ways, and this application does not impose any restrictions on this. Figure 7 As shown, the finite state machine defines 14 states, including 12 active states and 2 boundary states. The two boundary states are Idle and Error. In the Idle state, the system has not loaded any models. The Error state is an abnormal state entered after an operation fails, and can be reset back to Idle. The complete editing flow is as follows: IMPORTING → LOADED → FACE_SELECTED → 2D Editing → CONFIRMED_2D → PROJECTING → 3D Editing → CURVE_CONFIRMED_3D → FEATURE_SELECT → TRIMMING → LOADED. The two boundary states, Idle and Error, do not participate in the normal editing flow; they are the starting point and the exception handling state, respectively.

[0108] IMPORTING: Reading STEP / IGES file; LOADED: Model loaded, waiting for face selection; FACE_SELECTED: Surface to be edited selected; ORTHO_EDIT: Drawing / editing anchor points in 2D orthogonal view; CURVE_DRAWN: Anchor point curve drawing completed; CONFIRMED_2D: Designer confirms 2D editing complete; PROJECTING: 2D curve projected onto 3D surface; EDITING_3D: Dragging CV in 3D perspective viewport; CURVE_CONFIRMED_3D: 3D CV editing complete; FEATURE_SELECT: Selecting feature type such as groove / boob; SECTION_EDIT: Editing section line; TRIMMING: Performing trimming / feature operation.

[0109] In one possible implementation, rendering and displaying the target NURBS curve data can be achieved by: determining the curve bounding box enclosing the coordinates of each anchor point, the corresponding input handle, and the output handle in real time; calculating the spatial diagonal length of the curve bounding box enclosing the positions of each anchor point, input handle, and output handle, and then calculating the length of the curve bounding box according to scale = diag. A UI rendering scaling factor is obtained by mapping 0.015 / 3.5, and the scaling factor is clamped to the range of [0.4, 4.0]. Based on the scaling factor, the rendering size of the anchor points, input handles, and output handles corresponding to the target NURBS curve data is adaptively adjusted. Through this implementation method, the rendering size of the anchor points, handles, and CVs is dynamically calculated based on the diagonal length of the curve bounding box, which can solve the pain points of traditional fixed-size rendering. For extremely small models, the control points are too large and obstruct the curve, while for extremely large models, the control points are too small and difficult to click, ensuring that the visual size of interactive controls is moderate and the picking is stable under any scale model.

[0110] In one possible implementation, the interactive editing in this application embodiment also supports multi-user collaborative editing, that is, multiple designers simultaneously edit different curves of the same model, and resolve conflicts through Operational Transformation (OT) or Conflict-free Replicated Data Type (CRDT), extending symmetric constraints from single-machine propagation to cross-user propagation.

[0111] The following examples illustrate potential conflict scenarios and solutions during collaborative editing by multiple people.

[0112] Conflict Scenario 1: Concurrent Modification of the Same Anchor Point; Scenario: Designer A drags anchor point #3 to position P1, while designer B simultaneously drags the same anchor point #3 to position P2; OT Solution: The system records the timing of the two operations. The operation arriving first (e.g., A's P1) is executed directly. The operation arriving later (B's P2) is transformed before execution, and the target position of operation B is adjusted based on the state already generated by operation A. The final position of anchor point #3 is the transformed P2', not the original P2. OT guarantees that the two operations eventually converge to the same result on all replicas. CRDT Solution: Anchor point positions use a CRDT data structure (e.g., Last-Write-Wins Register), with each operation accompanied by a timestamp; the operation with the later timestamp between P1 and P2 automatically wins, and all replicas eventually converge to the same position. No operation transformation is required, but earlier modifications may be lost.

[0113] Conflict Scenario 2: Conflict in Continuity Constraint Settings; Scenario: Designer A sets anchor point #3 to C1, while Designer B simultaneously sets anchor point #3 to C2; Solution using OT: Continuity settings are discrete value operations, which OT converts into "set merging," ultimately determining the continuity constraint with the stronger one (C2 > C1 > C0). Solution using CRDT: Using LWW-Element-Set, C2 with the later timestamp wins.

[0114] Conflict Scenario 3: Cross-user propagation of symmetric constraints; Scenario: Designer A is editing the anchor point of the L1 curve, and the symmetric constraint automatically updates the R1 curve. Simultaneously, Designer B is editing the same anchor point of the R1 curve. Solution: The propagation of symmetric constraints is extended from single-machine to cross-user. A's L1 edit triggers an R1 update, which conflicts with B's R1 edit. The system merges the OT / CRDT operations, merging A's symmetric update and B's direct edit according to priority. Generally, direct edit takes precedence over automatic symmetric update.

[0115] Based on any of the above embodiments, the interactive editing in this application further supports time-series editing history and parameter backtracking. Each editing operation (anchor point dragging, continuous switching, feature execution) is recorded as a time-series event. Designers can backtrack to any historical state through the timeline, modify parameters, and automatically re-execute subsequent operations.

[0116] Below is a specific example of editing a recessed feature on a car hood.

[0117] Figures 8A to 8D A timing diagram illustrating the complete process of editing the hood recess feature provided in this application embodiment. (See attached diagram.) Figures 8A to 8D As shown, the process consists of five stages. For stages 1 and 2, please refer to [link / reference needed]. Figure 8A For stage 3, please refer to [link / reference]. Figure 8B For stage 4, please refer to [link / reference]. Figure 8C For stage 5, please refer to [link / reference]. Figure 8D The following sections will introduce stages 1 through 5 respectively: Phase 1, Importing the Model, please refer to [link / reference] Figure 8A .

[0118] S11, Designer issues instruction: Import hood STEP file; S12, the AI ​​agent calls StepFileReader to read the STEP file, parses it to generate NURBS surface JSON data, and sends it to the entire module; S13, Data loading complete, AI agent triggers state transition: transition(LOADED), system enters model ready state.

[0119] Phase 2: Select the facet and enter 2D orthographic editing. Please refer to [link / reference]. Figure 8A .

[0120] S21, the designer issued the instruction: Draw the details; S22, the AI ​​agent triggers a state transition: transition(FACE_SELECTED), which notifies the state manager to edit; S23, the state manager calls enterOrtho(patch geometry data) and sends instructions to the orthogonal camera adapter to complete the orthogonal camera initialization; S24, orthogonal camera ready, trigger state transition: transition(ORTHO_EDIT), lock 2D orthogonal editing working state.

[0121] Phase 3: 2D Anchor Point Drawing (Dual-Mode 2D Orthogonal Editing), please refer to [link / reference]. Figure 8B .

[0122] S31, the designer places anchor points on the orthogonal plane; S32, the orthogonal camera adapter executes unprojectToPlane(screenX, screenY): intersects the NDC screen ray with the dragged plane, outputs 3D world coordinates, and eliminates perspective distortion; S33, the orthogonal camera adapter, transmits 3D world coordinates to the curve editing controller; S34, the curve editing controller executes buildCurveFromAnchors(anchor set, whether closed): S35, the bridging adapter calls the adaptive curve generation component to automatically generate chord length parameterization and node vectors; S36, Bridge adapter outputs standardized NURBS curve data; S37, the curve editing controller callback HandleRender renders in real time (adaptive scaling), and the viewport previews the 2D curve in real time; S38, Designer Operation: Right-click to switch anchor point continuity C0→C1; S39, the controller executes setSelectedAnchorContinuity(C1), automatically calculates the chord length weighted angle bisector calculation handle; S40, the designer confirms the closed curve, triggering a state transition: transition(CONFIRMED_2D), exiting the pure 2D drawing state; Phase 4: 3D Projection + 3D CV Free Editing (Seamless Switching Between Dual Modes), please refer to [link / reference]. Figure 8C .

[0123] S41, the designer confirms "it's done", meaning the 2D curve is complete; S42, AI agent triggers state transition: transition(PROJECTING), transitions to the projected state; S43, the AI ​​agent calls ExactCurveProjector to accurately project the 2D closed contour onto the original body base surface; S44, the AI ​​agent loads the projected 3D control point (CV) data into the 3D CV editor; S45, the AI ​​agent triggers a state transition: transition(EDITING_3D), switching to 3D free-form shaping mode; S46, the designer drags control points in the 3D perspective viewport to adjust the curve; S47, the 3D CV editor executes _screenDeltaToWorld(), which converts the screen pixel displacement increment into a 3D world coordinate increment; S48, Designers can right-click to toggle CV continuity; S49, 3D CV editor triggers status confirmation: transition(CURVE_CONFIRMED_3D).

[0124] Phase 5: Feature Selection + Trimming Execution (Groove Feature Forming), please refer to [link / reference]. Figure 8D .

[0125] S51, the designer selects the feature area and issues the instruction: "groove"; S52, the AI ​​agent triggers the transition(FEATURE_SELECT) feature selection state; S53, the designer clicks "Execute"; S54, the AI ​​agent triggers the transition (TRIMMING) trimming process; S55, the bridging adapter sends a standardized pruning operator sequence to the backend Python OCC geometry kernel: ECP-WCE-FBS-RSB-IHO-BS-SF; S56, the underlying geometric kernel generates the clipped surface; S57, the calculation is complete, and the AI ​​agent triggers transition (LOADED); S58, the AI ​​agent notifies the designer: the groove feature has been created.

[0126] In the above embodiments, the entire timing chain realizes STEP import → 2D orthogonal sketch drawing → curve projection to 3D surface → free fine-tuning of 3D control points → surface trimming to generate features, achieving fully automated intelligent modeling; relying on a unified anchor point data model to realize bidirectional switching between 2D / 3D editing, relying on state machine to manage the legal operation of the entire process, and separating the interactive control layer and geometric calculation kernel at the bottom layer, taking into account both the naturalness of design interaction and the accuracy of surface modeling.

[0127] Below is a specific example of symmetrical editing of the basic shape of a car body. The designer edits the cross-sectional curves of the car body in a four-viewport mode, using symmetry constraints to achieve left-right synchronization.

[0128] Figures 9A to 9B This is a schematic diagram illustrating the symmetrical editing sequence of the basic shape of the automobile shell provided in an embodiment of this application. (See attached diagram.) Figures 9A to 9B As shown, this timing process includes six stages, of which stages 1 to 4 are described in detail below. Figure 9A For stages 5 and 6, please refer to [link / reference]. Figure 9B The following sections will introduce stages 1 through 6 respectively: Phase 1: Load the cross-sectional curve and semantically divide the layers.

[0129] S11, the designer loaded a total of 16 styling curves for the whole vehicle: 4 each for the left and right horizontal sections L / R, 4 each for the longitudinal center curves F1 / F2, and boundary contours P1-P4; S12, Four-Viewport Manager assigns layers by semantic type (automatic hierarchical categorization): Lateral left and right cross sections L / R → Layer 2; Central longitudinal curve F / B → Layer 3; Boundary contour P1-P4→Layer1; Function: To isolate different functional curves into layers, preparing data for differentiated display across multiple viewports.

[0130] Phase 2: Four-viewport differentiated display.

[0131] The four-viewport manager configures layer masks for four independent viewports, enabling partitioned and isolated display without interference. When editing a certain type of curve, irrelevant lines are hidden to reduce visual clutter, and orthogonal viewports automatically lock the plane drag axis.

[0132] S21, Front Viewport: Only L / R cross section is displayed (Layer 2); That is, only Layer2 is loaded, and only the left and right horizontal cross-sectional curves L / R are displayed, focusing on cross-sectional streamline editing; S22, Side View: Only the F / B cross section is displayed (Layer 3); That is, only Layer 3 is loaded, and only the central vertical curve F / B is displayed, focusing on vertical shaping; S23, Top viewport: Only display the boundary curves of P1-P4 (Layer 1). That is, only Layer1 is loaded, and only the boundary contours of P1-P4 are displayed, focusing on contour constraints; S24, Perspective Viewport: Displays all curves; loads all layers for a full preview of the entire surface.

[0133] Phase 3: Edit the left transverse section L1 using the front viewport; S31, the designer drags the control point (CV) of L1 in the front viewport; S32, the 3D CV editor executes screenDeltaToWorld(): converts screen pixel displacement into 3D world coordinates; the front viewport is an orthographic view, and constraints are automatically applied: dragging is only allowed in the XY plane, Z-axis displacement is locked, and perspective dragging ambiguity is eliminated.

[0134] Phase 4: Real-time propagation of symmetry constraints (transverse sections require mirror synchronization)

[0135] Dragging L1 triggers the SymmetryManager to calculate the symmetric link. The horizontal section belongs to a non-central axis curve, so the right side R1 must be mirrored and synchronized. S41, the 3D CV editor calls applySymmetry('L1', 3, newPos, urvesMap) to initiate the symmetry logic; S42, identify the curve group type getCurveGroup('L1') = 'transverse (transverse section)'; S43, get mirrored pairing curves getMirrorCurves('L1') = 'R1'; S44, perform YOZ plane coordinate mirrorPoint(newPos)=(-x,y,z) on the dragged anchor point; S45 returns {MirrorCurveld: 'R1', MirrorAnchorldx: 3, Mirrorposition}, matching the anchor point with the corresponding index R1; S46, synchronously update all control points of R1; The R1 curve is refreshed in real time after synchronization, allowing for single-sided editing and double-sided synchronization.

[0136] Phase 5: Edit the F1 longitudinal section of the side view (differentiated symmetry: not mirrored).

[0137] S51, the designer drags the control point (CV) of F1 in the side viewport; S52, the 3D CV editor calls applySymmetry('F1', 2, newPos, curvesMap); S53, identify the curve group type getCurveGroup('F1') ='longitudinal' (longitudinal curve along the central axis); S54, execute isOnSymmetryPlane('F1', avgX)=true, that is, determine whether the curve lies on the YOZ symmetry plane; S55 returns null, skips the mirror operation, and will not generate repeating symmetrical curves; This achieves differentiated logic: the central axis curve does not need to be mirrored, avoiding geometric repetition and redundancy.

[0138] Phase 6: Edit the P1 boundary curve in the top viewport (match mirrored boundary anchor points)

[0139] S61, the designer drags the control point (CV) of the boundary curve P1 in the top viewport; S62, the 3D CV editor executes applySymmetry('P1', 5, newPos, curvesMap); newPos is the new coordinates, and curvesMap is the curve mapping table; S63, Symmetry constraint manager identifies curve group getCurveGroup('P1') ='boundary' (boundary contour); S64, the symmetry constraint manager calls _findSymmetricAnchor('P1', 5, anchors) to retrieve the matching anchors on the symmetric side; anchors is the set of all anchors; S65, the symmetry constraint manager executes mirrorPoint(anchors[5]), that is, to mirror the matched anchor points in YOZ coordinates; S66, return {MirrorCurveld:'P1', MirrorAnchorldx:12,Mirrorposition}; That is, it returns an object {mirrorCurveId, mirrorAnchorIdx, mirrorPosition}, which specifies the mirror curve, mirror anchor point and mirror position that need to be updated synchronously, and is used to update the control points (CV) of the symmetrical side boundary curve P1. S67, the 3D CV editor synchronously updates the CV of the boundary curve P1.

[0140] This application's embodiments solve the problem of multi-curve mixed editing interference by using multi-viewport layering, and further distinguish horizontal, center, and boundary curves through differentiated symmetry logic, enabling or disabling mirroring as needed, balancing the convenience of modeling operations with the correctness of surface geometry, and providing real-time synchronous rendering throughout the process, so what you see is what you get.

[0141] Based on the same concept, embodiments of this application also provide a NURBS surface editing device, which can perform the NURBS surface editing method described above. For example... Figure 10 As shown, the NURBS surface editing device 1000 includes a receiving module 1001, an editing module 1003, a geometric operation execution module 1004, and a rendering module 1005. Optionally, it may also include a parsing module 1002.

[0142] Receiver module 1001 is used to receive multimodal editing input from the designer for the target NURBS curve; The editing module 1003 is used to respond to multimodal editing input and interactively edit the target NURBS curve based on a unified anchor data model. The anchor data model includes at least anchor position, input handle, output handle, and continuity constraint. The interactive editing supports seamless switching between 2D orthogonal editing mode and 3D CV editing mode. The geometric operation execution module 1004 is used to execute at least one standardized geometric operation corresponding to the standardized modeling process by an AI agent under the decision control of the designer, so as to obtain the target NURBS curve data. Rendering module 1005 is used to render and display the target NURBS curve data.

[0143] Optionally, the NURBS surface editing device 1000 may further include a parsing module 1002, used to perform semantic parsing on the multimodal input to obtain the design intent. The design intent includes the shape design information, parametric constraint design information, and feature design information corresponding to the target NURBS surface. Based on the knowledge graph and the design intent, the standardized modeling procedure corresponding to the design intent is determined, and the standardized modeling procedure is decomposed into at least one standardized geometric operation. The standardized geometric operation corresponding to the standardized modeling procedure is then output to the AI ​​agent. The knowledge graph includes a mapping relationship between preset design intents and preset standardized modeling procedures.

[0144] Optionally, multimodal editing input includes drawing operations on anchor points in 2D orthogonal editing mode or dragging operations on control points in 3D CV editing mode; the editing module 1003 is used to: in response to the drawing operation on anchor points in 2D orthogonal editing mode, convert the screen coordinates of multiple anchor points corresponding to the drawing operation into canvas relative coordinates, and project the canvas relative coordinates onto the dragging plane through an orthogonal camera to obtain the 3D world coordinates corresponding to the multiple anchor points respectively; the 3D world coordinates corresponding to the multiple anchor points are used to fit the target NURBS curve; or, in response to the dragging operation on the CV in 3D CV editing mode, if the dragging operation is in 3D CV editing mode, use the position of the dragged CV as a reference point, convert the screen pixel movement corresponding to the drawing operation into the displacement increment of the 3D world coordinates in the projection plane where the CV is located; the displacement increment of the 3D world coordinates is used to finely adjust the target NURBS curve.

[0145] Optionally, the 2D orthogonal editing mode and the 3D CV editing mode share the same anchor point data model.

[0146] Optionally, the multimodal editing input includes drawing or dragging operations on the target anchor point, which is any anchor point on the target NURBS curve; the geometric operation execution module 1004 is used to: in response to the drawing or dragging operation on the target anchor point, calculate the included angle and curvature difference between the tangents on both sides of the target anchor point; recommend the continuity level of the target anchor point based on the included angle and curvature difference between the tangents on both sides of the target anchor point, wherein C2 is recommended when the included angle is close to 180 degrees, C0 is recommended when the included angle is acute, and C1 is recommended in other cases, and update the anchor point data model corresponding to the target anchor point according to the continuity level of the target anchor point.

[0147] Optionally, multimodal editing input includes modifications to the continuity level of the target anchor point; The geometric operation execution module 1004 is used to: respond to the modification operation of the continuity level of the target anchor point, perform linkage constraints on the input handle and output handle of the anchor point according to the continuity constraints, including C0 independent, C1 collinear, and C2 collinear and equidistant; wherein, when dragging the output handle under C1 / C2 continuity, the input handle automatically reverses the collinearity and maintains the distance relationship; when upgrading from C0 to C1, the tangent direction is calculated using the chord length weighted angle bisector and the handle distance is set to 0.33 times the adjacent chord length; when upgrading from C0 to C2, the chord length weighted angle bisector and symmetrical distance are used; when upgrading from C1 to C2, the distance between the two handles is equalized and the collinear direction is maintained; and update the input handle and output handle in the anchor point data model of the target anchor point.

[0148] Optionally, multimodal editing input includes operations in the active viewport; the geometry operation execution module 1004 is used to: determine at least one semantic layer corresponding to the active viewport based on the layer mask configured for the active viewport and the mapping relationship between the layer mask and the semantic layer, the semantic layer including a default layer, a boundary curve layer, a horizontal section layer, a vertical section layer and an editing handle layer; render at least one semantic layer corresponding to the active viewport, and at least one semantic layer is visible in the active viewport.

[0149] Optionally, the geometric operation execution module 1004 is used to: filter and display curve types and lock legal editing coordinate axes in a four-viewport environment based on the semantic layer system and viewport orthogonal orientation constraints, and according to the orthogonal orientation of the active viewport; restrict displacement to within the drawing plane when dragging in the orthogonal viewport, and prohibit spatial offset in the vertical plane direction; extract anchor points according to the anchor point extraction strategy corresponding to the type of NURBS curve; wherein, if the type of NURBS curve is a closed curve, the curvature abrupt change corner points are located based on the Greville horizontal coordinate and four corner points with fixed indices are extracted as visible anchor points; if the type of NURBS curve is an open curve, the curvature extreme points are filtered based on the Greville horizontal coordinate, the beginning and end endpoints of the curve are retained and the maximum number of intermediate anchor points is limited to six.

[0150] Optionally, the geometric operation execution module 1004 is further configured to: determine the next state to be transitioned to based on the state transition path corresponding to the design intent and the current state; execute a state transition legality verification process through the edit state manager, wherein the state transition legality verification process includes: verifying the legality of the transition from the current state to the next state based on a pre-stored legal transition table, the legal transition table including the target state that each state defined by the finite state machine is allowed to transition to; if the transition from the current state to the next state is legal, execute at least one standardized geometric operation to merge the incremental payload corresponding to the transition from the current state to the next state into the global context, and distribute a global state change event to complete the state transition and enter the editing process corresponding to the next state, the global state change event being used by the subscription module that receives the event to update local data and views; or, if the transition from the current state to the target state is illegal, intercept and terminate the transition to the target state.

[0151] Optionally, the multimodal editing input includes editing operations on the target NURBS curve; the geometric operation execution module 1004 is further configured to: in response to the editing operation, obtain the 3D world coordinates of the current anchor point; and execute a differentiated YOZ plane symmetry constraint propagation strategy according to the curve type, wherein the differentiated symmetry constraint propagation strategy includes: if the target NURBS curve is a transverse cross section, obtain the paired mirror curve, perform a YOZ plane mirror transformation on the 3D world coordinates of the current anchor point to obtain the mirror anchor point coordinates, and update the anchor point of the corresponding index of the paired mirror curve; if the target NURBS curve is a longitudinal cross section, determine that the target NURBS curve is located in the YOZ symmetry plane, do not perform a mirror transformation, and update the anchor point of the target NURBS curve; if the target NURBS curve is a boundary curve, perform a YOZ plane mirror transformation on the current anchor point to obtain the mirror coordinates, traverse all Greville anchor points inside the target NURBS curve, determine the index of the matching anchor point closest to the mirror coordinates, and update the matching anchor point to the mirror coordinates.

[0152] Optionally, the rendering module 1005 is used to determine the bounding box of curves enclosing the coordinates of each anchor point, the corresponding input handle, and the output handle in real time; calculate the spatial diagonal length of the bounding box enclosing the positions of each anchor point, input handle, and output handle; and obtain the UI rendering scaling factor based on the spatial diagonal length using the following formula: scale = diag 0.015 / 3.5, where diag is the length of the space diagonal, scale is the scaling factor, and the scaling factor is clamped to the range of [0.4, 4.0]; according to the clamped scaling factor, the rendering size of the anchor point, input handle and output handle corresponding to the target NURBS curve data is adaptively adjusted respectively.

[0153] Based on the same inventive concept, this application also provides a NURBS surface editing system, including an anchor point data model manager, a multi-mode editor, an AI agent, and a NURBS rendering engine. It should be understood that the functions of each component in the NURBS surface editing system provided in this embodiment can be referred to the foregoing. Figure 1 The functional descriptions of each component are not repeated here. Among them: Anchor Data Model Manager is used to store and maintain anchor positions, input handles, output handles, and continuity constraints in the anchor data model; A multi-mode editor, responding to the multi-modal editing input, interactively edits the target NURBS curve based on a unified anchor point data model. The anchor point data model includes at least anchor point positions, input handles, output handles, and continuity constraints. The interactive editing supports seamless switching between 2D orthogonal editing mode and 3D CV editing mode. The multi-mode editor includes an orthogonal camera adapter and a 3D control point editor. The orthogonal camera adapter receives multi-modal editing input for the target NURBS curve in 2D orthogonal mode, and the 3D control point editor receives multi-modal editing input for the target NURBS curve in 3D CV editing mode. An AI agent is used to execute at least one standardized geometric operation corresponding to the interactive editing under the designer's decision control to obtain the target NURBS curve data; The NURBS rendering engine is used to render and display target NURBS curve data.

[0154] In one possible implementation, the NURBS surface editing system also includes at least one of the following: A continuity constraint linkage is used to apply linkage constraints to the input and output handles according to the C0 / C1 / C2 continuity levels. The semantic layer manager is used to determine the visible semantic layers based on the layer mask of the active viewport and the mapping relationship between the layer mask and the semantic layers. Viewport axis locker, used to lock valid editing axes based on orthogonal viewport orientation; Symmetry constraint propagator, used to perform differentiated YOZ plane symmetry constraint propagation based on curve type; An edit state manager is used to control the legality of the editing process through a finite state machine; The bounding box adaptive scaler is used to adaptively adjust the rendering size of anchor points and handles based on the diagonal length of the curve bounding box.

[0155] Based on the same inventive concept, this application also provides a computer device in its embodiments.

[0156] Please see Figure 11 This illustration shows a structural schematic diagram of a computer device provided in an embodiment of this application, such as... Figure 11 As shown, the computer device 1100 includes a memory 1101 and a processor 1102, with the processor 1102 coupled to the memory 1101. The memory 1101 is used to store program instructions, and the processor 1102 is used to call the program instructions stored in the memory 1101 and execute the NURBS surface editing method described above according to the obtained program.

[0157] Optionally, the computer device may further include an interface circuit 1103, which may be a transceiver or an input / output interface. The input / output interface is used for inputting and / or outputting information; output can be understood as sending, and input as receiving. The processor 1102 can communicate with other devices in the NURBS surface editing apparatus or other devices besides the NURBS surface editing apparatus via the interface circuit 1103 to obtain the information required to perform the above-described NURBS surface editing method.

[0158] When computer device 1100 is used to implement Figure 2 In the method shown, the processor 1102 is used to implement the functions of the receiving module 1001, the parsing module 1002, the editing module 1003, the geometric operation execution module 1004, and the rendering module 1005.

[0159] It is understood that the processor in the embodiments of this application may be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, transistor logic devices, hardware components, or any combination thereof. A general-purpose processor may be a microprocessor or any conventional processor.

[0160] The memory in the embodiments of this application may be random access memory, flash memory, read-only memory, programmable read-only memory, erasable programmable read-only memory, electrically erasable programmable read-only memory, registers, hard disk, portable hard disk, compact disc read-only memory (CD-ROM), or any other form of storage medium known in the art. An exemplary storage medium is coupled to a processor, enabling the processor to read information from and write information to the storage medium. The storage medium may also be a component of the processor.

[0161] Based on the same technical concept, embodiments of this application also provide a computer-readable storage medium storing a computer program or instructions, which, when executed by a processor, causes the computer to perform the above-described NURBS surface editing method.

[0162] Based on the same technical concept, embodiments of this application also provide a computer-readable program product that, when executed, causes a computer to perform the above-described NURBS surface editing method.

[0163] Those skilled in the art will understand that embodiments of this application can be provided as methods, systems, or computer program products. Therefore, this application can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this application can take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0164] This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to this application. It should be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart illustrations and / or block diagrams. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0165] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0166] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0167] Obviously, those skilled in the art can make various modifications and variations to this application without departing from the spirit and scope of this application. Therefore, if such modifications and variations fall within the scope of the claims of this application and their equivalents, this application also intends to include such modifications and variations.

Claims

1. A NURBS surface editing method, characterized in that, The method, applied to a NURBS surface editing system, includes: Receive multimodal editing input from designers for the target NURBS curve; In response to the multimodal editing input, the target NURBS curve is interactively edited based on a unified anchor data model. The anchor data model includes at least anchor position, input handle, output handle, and continuity constraint. The interactive editing supports seamless switching between 2D orthogonal editing mode and 3D CV editing mode. Under the designer's decision-making control, the AI ​​agent executes at least one standardized geometric operation corresponding to the interactive editing to obtain the target NURBS curve data; Render and display the target NURBS curve data.

2. The method as described in claim 1, characterized in that, The multimodal editing input includes drawing anchor points in 2D orthogonal editing mode or dragging control points in 3D CV editing mode; The interactive editing of the target NURBS curve in response to the multimodal editing input, based on a unified anchor data model, includes: In response to a drawing operation of anchor points in 2D orthogonal editing mode, the screen coordinates of multiple anchor points corresponding to the drawing operation are converted into canvas-relative coordinates. These canvas-relative coordinates are then back-projected onto the dragging plane using an orthogonal camera to obtain the 3D world coordinates corresponding to each anchor point. The 3D world coordinates corresponding to each anchor point are used to fit the target NURBS curve; or... In response to a drag operation of a CV in 3D CV editing mode, if the drag operation is in 3D CV editing mode, the screen pixel movement corresponding to the drawing operation is converted into the displacement increment of 3D world coordinates in the projection plane where the CV is located, with the position of the dragged CV as the reference point; the displacement increment of 3D world coordinates is used to finely adjust the target NURBS curve.

3. The method as described in claim 1 or 2, characterized in that, The 2D orthogonal editing mode and the 3D CV editing mode share the same anchor point data model.

4. The method as described in claim 1, characterized in that, The multimodal editing input includes drawing or dragging operations on the target anchor point, which is any anchor point on the target NURBS curve; Under the designer's decision-making control, executing at least one standardized geometric operation corresponding to the interactive editing includes: In response to the drawing or dragging operation of the target anchor point, calculate the included angle and curvature difference between the tangents on both sides of the target anchor point; The continuity level of the target anchor point is recommended based on the angle between the tangents on both sides of the target anchor point and the curvature difference. C2 is recommended when the angle is close to 180 degrees, C0 is recommended when the angle is acute, and C1 is recommended in other cases. The anchor point data model corresponding to the target anchor point is then updated based on the continuity level of the target anchor point.

5. The method as described in claim 1, characterized in that, The multimodal editing input includes operations to modify the continuity level of the target anchor point; Under the designer's decision-making control, executing at least one standardized geometric operation corresponding to the interactive editing includes: In response to a modification operation on the continuity level of the target anchor point, linkage constraints are applied to the input and output handles of the anchor point according to continuity constraints. These continuity constraints include C0 being independent, C1 being collinear, and C2 being collinear and equidistant. Specifically, when dragging the output handle under C1 / C2 continuity, the input handles automatically reverse their collinearity while maintaining their distance relationship. When upgrading from C0 to C1, the tangent direction is calculated using a chord-weighted angle bisector, and the handle distances are set to 0.33 times the adjacent chord lengths. When upgrading from C0 to C2, a chord-weighted angle bisector and symmetrical distance are used. When upgrading from C1 to C2, the distances between the two handles are equalized, and their collinear directions are maintained. Update the input handle and output handle in the anchor data model of the target anchor point.

6. The method as described in claim 1, characterized in that, The multimodal editing input includes the operation of activating the viewport; Under the designer's decision-making control, executing at least one standardized geometric operation corresponding to the interactive editing includes: The at least one semantic layer corresponding to the active viewport is determined based on the layer mask configured for the active viewport and the mapping relationship between the layer mask and the semantic layer. The semantic layer includes a default layer, a boundary curve layer, a horizontal section layer, a vertical section layer, and an editing handle layer. Render at least one semantic layer corresponding to the active viewport, and the at least one semantic layer is visible in the active viewport.

7. The method as described in claim 6, characterized in that, The step of executing at least one standardized geometric operation corresponding to the interactive editing under the designer's decision control also includes: Based on the semantic layer system and viewport orthogonal orientation constraints, and according to the orthogonal orientation of the active viewport, the curve type is filtered and the legal editing coordinate axes are locked in the four-viewport environment. When dragging in the orthogonal viewport, the displacement is restricted to the drawing plane only, and spatial offset in the vertical plane direction is prohibited. Anchor points are extracted according to the anchor point extraction strategy corresponding to the type of NURBS curve. Specifically, if the NURBS curve is a closed curve, the curvature abrupt change corners are located based on the Greville abscissa, and four corner points with fixed indices are extracted as visible anchor points. If the NURBS curve is an open curve, the curvature extremes are filtered based on the Greville abscissa, the beginning and end endpoints of the curve are retained, and the maximum number of intermediate anchor points is limited to six.

8. The method as described in claim 1, characterized in that, The method further includes: Based on the state transition path corresponding to the design intent and the current state, determine the next state to be transitioned to; The state transition validity verification process is executed by editing the state manager. The state transition validity verification process includes: verifying the validity of the transition from the current state to the next state according to the pre-stored valid transition table. The valid transition table includes the target state that each state is allowed to transition to as defined by the finite state machine. If the transition from the current state to the next state is legal, perform at least one of the standardized geometric operations to merge the incremental payload corresponding to the transition from the current state to the next state into the global context, and distribute a global state change event to complete the state transition and enter the editing process corresponding to the next state. The global state change event is used by the subscription module that receives the event to update its local data and view; or... If the transition from the current state to the target state is illegal, the transition to the target state will be blocked and terminated.

9. The method as described in claim 1, characterized in that, The multimodal editing input includes editing operations on the target NURBS curve; The step of executing at least one standardized geometric operation corresponding to the interactive editing under the designer's decision control also includes: In response to the editing operation, obtain the 3D world coordinates of the current anchor point; A differentiated YOZ plane symmetric constraint propagation strategy is executed based on the curve type, wherein the differentiated symmetric constraint propagation strategy includes: If the target NURBS curve is a horizontal cross section, obtain the paired mirror curve, perform a YOZ plane mirror transformation on the 3D world coordinates of the current anchor point to obtain the coordinates of the mirror anchor point, and update the anchor point with the corresponding index of the paired mirror curve. If the target NURBS curve is a longitudinal cross-section, determine that the target NURBS curve is located in the YOZ symmetry plane, do not perform mirror transformation, and update the anchor points of the target NURBS curve; If the target NURBS curve is a boundary curve, perform a YOZ plane mirror transformation on the current anchor point to obtain the mirror coordinates. Traverse all Greville anchor points inside the target NURBS curve, determine the index of the matching anchor point closest to the mirror coordinates, and update the matching anchor point to the mirror coordinates.

10. The method as described in claim 1, characterized in that, The rendering and display of the target NURBS curve data includes: The bounding box of the curves surrounding each anchor point coordinate, the corresponding input handle, and the output handle is determined in real time. Calculate the spatial diagonal length of the bounding box enclosing each anchor point position, input handle position, and output handle position. Based on this spatial diagonal length, map the UI rendering scaling factor using the following formula: scale = diag 0.015 / 3.5, where diag is the length of the space diagonal, scale is the scaling factor, and the scaling factor is clamped to the range [0.4, 4.0]. Based on the clamped scaling factor, the rendering sizes of the anchor points, input handles, and output handles corresponding to the target NURBS curve data are adaptively adjusted.

11. A NURBS surface editing system, characterized in that, include: Anchor Data Model Manager is used to store and maintain anchor positions, input handles, output handles, and continuity constraints in the anchor data model; A multi-modal editor, in response to the multi-modal editing input, interactively edits the target NURBS curve based on a unified anchor data model, wherein the anchor data model includes at least anchor position, input handle, output handle, and continuity constraint; The interactive editing supports seamless switching between 2D orthogonal editing mode and 3D CV editing mode. The multi-mode editor includes an orthogonal camera adapter and a 3D control point editor. The orthogonal camera adapter receives multimodal editing input of the target NURBS curve in 2D orthogonal mode, while the 3D control point editor receives multimodal editing input of the target NURBS curve in 3D CV editing mode. An AI agent is used to execute at least one standardized geometric operation corresponding to the interactive editing under the designer's decision control to obtain the target NURBS curve data; The NURBS rendering engine is used to render and display target NURBS curve data.

12. The system as claimed in claim 11, characterized in that, It also includes at least one of the following: A continuity constraint linkage is used to apply linkage constraints to the input and output handles according to the C0 / C1 / C2 continuity levels. The semantic layer manager is used to determine the visible semantic layers based on the layer mask of the active viewport and the mapping relationship between the layer mask and the semantic layers. Viewport axis locker, used to lock valid editing axes based on orthogonal viewport orientation; Symmetry constraint propagator, used to perform differentiated YOZ plane symmetry constraint propagation based on curve type; An edit state manager is used to control the legality of the editing process through a finite state machine; The bounding box adaptive scaler is used to adaptively adjust the rendering size of anchor points and handles based on the diagonal length of the curve bounding box.

13. A computing device, characterized in that, include: Memory, used to store program instructions; A processor is configured to invoke program instructions stored in the memory and execute the method as described in any one of claims 1 to 10 according to the obtained program.